43 : theIds(cfg.getParameter<std::vector<int> >(
"pdgIds")),
44 theCharges(cfg.getParameter<std::vector<int> >(
"charges")),
45 thePropagatorName(cfg.getParameter<std::
string>(
"propagator")),
46 theMinP2(cfg.getParameter<double>(
"minP")*cfg.getParameter<double>(
"minP")),
47 theMinPt2(cfg.getParameter<double>(
"minPt")*cfg.getParameter<double>(
"minPt")),
48 theDoMonitor(cfg.getUntrackedParameter<bool>(
"doMonitor"))
54 <<
"'pdgIds' and 'charges' need same length.";
61 throw cms::Exception(
"BadConfig") <<
"CosmicGenFilterHelix: maxZ (" << maxZ
62 <<
") smaller than minZ (" << minZ <<
").";
86 const HepMC::GenEvent *mCEvt = hepMCEvt->GetEvent();
92 for (HepMC::GenEvent::particle_const_iterator iPart = mCEvt->particles_begin(),
93 endPart = mCEvt->particles_end(); iPart != endPart; ++iPart) {
95 if ((*iPart)->status() != 1)
continue;
99 const HepMC::ThreeVector hepVertex((*iPart)->production_vertex()->point3d());
100 const GlobalPoint vert(hepVertex.x()/10., hepVertex.y()/10., hepVertex.z()/10.);
101 const HepMC::FourVector hepMomentum((*iPart)->momentum());
102 const GlobalVector mom(hepMomentum.x(), hepMomentum.y(), hepMomentum.z());
121 typedef std::pair<TrajectoryStateOnSurface, double> TsosPath;
127 if (!aTsosPath.first.isValid()) {
129 }
else if (aTsosPath.first.globalPosition().z() <
theTargetPlaneMin->position().z()) {
134 if (!aTsosPath.first.isValid()
138 }
else if (aTsosPath.first.globalPosition().z() >
theTargetPlaneMax->position().z()) {
141 if (!aTsosPath.first.isValid()
148 const GlobalVector momEnd(aTsosPath.first.globalMomentum());
152 const GlobalPoint vertEnd(aTsosPath.first.globalPosition());
181 hists.Add(
fd.make<TH1F>(
"momentumP",
"|p(#mu^{+})| (start);|p| [GeV]",100, 0., 1000.));
182 hists.Add(
fd.make<TH1F>(
"momentumM",
"|p(#mu^{-})| (start);|p| [GeV]",100, 0., 1000.));
183 hists.Add(
fd.make<TH1F>(
"momentum2",
"|p(#mu)| (start);|p| [GeV]",100, 0., 25.));
184 const int kNumBins = 50;
185 double pBinsLog[kNumBins+1] = {0.};
187 hists.Add(
fd.make<TH1F>(
"momentumLog",
"|p(#mu)| (start);|p| [GeV]", kNumBins, pBinsLog));
189 hists.Add(
fd.make<TH1F>(
"cosPhi",
"cos(p_{#phi(#mu)}) (start);cos(#phi)", 100, -1., 1.));
190 hists.Add(
fd.make<TH1F>(
"phiXz",
"start p_{#phi_{xz}(#mu)};#phi_{xz}",
192 hists.Add(
fd.make<TH1F>(
"theta",
"#theta(#mu) (start);#theta", 100, 0.,
TMath::Pi()));
193 hists.Add(
fd.make<TH1F>(
"thetaY",
"#theta_{y}(#mu) (start);#theta_{y}", 100,0.,
TMath::Pi()/2.));
195 hists.Add(
fd.make<TH2F>(
"momVsPhi",
"|p(#mu)| vs #phi (start);#phi;|p| [GeV]",
197 hists.Add(
fd.make<TH2F>(
"momVsTheta",
"|p(#mu)| vs #theta (start);#theta;|p| [GeV]",
199 hists.Add(
fd.make<TH2F>(
"momVsThetaY",
"|p(#mu)| vs #theta_{y} (start);#theta_{y};|p| [GeV]",
200 50, 0.,
TMath::Pi()/2., 50, 1.5, 1000.));
201 hists.Add(
fd.make<TH2F>(
"momVsZ",
"|p(#mu)| vs z (start);z [cm];|p| [GeV]",
202 50, -1600., 1600., 50, 1.5, 1000.));
203 hists.Add(
fd.make<TH2F>(
"thetaVsZ",
"#theta vs z (start);z [cm];#theta",
204 50, -1600., 1600., 50, 0.,
TMath::Pi()));
205 hists.Add(
fd.make<TH2F>(
"thetaYvsZ",
"#theta_{y} vs z (start);z [cm];#theta",
206 50, -1600., 1600., 50, 0., TMath::PiOver2()));
207 hists.Add(
fd.make<TH2F>(
"yVsThetaY",
"#theta_{y}(#mu) vs y (start);#theta_{y};y [cm]",
208 50, 0.,
TMath::Pi()/2., 50, -1000., 1000.));
209 hists.Add(
fd.make<TH2F>(
"yVsThetaYnoR",
"#theta_{y}(#mu) vs y (start, barrel);#theta_{y};y [cm]",
210 50, 0.,
TMath::Pi()/2., 50, -1000., 1000.));
212 hists.Add(
fd.make<TH1F>(
"radius",
"start radius;r [cm]", 100, 0., 1000.));
213 hists.Add(
fd.make<TH1F>(
"z",
"start z;z [cm]", 100, -1600., 1600.));
214 hists.Add(
fd.make<TH2F>(
"xyPlane",
"start xy;x [cm];y [cm]", 50, -1000., 1000.,
216 hists.Add(
fd.make<TH2F>(
"rzPlane",
217 "start rz (y < 0 #Rightarrow r_{#pm} = -r);z [cm];r_{#pm} [cm]",
218 50, -1600., 1600., 50, -1000., 1000.));
227 const int kNumBins = 50;
228 double pBinsLog[kNumBins+1] = {0.};
232 hists.Add(
fd.make<TH1F>(
"pathEnd",
"path until cylinder;s [cm]", 100, 0., 2000.));
233 hists.Add(
fd.make<TH1F>(
"momEnd",
"|p_{end}|;p [GeV]", 100, 0., 1000.));
234 hists.Add(
fd.make<TH1F>(
"momEndLog",
"|p_{end}|;p [GeV]", kNumBins, pBinsLog));
235 hists.Add(
fd.make<TH1F>(
"ptEnd",
"p_{t} (end);p_{t} [GeV]", 100, 0., 750.));
236 hists.Add(
fd.make<TH1F>(
"ptEndLog",
"p_{t} (end);p_{t} [GeV]", kNumBins, pBinsLog));
237 hists.Add(
fd.make<TH1F>(
"phiXzEnd",
"#phi_{xz} (end);#phi_{xz}", 100,-
TMath::Pi(),
TMath::Pi()));
238 hists.Add(
fd.make<TH1F>(
"thetaYEnd",
"#theta_{y} (end);#theta_{y}", 100, 0.,
TMath::Pi()));
240 hists.Add(
fd.make<TH1F>(
"momStartEnd",
"|p_{start}|-|p_{end}|;#Deltap [GeV]",100,0.,15.));
241 hists.Add(
fd.make<TH1F>(
"momStartEndRel",
"(p_{start}-p_{end})/p_{start};#Deltap_{rel}",
243 hists.Add(
fd.make<TH1F>(
"phiXzStartEnd",
"#phi_{xz,start}-#phi_{xz,end};#Delta#phi_{xz}",
245 hists.Add(
fd.make<TH1F>(
"thetaYStartEnd",
"#theta_{y,start}-#theta_{y,end};#Delta#theta_{y}",
248 hists.Add(
fd.make<TH2F>(
"phiXzStartVsEnd",
249 "#phi_{xz} start vs end;#phi_{xz}^{end};#phi_{xz}^{start}",
251 hists.Add(
fd.make<TH2F>(
"thetaYStartVsEnd",
252 "#theta_{y} start vs end;#theta_{y}^{end};#theta_{y}^{start}",
255 hists.Add(
fd.make<TH2F>(
"momStartEndRelVsZ",
256 "(p_{start}-p_{end})/p_{start} vs z_{start};z [cm];#Deltap_{rel}",
257 50, -1600., 1600., 50,.0,.8));
258 hists.Add(
fd.make<TH2F>(
"phiXzStartEndVsZ",
259 "#phi_{xz,start}-#phi_{xz,end} vs z_{start};z [cm];#Delta#phi_{xz}",
260 50, -1600., 1600., 50,-1., 1.));
261 hists.Add(
fd.make<TH2F>(
"thetaYStartEndVsZ",
262 "#theta_{y,start}-#theta_{y,end} vs z_{start};z [cm];#Delta#theta_{y}",
263 50, -1600., 1600., 50,-.5,.5));
264 hists.Add(
fd.make<TH2F>(
"momStartEndRelVsP",
265 "(p_{start}-p_{end})/p_{start} vs p_{start};p [GeV];#Deltap_{rel}",
266 kNumBins, pBinsLog, 50, .0, .8));
267 hists.Add(
fd.make<TH2F>(
"phiXzStartEndVsP",
268 "#phi_{xz,start}-#phi_{xz,end} vs |p|_{start};p [GeV];#Delta#phi_{xz}",
269 kNumBins, pBinsLog, 100,-1.5, 1.5));
270 hists.Add(
fd.make<TH2F>(
"thetaYStartEndVsP",
271 "#theta_{y,start}-#theta_{y,end} vs |p|_{start};p [GeV];#Delta#theta_{y}",
272 kNumBins, pBinsLog, 100,-1.,1.));
275 hists.Add(
fd.make<TH1F>(
"radiusEnd",
"end radius;r [cm]", 100, 0., maxR));
280 hists.Add(
fd.make<TH1F>(
"zEnd",
"end z;z [cm]", 100, minZ, maxZ));
281 hists.Add(
fd.make<TH1F>(
"zDiff",
"z_{start}-z_{end};#Deltaz [cm]", 100, -1000., 1000.));
282 hists.Add(
fd.make<TH2F>(
"xyPlaneEnd",
"end xy;x [cm];y [cm]", 100, -maxR, maxR, 100,-maxR,maxR));
284 hists.Add(
fd.make<TH2F>(
"rzPlaneEnd",
"end rz (y<0 #Rightarrow r_{#pm}=-r);z [cm];r_{#pm} [cm]",
285 50, minZ, maxZ, 50, -maxR, maxR));
286 hists.Add(
fd.make<TH2F>(
"thetaVsZend",
"#theta vs z (end);z [cm];#theta",
293 const char *border =
"////////////////////////////////////////////////////////";
294 const char *
line =
"\n// ";
295 edm::LogInfo(
"Filter") <<
"@SUB=CosmicGenFilterHelix::endJob"
299 <<
"reached target cylinder,"
300 << line <<
"defined by r < "
304 << line <<
"Minimal required (transverse) momentum was "
312 std::vector<int>::const_iterator iC =
theCharges.begin();
340 if (!dynamic_cast<const SteppingHelixPropagator*>(prop)) {
341 edm::LogWarning(
"BadConfig") <<
"@SUB=CosmicGenFilterHelix::getPropagator"
342 <<
"Not a SteppingHelixPropagator!";
350 int charge, TObjArray &hists)
352 const double scalarMom = mom.
mag();
353 const double phi = mom.
phi();
354 const double phiXz = TMath::ATan2(mom.
z(), mom.
x());
356 const double thetaY = TMath::ATan2(TMath::Sqrt(mom.
x()*mom.
x()+mom.
z()*mom.
z()), -mom.
y());
358 const double z = vert.
z();
359 const double r = vert.
perp();
361 const static int iMomP = hists.IndexOf(hists.FindObject(
"momentumP"));
362 const static int iMomM = hists.IndexOf(hists.FindObject(
"momentumM"));
363 if (charge > 0)
static_cast<TH1*
>(hists[iMomP])->
Fill(scalarMom);
364 else static_cast<TH1*
>(hists[iMomM])->
Fill(scalarMom);
365 const static int iMom2 = hists.IndexOf(hists.FindObject(
"momentum2"));
366 static_cast<TH1*
>(hists[iMom2])->
Fill(scalarMom);
367 const static int iMomLog = hists.IndexOf(hists.FindObject(
"momentumLog"));
368 static_cast<TH1*
>(hists[iMomLog])->
Fill(scalarMom);
369 const static int iPhi = hists.IndexOf(hists.FindObject(
"phi"));
370 static_cast<TH1*
>(hists[iPhi])->
Fill(phi);
371 const static int iCosPhi = hists.IndexOf(hists.FindObject(
"cosPhi"));
372 static_cast<TH1*
>(hists[iCosPhi])->
Fill(TMath::Cos(phi));
373 const static int iPhiXz = hists.IndexOf(hists.FindObject(
"phiXz"));
374 static_cast<TH1*
>(hists[iPhiXz])->
Fill(phiXz);
375 const static int iTheta = hists.IndexOf(hists.FindObject(
"theta"));
376 static_cast<TH1*
>(hists[iTheta])->
Fill(theta);
377 const static int iThetaY = hists.IndexOf(hists.FindObject(
"thetaY"));
378 static_cast<TH1*
>(hists[iThetaY])->
Fill(thetaY);
380 const static int iMomVsTheta = hists.IndexOf(hists.FindObject(
"momVsTheta"));
381 static_cast<TH2*
>(hists[iMomVsTheta])->
Fill(theta, scalarMom);
382 const static int iMomVsThetaY = hists.IndexOf(hists.FindObject(
"momVsThetaY"));
383 static_cast<TH2*
>(hists[iMomVsThetaY])->
Fill(thetaY, scalarMom);
384 const static int iMomVsPhi = hists.IndexOf(hists.FindObject(
"momVsPhi"));
385 static_cast<TH2*
>(hists[iMomVsPhi])->
Fill(phi, scalarMom);
386 const static int iMomVsZ = hists.IndexOf(hists.FindObject(
"momVsZ"));
387 static_cast<TH2*
>(hists[iMomVsZ])->
Fill(z, scalarMom);
388 const static int iThetaVsZ = hists.IndexOf(hists.FindObject(
"thetaVsZ"));
389 static_cast<TH2*
>(hists[iThetaVsZ])->
Fill(z, theta);
390 const static int iThetaYvsZ = hists.IndexOf(hists.FindObject(
"thetaYvsZ"));
391 static_cast<TH2*
>(hists[iThetaYvsZ])->
Fill(z, thetaY);
392 const static int iYvsThetaY = hists.IndexOf(hists.FindObject(
"yVsThetaY"));
393 static_cast<TH2*
>(hists[iYvsThetaY])->
Fill(thetaY, vert.
y());
394 const static int iYvsThetaYnoR = hists.IndexOf(hists.FindObject(
"yVsThetaYnoR"));
395 if (z > -1400. && z < 1400.) {
396 static_cast<TH2*
>(hists[iYvsThetaYnoR])->
Fill(thetaY, vert.
y());
399 const static int iRadius = hists.IndexOf(hists.FindObject(
"radius"));
400 static_cast<TH1*
>(hists[iRadius])->
Fill(r);
401 const static int iZ = hists.IndexOf(hists.FindObject(
"z"));
402 static_cast<TH1*
>(hists[iZ])->
Fill(z);
403 const static int iXy = hists.IndexOf(hists.FindObject(
"xyPlane"));
404 static_cast<TH1*
>(hists[iXy])->
Fill(vert.
x(), vert.
y());
405 const static int iRz = hists.IndexOf(hists.FindObject(
"rzPlane"));
406 static_cast<TH1*
>(hists[iRz])->
Fill(z, (vert.
y() > 0 ? r : -
r));
412 double path, TObjArray &hists)
414 const double scalarMomStart = mom.
mag();
415 const double phiXzStart = TMath::ATan2(mom.
z(), mom.
x());
416 const double thetaYStart = TMath::ATan2(TMath::Sqrt(mom.
x()*mom.
x()+mom.
z()*mom.
z()), -mom.
y());
417 const double scalarMomEnd = endMom.
mag();
418 const double ptEnd = endMom.
perp();
419 const double phiXzEnd = TMath::ATan2(endMom.
z(), endMom.
x());
420 const double thetaYEnd = TMath::ATan2(TMath::Sqrt(endMom.
x()*endMom.
x()+endMom.
z()*endMom.
z()),
422 const double thetaEnd = endMom.
theta();
424 const double diffMomRel = (scalarMomStart-scalarMomEnd)/scalarMomStart;
426 const double zEnd = endVert.
z();
427 const double rEnd = endVert.
perp();
428 const double diffZ = zEnd - vert.
z();
430 const static int iPathEnd = hists.IndexOf(hists.FindObject(
"pathEnd"));
431 static_cast<TH1*
>(hists[iPathEnd])->
Fill(path);
432 const static int iMomEnd = hists.IndexOf(hists.FindObject(
"momEnd"));
433 static_cast<TH1*
>(hists[iMomEnd])->
Fill(scalarMomEnd);
434 const static int iMomEndLog = hists.IndexOf(hists.FindObject(
"momEndLog"));
435 static_cast<TH1*
>(hists[iMomEndLog])->
Fill(scalarMomEnd);
436 const static int iPtEnd = hists.IndexOf(hists.FindObject(
"ptEnd"));
437 static_cast<TH1*
>(hists[iPtEnd])->
Fill(ptEnd);
438 const static int iPtEndLog = hists.IndexOf(hists.FindObject(
"ptEndLog"));
439 static_cast<TH1*
>(hists[iPtEndLog])->
Fill(ptEnd);
440 const static int iPhiXzEnd = hists.IndexOf(hists.FindObject(
"phiXzEnd"));
441 static_cast<TH1*
>(hists[iPhiXzEnd])->
Fill(phiXzEnd);
442 const static int iThetaYEnd = hists.IndexOf(hists.FindObject(
"thetaYEnd"));
443 static_cast<TH1*
>(hists[iThetaYEnd])->
Fill(thetaYEnd);
445 const static int iMomStartEnd = hists.IndexOf(hists.FindObject(
"momStartEnd"));
446 static_cast<TH1*
>(hists[iMomStartEnd])->
Fill(scalarMomStart-scalarMomEnd);
447 const static int iMomStartEndRel = hists.IndexOf(hists.FindObject(
"momStartEndRel"));
448 static_cast<TH1*
>(hists[iMomStartEndRel])->
Fill(diffMomRel);
449 const static int iPhiStartEnd = hists.IndexOf(hists.FindObject(
"phiXzStartEnd"));
450 static_cast<TH1*
>(hists[iPhiStartEnd])->
Fill(phiXzStart-phiXzEnd);
451 const static int iThetaStartEnd = hists.IndexOf(hists.FindObject(
"thetaYStartEnd"));
452 static_cast<TH1*
>(hists[iThetaStartEnd])->
Fill(thetaYStart-thetaYEnd);
454 const static int iPhiStartVsEnd = hists.IndexOf(hists.FindObject(
"phiXzStartVsEnd"));
455 static_cast<TH2*
>(hists[iPhiStartVsEnd])->
Fill(phiXzEnd, phiXzStart);
456 const static int iThetaStartVsEnd = hists.IndexOf(hists.FindObject(
"thetaYStartVsEnd"));
457 static_cast<TH2*
>(hists[iThetaStartVsEnd])->
Fill(thetaYEnd, thetaYStart);
459 const static int iMomStartEndRelVsZ = hists.IndexOf(hists.FindObject(
"momStartEndRelVsZ"));
460 static_cast<TH2*
>(hists[iMomStartEndRelVsZ])->
Fill(vert.
z(), diffMomRel);
461 const static int iPhiStartEndVsZ = hists.IndexOf(hists.FindObject(
"phiXzStartEndVsZ"));
462 static_cast<TH2*
>(hists[iPhiStartEndVsZ])->
Fill(vert.
z(), phiXzStart-phiXzEnd);
463 const static int iThetaStartEndVsZ = hists.IndexOf(hists.FindObject(
"thetaYStartEndVsZ"));
464 static_cast<TH2*
>(hists[iThetaStartEndVsZ])->
Fill(vert.
z(), thetaYStart-thetaYEnd);
465 const static int iMomStartEndRelVsP = hists.IndexOf(hists.FindObject(
"momStartEndRelVsP"));
466 static_cast<TH2*
>(hists[iMomStartEndRelVsP])->
Fill(scalarMomStart, diffMomRel);
467 const static int iPhiStartEndVsP = hists.IndexOf(hists.FindObject(
"phiXzStartEndVsP"));
468 static_cast<TH2*
>(hists[iPhiStartEndVsP])->
Fill(scalarMomStart, phiXzStart-phiXzEnd);
469 const static int iThetaStartEndVsP = hists.IndexOf(hists.FindObject(
"thetaYStartEndVsP"));
470 static_cast<TH2*
>(hists[iThetaStartEndVsP])->
Fill(scalarMomStart, thetaYStart-thetaYEnd);
472 const static int iRadiusEnd = hists.IndexOf(hists.FindObject(
"radiusEnd"));
473 static_cast<TH1*
>(hists[iRadiusEnd])->
Fill(rEnd);
474 const static int iZend = hists.IndexOf(hists.FindObject(
"zEnd"));
475 static_cast<TH1*
>(hists[iZend])->
Fill(zEnd);
476 const static int iZdiff = hists.IndexOf(hists.FindObject(
"zDiff"));
477 static_cast<TH1*
>(hists[iZdiff])->
Fill(diffZ);
478 const static int iXyPlaneEnd = hists.IndexOf(hists.FindObject(
"xyPlaneEnd"));
479 static_cast<TH1*
>(hists[iXyPlaneEnd])->
Fill(endVert.
x(), endVert.
y());
480 const static int iRzPlaneEnd = hists.IndexOf(hists.FindObject(
"rzPlaneEnd"));
481 static_cast<TH1*
>(hists[iRzPlaneEnd])->
Fill(zEnd, (endVert.
y() > 0 ? rEnd : -rEnd));
482 const static int iThetaVsZend = hists.IndexOf(hists.FindObject(
"thetaVsZend"));
483 static_cast<TH2*
>(hists[iThetaVsZend])->
Fill(zEnd, thetaEnd);
495 if (nBins < 1 || first <= 0. || last <= 0.)
return false;
499 const double firstLog = TMath::Log10(bins[0]);
500 const double lastLog = TMath::Log10(bins[nBins]);
501 for (
int i = 1;
i < nBins; ++
i) {
502 bins[
i] = TMath::Power(10., firstLog +
i*(lastLog-firstLog)/(nBins));
ESHandle< MagneticField > fieldHandle
Cylinder::ConstCylinderPointer theTargetCylinder
minimal transverse^2 momentum after propagation to cylinder
T getParameter(std::string const &) const
unsigned int theNumPass
for final statistics: all seen events
Plane::ConstPlanePointer theTargetPlaneMax
plane closing cylinder at 'negative' side
const double theMinPt2
minimal momentum^2 after propagation to cylinder
virtual ~CosmicGenFilterHelix()
bool getByToken(EDGetToken token, Handle< PROD > &result) const
const std::vector< int > theIds
const Propagator * getPropagator(const edm::EventSetup &setup) const
Geom::Phi< T > phi() const
TObjArray theHistsAfter
hists of properties from generator
Geom::Theta< T > theta() const
void createHistsStart(const char *dirName, TObjArray &hists)
for final statistics: events with track reaching target
const MagneticField * getMagneticField(const edm::EventSetup &setup) const
provide magnetic field from Event Setup
bool propagateToCutCylinder(const GlobalPoint &vertStart, const GlobalVector &momStart, int charge, const MagneticField *field, const Propagator *propagator)
actually propagate to the defined cylinder
edm::EDGetTokenT< edm::HepMCProduct > theSrcToken
void monitorEnd(const GlobalPoint &endVert, const GlobalVector &endMom, const GlobalPoint &vert, const GlobalVector &mom, double path, TObjArray &hists)
Geom::Theta< T > theta() const
CosmicGenFilterHelix(const edm::ParameterSet &config)
static CylinderPointer build(const PositionType &pos, const RotationType &rot, Scalar radius, Bounds *bounds=0)
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
virtual bool filter(edm::Event &event, const edm::EventSetup &eventSetup)
const std::vector< int > theCharges
requested Ids
virtual std::pair< TrajectoryStateOnSurface, double > propagateWithPath(const FreeTrajectoryState &, const Surface &) const final
bool equidistLogBins(double *bins, int nBins, double first, double last) const
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
void createHistsEnd(const char *dirName, TObjArray &hists)
T const * product() const
TObjArray theHistsBefore
whether or not to fill monitor hists (needs TFileService)
bool charge(int id, int &charge) const
true if ID selected, return by value its charge
void monitorStart(const GlobalPoint &vert, const GlobalVector &mom, int charge, TObjArray &hists)
const std::string thePropagatorName
charges, parallel to theIds
Plane::ConstPlanePointer theTargetPlaneMin
target cylinder, around z-axis
void setup(std::vector< TH2F > &depth, std::string name, std::string units="")
unsigned int theNumTotal
plane closing cylinder at 'positive' side