All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Private Attributes | List of all members
BasicHitAnalysis::BasicHitAnalysis Class Reference
Inheritance diagram for BasicHitAnalysis::BasicHitAnalysis:
IHitHistogramTool

Public Member Functions

 BasicHitAnalysis (fhicl::ParameterSet const &pset)
 Constructor. More...
 
 ~BasicHitAnalysis ()
 Destructor. More...
 
void configure (fhicl::ParameterSet const &pset) override
 
void initializeHists (art::ServiceHandle< art::TFileService > &, const std::string &) override
 Interface for initializing the histograms to be filled. More...
 
void endJob (int numEvents) override
 Interface for method to executve at the end of run processing. More...
 
void fillHistograms (const HitPtrVec &) const override
 Interface for filling histograms. More...
 
- Public Member Functions inherited from IHitHistogramTool
virtual ~IHitHistogramTool () noexcept=default
 Virtual Destructor. More...
 

Private Attributes

std::string fLocalDirName
 Fraction for truncated mean. More...
 
std::vector< TH1D * > fHitsByWire
 
TH1D * fDriftTimes [3]
 
TH1D * fHitsByTime [3]
 
TH1D * fPulseHeight [3]
 
TH1D * fPulseHeightSingle [3]
 
TH1D * fPulseHeightMulti [3]
 
TH1D * fPulseHeightMultiMax [3]
 
TH1D * fPulseHeightLong [3]
 
TH1D * fChi2DOF [3]
 
TH1D * fNumDegFree [3]
 
TH1D * fChi2DOFSingle [3]
 
TH1D * fHitMult [3]
 
TH1D * fHitCharge [3]
 
TH1D * fHitChargeSingle [3]
 
TH1D * fHitChargeMulti [3]
 
TH1D * fHitChargeLong [3]
 
TH1D * fFitWidth [3]
 
TH1D * fFitWidthSingle [3]
 
TH1D * fFitWidthMulti [3]
 
TH1D * fFitWidthLong [3]
 
TH1D * fHitSumADC [3]
 
TH2D * fNDFVsChi2 [3]
 
TH2D * fPulseHVsWidth [3]
 
TH2D * fPulseHVsCharge [3]
 
TH1D * fBadWPulseHeight
 
TH2D * fBadWPulseHVsWidth
 
TH1D * fBadWHitsByWire
 
TProfile * fPulseHVsHitNo [3]
 
TProfile * fChargeVsHitNo [3]
 
TProfile * fChargeVsHitNoS [3]
 
TH2D * fSPHvsIdx [3]
 
TH2D * fSWidVsIdx [3]
 
TH2D * f1PPHvsWid [3]
 
TH2D * fSPPHvsWid [3]
 
TH2D * fSOPHvsWid [3]
 
TH2D * fPHRatVsIdx [3]
 
const geo::GeometryCore * fGeometry
 pointer to Geometry service More...
 

Additional Inherited Members

- Public Types inherited from IHitHistogramTool
using HitPtrVec = std::vector< art::Ptr< recob::Hit >>
 Interface for filling histograms. More...
 

Detailed Description

Definition at line 48 of file BasicHitAnalysis_tool.cc.

Constructor & Destructor Documentation

BasicHitAnalysis::BasicHitAnalysis::BasicHitAnalysis ( fhicl::ParameterSet const &  pset)
explicit

Constructor.

Parameters
psetConstructor.

Arguments:

pset - Fcl parameters.

Definition at line 141 of file BasicHitAnalysis_tool.cc.

142 {
143  fGeometry = lar::providerFrom<geo::Geometry>();
144 
145  configure(pset);
146 
147  // Report.
148  mf::LogInfo("BasicHitAnalysis") << "BasicHitAnalysis configured\n";
149 }
BasicHitAnalysis::BasicHitAnalysis::configure
void configure(fhicl::ParameterSet const &pset) override
Definition: BasicHitAnalysis_tool.cc:163
BasicHitAnalysis::BasicHitAnalysis::fGeometry
const geo::GeometryCore * fGeometry
pointer to Geometry service
Definition: BasicHitAnalysis_tool.cc:131
BasicHitAnalysis::BasicHitAnalysis::~BasicHitAnalysis ( )

Destructor.

Definition at line 153 of file BasicHitAnalysis_tool.cc.

154 {}

Member Function Documentation

void BasicHitAnalysis::BasicHitAnalysis::configure ( fhicl::ParameterSet const &  pset)
overridevirtual

Reconfigure method.

Arguments:

pset - Fcl parameter set.

Implements IHitHistogramTool.

Definition at line 163 of file BasicHitAnalysis_tool.cc.

164 {
165  fLocalDirName = pset.get<std::string>("LocalDirName", std::string("wow"));
166 }
BasicHitAnalysis::BasicHitAnalysis::fLocalDirName
std::string fLocalDirName
Fraction for truncated mean.
Definition: BasicHitAnalysis_tool.cc:89
void BasicHitAnalysis::BasicHitAnalysis::endJob ( int  numEvents)
overridevirtual

Interface for method to executve at the end of run processing.

Parameters
intnumber of events to use for normalization

Implements IHitHistogramTool.

Definition at line 426 of file BasicHitAnalysis_tool.cc.

427 {
428  if (!fHitsByWire.empty())
429  {
430  // Normalize wire profiles to be hits/event
431  double normFactor(1./numEvents);
432 
433  for(size_t idx = 0; idx < 3; idx++) fHitsByWire[idx]->Scale(normFactor);
434  }
435 
436  return;
437 }
actions::Scale
Scale(size_t pos, T factor) -> Scale< T >
void BasicHitAnalysis::BasicHitAnalysis::fillHistograms ( const HitPtrVec &  hitPtrVec) const
overridevirtual

Interface for filling histograms.

Implements IHitHistogramTool.

Definition at line 299 of file BasicHitAnalysis_tool.cc.

300 {
301  // Keep track of number of hits per view
302  size_t nHitsPerView[] = {0,0,0};
303  size_t negCount(0);
304 
305  std::vector<const recob::Hit*> hitSnippetVec;
306 
307  // Loop the hits and make some plots
308  for(const auto& hitPtr : hitPtrVec)
309  {
310  // Extract interesting hit parameters
311  const geo::WireID& wireID = hitPtr->WireID();
312  float chi2DOF = std::min(hitPtr->GoodnessOfFit(),float(249.8));
313  int numDOF = hitPtr->DegreesOfFreedom();
314  int hitMult = hitPtr->Multiplicity();
315  float peakTime = std::min(float(3199.),hitPtr->PeakTime());
316  float charge = hitPtr->Integral();
317  float sumADC = hitPtr->SummedADC();
318  float hitPH = std::min(hitPtr->PeakAmplitude(),float(149.8));
319  float hitSigma = hitPtr->RMS();
320 
321  size_t plane = wireID.Plane;
322  size_t wire = wireID.Wire;
323 
324  if (hitPH < 0.)
325  {
326  negCount++;
327  //std::cout << "Hit Plane: " << plane << ", wire: " << wire << ", T: " << peakTime << ", PH: " << hitPH << ", charge: " << charge << ", sumADC: " << sumADC << std::endl;
328  }
329 
330  nHitsPerView[plane]++;
331 
332  fHitsByWire[plane]->Fill(wire,1.);
333  fHitsByTime[plane]->Fill(peakTime, 1.);
334  fPulseHeight[plane]->Fill(std::min(float(149.5),hitPH), 1.);
335  fChi2DOF[plane]->Fill(chi2DOF, 1.);
336  fNumDegFree[plane]->Fill(numDOF, 1.);
337  fHitMult[plane]->Fill(hitMult, 1.);
338  fHitCharge[plane]->Fill(charge, 1.);
339  fFitWidth[plane]->Fill(std::min(float(19.99),hitSigma), 1.);
340  fHitSumADC[plane]->Fill(sumADC, 1.);
341  fNDFVsChi2[plane]->Fill(numDOF, chi2DOF, 1.);
342  fDriftTimes[plane]->Fill(peakTime, 1.);
343 
344  if (hitMult == 1)
345  {
346  fPulseHeightSingle[plane]->Fill(std::min(float(149.5),hitPH), 1.);
347  fFitWidthSingle[plane]->Fill(std::min(float(19.99),hitSigma), 1.);
348  fHitChargeSingle[plane]->Fill(charge, 1.);
349  fChi2DOFSingle[plane]->Fill(chi2DOF, 1.);
350  fPulseHVsWidth[plane]->Fill(std::min(float(99.9),hitPH), std::min(float(19.99),hitSigma), 1.);
351  fPulseHVsCharge[plane]->Fill(std::min(float(99.9),hitPH), std::min(float(1999.),charge), 1.);
352 
353  if (plane == 2 && hitPH < 5 && hitSigma < 2.2)
354  {
355  std::cout << "++> Plane: " << plane << ", wire: " << wire << ", peakTime: " << peakTime << ", ph: " << hitPH << ", w: " << hitSigma << std::endl;
356 
357  fBadWPulseHeight->Fill(std::min(float(149.5),hitPH),1.);
358  fBadWPulseHVsWidth->Fill(std::min(float(99.9),hitPH), std::min(float(9.99),hitSigma), 1.);
359  fBadWHitsByWire->Fill(wire,1.);
360  }
361  }
362  else
363  {
364  if (numDOF > 1)
365  {
366  fPulseHeightMulti[plane]->Fill(std::min(float(149.5),hitPH), 1.);
367  fFitWidthMulti[plane]->Fill(std::min(float(19.99),hitSigma), 1.);
368  fHitChargeMulti[plane]->Fill(charge, 1.);
369  }
370  else
371  {
372  fPulseHeightLong[plane]->Fill(std::min(float(149.5),hitPH), 1.);
373  fFitWidthLong[plane]->Fill(std::min(float(19.99),hitSigma), 1.);
374  fHitChargeLong[plane]->Fill(charge, 1.);
375  }
376  }
377 
378  // Look at hits on snippets
379  if (!hitSnippetVec.empty() && hitSnippetVec.back()->LocalIndex() >= hitPtr->LocalIndex())
380  {
381  // Only worried about multi hit snippets
382  if (hitSnippetVec.size() > 1)
383  {
384  // Sort in order of largest to smallest pulse height
385  std::sort(hitSnippetVec.begin(),hitSnippetVec.end(),[](const auto* left, const auto* right){return left->PeakAmplitude() > right->PeakAmplitude();});
386 
387  float maxPulseHeight = hitSnippetVec.front()->PeakAmplitude();
388 
389  fPulseHeightMultiMax[plane]->Fill(std::min(float(149.5),maxPulseHeight), 1.);
390 
391  for(size_t idx = 0; idx < hitSnippetVec.size(); idx++)
392  {
393  float pulseHeight = hitSnippetVec.at(idx)->PeakAmplitude();
394  float pulseWid = hitSnippetVec.at(idx)->RMS();
395  float pulseHeightRatio = pulseHeight / maxPulseHeight;
396 
397  size_t plane = hitSnippetVec.at(idx)->WireID().Plane;
398 
399  fSPHvsIdx[plane]->Fill(idx, std::min(float(99.9),pulseHeight), 1.);
400  fSWidVsIdx[plane]->Fill(idx, std::min(float(9.99),pulseWid), 1.);
401  fPHRatVsIdx[plane]->Fill(idx, pulseHeightRatio, 1.);
402 
403  if (idx == 0) fSPPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(9.99),pulseWid), 1.);
404  else fSOPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(9.99),pulseWid), 1.);
405  }
406  }
407  else
408  {
409  float pulseHeight = hitSnippetVec.front()->PeakAmplitude();
410  float pulseWid = hitSnippetVec.front()->RMS();
411  size_t plane = hitSnippetVec.front()->WireID().Plane;
412 
413  f1PPHvsWid[plane]->Fill(std::min(float(99.9),pulseHeight), std::min(float(9.99),pulseWid), 1.);
414  }
415 
416  hitSnippetVec.clear();
417  }
418 
419  hitSnippetVec.push_back(hitPtr.get());
420  }
421 
422  return;
423 }
right
walls no right
Definition: selectors.fcl:105
geo::WireID::Wire
WireID_t Wire
Index of the wire within its plane.
Definition: geo_types.h:580
left
walls no left
Definition: selectors.fcl:105
geo::PlaneID::Plane
PlaneID_t Plane
Index of the plane within its TPC.
Definition: geo_types.h:493
geo::WireID::WireID
constexpr WireID()=default
Default constructor: an invalid TPC ID.
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
void BasicHitAnalysis::BasicHitAnalysis::initializeHists ( art::ServiceHandle< art::TFileService > &  tfs,
const std::string &  dirName 
)
overridevirtual

Interface for initializing the histograms to be filled.

Begin job method.

Parameters
TFileServicehandle to the TFile service
stringsubdirectory to store the hists in

Implements IHitHistogramTool.

Definition at line 170 of file BasicHitAnalysis_tool.cc.

171 {
172  // Make a directory for these histograms
173  art::TFileDirectory dir = tfs->mkdir(dirName.c_str());
174 
175  fHitsByWire.resize(fGeometry->Nplanes());
176 
177  fHitsByWire[0] = dir.make<TH1D>("HitsByWire0", ";Wire #", fGeometry->Nwires(0), 0., fGeometry->Nwires(0));
178  fHitsByWire[1] = dir.make<TH1D>("HitsByWire1", ";Wire #", fGeometry->Nwires(1), 0., fGeometry->Nwires(1));
179  fHitsByWire[2] = dir.make<TH1D>("HitsByWire2", ";Wire #", fGeometry->Nwires(2), 0., fGeometry->Nwires(2));
180 
181  fDriftTimes[0] = dir.make<TH1D>("DriftTime0", ";time(ticks)", 2048, 0., 4096.);
182  fDriftTimes[1] = dir.make<TH1D>("DriftTime1", ";time(ticks)", 2048, 0., 4096.);
183  fDriftTimes[2] = dir.make<TH1D>("DriftTime2", ";time(ticks)", 2048, 0., 4096.);
184 
185  fHitsByTime[0] = dir.make<TH1D>("HitsByTime0", ";Tick", 1024, 0., 4096.);
186  fHitsByTime[1] = dir.make<TH1D>("HitsByTime1", ";Tick", 1024, 0., 4096.);
187  fHitsByTime[2] = dir.make<TH1D>("HitsByTime2", ";Tick", 1024, 0., 4096.);
188 
189  fPulseHeight[0] = dir.make<TH1D>("PulseHeight0", "PH (ADC)", 300, 0., 150.);
190  fPulseHeight[1] = dir.make<TH1D>("PulseHeight1", "PH (ADC)", 300, 0., 150.);
191  fPulseHeight[2] = dir.make<TH1D>("PulseHeight2", "PH (ADC)", 300, 0., 150.);
192  fPulseHeightSingle[0] = dir.make<TH1D>("PulseHeightS0", "PH (ADC)", 300, 0., 150.);
193  fPulseHeightSingle[1] = dir.make<TH1D>("PulseHeightS1", "PH (ADC)", 300, 0., 150.);
194  fPulseHeightSingle[2] = dir.make<TH1D>("PulseHeightS2", "PH (ADC)", 300, 0., 150.);
195  fPulseHeightMultiMax[0] = dir.make<TH1D>("PulseHeightMM0", "PH (ADC)", 300, 0., 150.);
196  fPulseHeightMultiMax[1] = dir.make<TH1D>("PulseHeightMM1", "PH (ADC)", 300, 0., 150.);
197  fPulseHeightMultiMax[2] = dir.make<TH1D>("PulseHeightMM2", "PH (ADC)", 300, 0., 150.);
198  fPulseHeightMulti[0] = dir.make<TH1D>("PulseHeightM0", "PH (ADC)", 300, 0., 150.);
199  fPulseHeightMulti[1] = dir.make<TH1D>("PulseHeightM1", "PH (ADC)", 300, 0., 150.);
200  fPulseHeightMulti[2] = dir.make<TH1D>("PulseHeightM2", "PH (ADC)", 300, 0., 150.);
201  fPulseHeightLong[0] = dir.make<TH1D>("PulseHeightL0", "PH (ADC)", 300, 0., 150.);
202  fPulseHeightLong[1] = dir.make<TH1D>("PulseHeightL1", "PH (ADC)", 300, 0., 150.);
203  fPulseHeightLong[2] = dir.make<TH1D>("PulseHeightL2", "PH (ADC)", 300, 0., 150.);
204  fChi2DOF[0] = dir.make<TH1D>("Chi2DOF0", "Chi2DOF", 502, -1., 250.);
205  fChi2DOF[1] = dir.make<TH1D>("Chi2DOF1", "Chi2DOF", 502, -1., 250.);
206  fChi2DOF[2] = dir.make<TH1D>("Chi2DOF2", "Chi2DOF", 502, -1., 250.);
207  fNumDegFree[0] = dir.make<TH1D>("NumDegFree0", "NDF", 200, 0., 200.);
208  fNumDegFree[1] = dir.make<TH1D>("NumDegFree1", "NDF", 200, 0., 200.);
209  fNumDegFree[2] = dir.make<TH1D>("NumDegFree2", "NDF", 200, 0., 200.);
210  fChi2DOFSingle[0] = dir.make<TH1D>("Chi2DOFS0", "Chi2DOF", 502, -1., 250.);
211  fChi2DOFSingle[1] = dir.make<TH1D>("Chi2DOFS1", "Chi2DOF", 502, -1., 250.);
212  fChi2DOFSingle[2] = dir.make<TH1D>("Chi2DOFS2", "Chi2DOF", 502, -1., 250.);
213  fHitMult[0] = dir.make<TH1D>("HitMult0", "# hits", 15, 0., 15.);
214  fHitMult[1] = dir.make<TH1D>("HitMult1", "# hits", 15, 0., 15.);
215  fHitMult[2] = dir.make<TH1D>("HitMult2", "# hits", 15, 0., 15.);
216  fHitCharge[0] = dir.make<TH1D>("HitCharge0", "Charge", 1000, 0., 2000.);
217  fHitCharge[1] = dir.make<TH1D>("HitCharge1", "Charge", 1000, 0., 2000.);
218  fHitCharge[2] = dir.make<TH1D>("HitCharge2", "Charge", 1000, 0., 2000.);
219  fHitChargeSingle[0] = dir.make<TH1D>("HitChargeS0", "Charge", 1000, 0., 2000.);
220  fHitChargeSingle[1] = dir.make<TH1D>("HitChargeS1", "Charge", 1000, 0., 2000.);
221  fHitChargeSingle[2] = dir.make<TH1D>("HitChargeS2", "Charge", 1000, 0., 2000.);
222  fHitChargeMulti[0] = dir.make<TH1D>("HitChargeM0", "Charge", 1000, 0., 2000.);
223  fHitChargeMulti[1] = dir.make<TH1D>("HitChargeM1", "Charge", 1000, 0., 2000.);
224  fHitChargeMulti[2] = dir.make<TH1D>("HitChargeM2", "Charge", 1000, 0., 2000.);
225  fHitChargeLong[0] = dir.make<TH1D>("HitChargeL0", "Charge", 1000, 0., 2000.);
226  fHitChargeLong[1] = dir.make<TH1D>("HitChargeL1", "Charge", 1000, 0., 2000.);
227  fHitChargeLong[2] = dir.make<TH1D>("HitChargeL2", "Charge", 1000, 0., 2000.);
228  fFitWidth[0] = dir.make<TH1D>("FitWidth0", "Width", 100, 0., 20.);
229  fFitWidth[1] = dir.make<TH1D>("FitWidth1", "Width", 100, 0., 20.);
230  fFitWidth[2] = dir.make<TH1D>("FitWidth2", "Width", 100, 0., 20.);
231  fFitWidthSingle[0] = dir.make<TH1D>("FitWidthS0", "Width", 100, 0., 20.);
232  fFitWidthSingle[1] = dir.make<TH1D>("FitWidthS1", "Width", 100, 0., 20.);
233  fFitWidthSingle[2] = dir.make<TH1D>("FitWidthS2", "Width", 100, 0., 20.);
234  fFitWidthMulti[0] = dir.make<TH1D>("FitWidthM0", "Width", 100, 0., 20.);
235  fFitWidthMulti[1] = dir.make<TH1D>("FitWidthM1", "Width", 100, 0., 20.);
236  fFitWidthMulti[2] = dir.make<TH1D>("FitWidthM2", "Width", 100, 0., 20.);
237  fFitWidthLong[0] = dir.make<TH1D>("FitWidthL0", "Width", 100, 0., 20.);
238  fFitWidthLong[1] = dir.make<TH1D>("FitWidthL1", "Width", 100, 0., 20.);
239  fFitWidthLong[2] = dir.make<TH1D>("FitWidthL2", "Width", 100, 0., 20.);
240  fHitSumADC[0] = dir.make<TH1D>("SumADC0", "Sum ADC", 1000, 0., 2000.);
241  fHitSumADC[1] = dir.make<TH1D>("SumADC1", "Sum ADC", 1000, 0., 2000.);
242  fHitSumADC[2] = dir.make<TH1D>("SumADC2", "Sum ADC", 1000, 0., 2000.);
243 
244  fNDFVsChi2[0] = dir.make<TH2D>("NDFVsChi20", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
245  fNDFVsChi2[1] = dir.make<TH2D>("NDFVsChi21", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
246  fNDFVsChi2[2] = dir.make<TH2D>("NDFVsChi22", ";NDF;Chi2", 50, 0., 50., 101, -1., 100.);
247 
248  fPulseHVsWidth[0] = dir.make<TH2D>("PHVsWidth0", ";PH;Width", 100, 0., 100., 100, 0., 20.);
249  fPulseHVsWidth[1] = dir.make<TH2D>("PHVsWidth1", ";PH;Width", 100, 0., 100., 100, 0., 20.);
250  fPulseHVsWidth[2] = dir.make<TH2D>("PHVsWidth2", ";PH;Width", 100, 0., 100., 100, 0., 20.);
251 
252  fPulseHVsCharge[0] = dir.make<TH2D>("PHVsChrg0", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
253  fPulseHVsCharge[1] = dir.make<TH2D>("PHVsChrg1", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
254  fPulseHVsCharge[2] = dir.make<TH2D>("PHVsChrg2", ";PH;Q", 100, 0., 100., 100, 0., 2000.);
255 
256  fPulseHVsHitNo[0] = dir.make<TProfile>("PHVsNo0", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
257  fPulseHVsHitNo[1] = dir.make<TProfile>("PHVsNo1", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
258  fPulseHVsHitNo[2] = dir.make<TProfile>("PHVsNo2", ";Hit #;PH", 1000, 0., 1000., 0., 100.);
259 
260  fChargeVsHitNo[0] = dir.make<TProfile>("QVsNo0", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
261  fChargeVsHitNo[1] = dir.make<TProfile>("QVsNo1", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
262  fChargeVsHitNo[2] = dir.make<TProfile>("QVsNo2", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
263 
264  fChargeVsHitNoS[0] = dir.make<TProfile>("QVsNoS0", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
265  fChargeVsHitNoS[1] = dir.make<TProfile>("QVsNoS1", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
266  fChargeVsHitNoS[2] = dir.make<TProfile>("QVsNoS2", ";Hit No;Q", 1000, 0., 1000., 0., 2000.);
267 
268  fBadWPulseHeight = dir.make<TH1D>("BWPulseHeight", "PH (ADC)", 300, 0., 150.);
269  fBadWPulseHVsWidth = dir.make<TH2D>("BWPHVsWidth", ";PH;Width", 100, 0., 100., 100, 0., 10.);
270  fBadWHitsByWire = dir.make<TH1D>("BWHitsByWire", ";Wire #", fGeometry->Nwires(2), 0., fGeometry->Nwires(2));
271 
272  fSPHvsIdx[0] = dir.make<TH2D>("SPHVsIdx0", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
273  fSPHvsIdx[1] = dir.make<TH2D>("SPHVsIdx1", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
274  fSPHvsIdx[2] = dir.make<TH2D>("SPHVsIdx2", ";PH;Idx", 30, 0., 30., 100, 0., 100.);
275 
276  fSWidVsIdx[0] = dir.make<TH2D>("SWidsIdx0", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
277  fSWidVsIdx[1] = dir.make<TH2D>("SWidsIdx1", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
278  fSWidVsIdx[2] = dir.make<TH2D>("SWidsIdx2", ";Width;Idx", 30, 0., 30., 100, 0., 10.);
279 
280  f1PPHvsWid[0] = dir.make<TH2D>("1PPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 10.);
281  f1PPHvsWid[1] = dir.make<TH2D>("1PPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 10.);
282  f1PPHvsWid[2] = dir.make<TH2D>("1PPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 10.);
283 
284  fSPPHvsWid[0] = dir.make<TH2D>("SPPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 10.);
285  fSPPHvsWid[1] = dir.make<TH2D>("SPPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 10.);
286  fSPPHvsWid[2] = dir.make<TH2D>("SPPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 10.);
287 
288  fSOPHvsWid[0] = dir.make<TH2D>("SOPHVsWid0", ";PH;Width", 100, 0., 100., 100, 0., 10.);
289  fSOPHvsWid[1] = dir.make<TH2D>("SOPHVsWid1", ";PH;Width", 100, 0., 100., 100, 0., 10.);
290  fSOPHvsWid[2] = dir.make<TH2D>("SOPHVsWid2", ";PH;Width", 100, 0., 100., 100, 0., 10.);
291 
292  fPHRatVsIdx[0] = dir.make<TH2D>("PHRatVsIdx0", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
293  fPHRatVsIdx[1] = dir.make<TH2D>("PHRatVsIdx1", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
294  fPHRatVsIdx[2] = dir.make<TH2D>("PHRatVsIdx2", ";PHRat;Idx", 30, 0., 30., 51, 0., 1.02);
295 
296  return;
297 }
geo::GeometryCore::Nwires
unsigned int Nwires(unsigned int p, unsigned int tpc=0, unsigned int cstat=0) const
Returns the total number of wires in the specified plane.
Definition: GeometryCore.h:3345
geo::GeometryCore::Nplanes
unsigned int Nplanes(unsigned int tpc=0, unsigned int cstat=0) const
Returns the total number of wire planes in the specified TPC.
Definition: GeometryCore.h:2854
BasicHitAnalysis::BasicHitAnalysis::fGeometry
const geo::GeometryCore * fGeometry
pointer to Geometry service
Definition: BasicHitAnalysis_tool.cc:131
dropbox.dir
tuple dir
Definition: dropbox.py:28
tfs
art::ServiceHandle< art::TFileService > tfs
Definition: NuVertexChargeTree_module.cc:254

Member Data Documentation

TH2D* BasicHitAnalysis::BasicHitAnalysis::f1PPHvsWid[3]
private

Definition at line 125 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fBadWHitsByWire
private

Definition at line 118 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fBadWPulseHeight
private

Definition at line 116 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fBadWPulseHVsWidth
private

Definition at line 117 of file BasicHitAnalysis_tool.cc.

TProfile* BasicHitAnalysis::BasicHitAnalysis::fChargeVsHitNo[3]
private

Definition at line 120 of file BasicHitAnalysis_tool.cc.

TProfile* BasicHitAnalysis::BasicHitAnalysis::fChargeVsHitNoS[3]
private

Definition at line 121 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fChi2DOF[3]
private

Definition at line 100 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fChi2DOFSingle[3]
private

Definition at line 102 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fDriftTimes[3]
private

Definition at line 93 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fFitWidth[3]
private

Definition at line 108 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fFitWidthLong[3]
private

Definition at line 111 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fFitWidthMulti[3]
private

Definition at line 110 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fFitWidthSingle[3]
private

Definition at line 109 of file BasicHitAnalysis_tool.cc.

const geo::GeometryCore* BasicHitAnalysis::BasicHitAnalysis::fGeometry
private

pointer to Geometry service

Definition at line 131 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitCharge[3]
private

Definition at line 104 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitChargeLong[3]
private

Definition at line 107 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitChargeMulti[3]
private

Definition at line 106 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitChargeSingle[3]
private

Definition at line 105 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitMult[3]
private

Definition at line 103 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitsByTime[3]
private

Definition at line 94 of file BasicHitAnalysis_tool.cc.

std::vector<TH1D*> BasicHitAnalysis::BasicHitAnalysis::fHitsByWire
private

Definition at line 92 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fHitSumADC[3]
private

Definition at line 112 of file BasicHitAnalysis_tool.cc.

std::string BasicHitAnalysis::BasicHitAnalysis::fLocalDirName
private

Fraction for truncated mean.

Definition at line 89 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fNDFVsChi2[3]
private

Definition at line 113 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fNumDegFree[3]
private

Definition at line 101 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fPHRatVsIdx[3]
private

Definition at line 128 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fPulseHeight[3]
private

Definition at line 95 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fPulseHeightLong[3]
private

Definition at line 99 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fPulseHeightMulti[3]
private

Definition at line 97 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fPulseHeightMultiMax[3]
private

Definition at line 98 of file BasicHitAnalysis_tool.cc.

TH1D* BasicHitAnalysis::BasicHitAnalysis::fPulseHeightSingle[3]
private

Definition at line 96 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fPulseHVsCharge[3]
private

Definition at line 115 of file BasicHitAnalysis_tool.cc.

TProfile* BasicHitAnalysis::BasicHitAnalysis::fPulseHVsHitNo[3]
private

Definition at line 119 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fPulseHVsWidth[3]
private

Definition at line 114 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fSOPHvsWid[3]
private

Definition at line 127 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fSPHvsIdx[3]
private

Definition at line 123 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fSPPHvsWid[3]
private

Definition at line 126 of file BasicHitAnalysis_tool.cc.

TH2D* BasicHitAnalysis::BasicHitAnalysis::fSWidVsIdx[3]
private

Definition at line 124 of file BasicHitAnalysis_tool.cc.

The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.5