LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
SCECorrection_module.cc
Go to the documentation of this file.
1 // Class: SCECorrection
3 // Plugin Type: producer (art v3_04_00)
4 // File: SCECorrection_module.cc
5 //
6 // Generated at Sun Mar 22 09:23:33 2020 by Edward Tyley using cetskelgen
7 // from cetlib version v3_09_00.
9 
19 #include "fhiclcpp/ParameterSet.h"
21 
30 
40 
41 namespace sce {
42  class SCECorrection;
43 }
44 
46 public:
47  explicit SCECorrection(fhicl::ParameterSet const& p);
48  // The compiler-generated destructor is fine for non-base
49  // classes without bare pointers or other resource use.
50 
51  // Plugins should not be copied or assigned.
52  SCECorrection(SCECorrection const&) = delete;
53  SCECorrection(SCECorrection&&) = delete;
54  SCECorrection& operator=(SCECorrection const&) = delete;
56 
57  // Required functions.
58  void produce(art::Event& evt) override;
59 
60 private:
61  // Declare member data here.
64 
66 
67  const std::string fPFPLabel, fTrackLabel;
68  const std::vector<std::string> fT0Labels;
69  const std::vector<bool> fT0LabelsCorrectT0;
70 
71  geo::Vector_t applyT0Shift(const double& t0, const geo::TPCID& tpcId) const;
72 
73  std::map<art::Ptr<anab::T0>, bool> getSliceT0s(
74  const art::Event& evt,
75  const std::vector<art::Ptr<recob::PFParticle>>& slicePFPs,
76  const art::Handle<std::vector<recob::PFParticle>>& pfpHandle,
77  const art::Handle<std::vector<recob::Track>>& trackHandle,
78  const art::FindManyP<recob::Track>& fmPFPTrack) const;
79 
80  std::pair<art::Ptr<anab::T0>, bool> getSliceBestT0(
81  const std::map<art::Ptr<anab::T0>, bool>& sliceT0CorrectMap) const;
82 };
83 
85  : EDProducer{p}
86  , fGeom(lar::providerFrom<geo::Geometry>())
87  , fSCE(lar::providerFrom<spacecharge::SpaceChargeService>())
88  , fCorrectNoT0Tag(p.get<bool>("CorrectNoT0Tag"))
89  , fCorrectSCE(p.get<bool>("CorrectSCE"))
90  , fSCEXCorrFlip(p.get<bool>("SCEXCorrFlip"))
91  , fPFPLabel(p.get<std::string>("PFPLabel"))
92  , fTrackLabel(p.get<std::string>("TrackLabel"))
93  , fT0Labels(p.get<std::vector<std::string>>("T0Labels"))
94  , fT0LabelsCorrectT0(p.get<std::vector<bool>>("T0LabelsCorrectT0"))
95 {
96 
97  produces<std::vector<anab::T0>>();
98  produces<std::vector<recob::Slice>>();
99  produces<std::vector<recob::PFParticle>>();
100  produces<std::vector<recob::SpacePoint>>();
101  produces<std::vector<recob::Cluster>>();
102  produces<std::vector<recob::Vertex>>();
103  produces<std::vector<larpandoraobj::PFParticleMetadata>>();
104 
105  // produces<art::Assns<anab::T0, recob::Slice> >();
106  produces<art::Assns<anab::T0, recob::PFParticle>>();
107  produces<art::Assns<recob::Slice, recob::Hit>>();
108 
109  produces<art::Assns<recob::PFParticle, recob::Slice>>();
110  produces<art::Assns<recob::PFParticle, recob::SpacePoint>>();
111  produces<art::Assns<recob::PFParticle, recob::Vertex>>();
112  produces<art::Assns<recob::PFParticle, recob::Cluster>>();
113  produces<art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata>>();
114  produces<art::Assns<recob::SpacePoint, recob::Hit>>();
115  produces<art::Assns<recob::Cluster, recob::Hit>>();
116 }
117 
119 {
120  // Implementation of required member function here.
121  // auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
122  auto t0Collection = std::make_unique<std::vector<anab::T0>>();
123  auto pfpCollection = std::make_unique<std::vector<recob::PFParticle>>();
124  auto clusterCollection = std::make_unique<std::vector<recob::Cluster>>();
125  auto spCollection = std::make_unique<std::vector<recob::SpacePoint>>();
126  auto vtxCollection = std::make_unique<std::vector<recob::Vertex>>();
127  auto sliceCollection = std::make_unique<std::vector<recob::Slice>>();
128  auto pfpMetaCollection = std::make_unique<std::vector<larpandoraobj::PFParticleMetadata>>();
129 
130  // auto t0SliceAssn = std::make_unique<art::Assns<anab::T0, recob::Slice> >();
131  auto t0PFPAssn = std::make_unique<art::Assns<anab::T0, recob::PFParticle>>();
132  auto sliceHitAssn = std::make_unique<art::Assns<recob::Slice, recob::Hit>>();
133  auto pfpSliceAssn = std::make_unique<art::Assns<recob::PFParticle, recob::Slice>>();
134  auto pfpVtxAssn = std::make_unique<art::Assns<recob::PFParticle, recob::Vertex>>();
135  auto pfpSPAssn = std::make_unique<art::Assns<recob::PFParticle, recob::SpacePoint>>();
136  auto pfpClusterAssn = std::make_unique<art::Assns<recob::PFParticle, recob::Cluster>>();
137  auto pfpMetaAssn =
138  std::make_unique<art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata>>();
139  auto spHitAssn = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();
140  auto clusterHitAssn = std::make_unique<art::Assns<recob::Cluster, recob::Hit>>();
141 
142  art::PtrMaker<anab::T0> t0PtrMaker{evt};
143  art::PtrMaker<recob::PFParticle> pfpPtrMaker{evt};
144  art::PtrMaker<recob::Cluster> clusterPtrMaker{evt};
145  art::PtrMaker<recob::Vertex> vtxPtrMaker{evt};
146  art::PtrMaker<recob::Slice> slicePtrMaker{evt};
147  art::PtrMaker<recob::SpacePoint> spPtrMaker{evt};
149 
150  // Get all the slices in the event
152  std::vector<art::Ptr<recob::Slice>> allSlices;
153  if (evt.getByLabel(fPFPLabel, sliceHandle)) art::fill_ptr_vector(allSlices, sliceHandle);
154 
155  // Get all the Clusters in the event
157  std::vector<art::Ptr<recob::Cluster>> allClusters;
158  if (evt.getByLabel(fPFPLabel, clusterHandle)) art::fill_ptr_vector(allClusters, clusterHandle);
159 
160  // Get all the SpacePoints in the event
162  std::vector<art::Ptr<recob::SpacePoint>> allSpacePoints;
163  if (evt.getByLabel(fPFPLabel, spHandle)) art::fill_ptr_vector(allSpacePoints, spHandle);
164 
165  // Get all the PFParticles in the event
167  std::vector<art::Ptr<recob::PFParticle>> allPFParticles;
168  if (evt.getByLabel(fPFPLabel, pfpHandle)) art::fill_ptr_vector(allPFParticles, pfpHandle);
169 
170  // Get all the Tracks in the event
172  std::vector<art::Ptr<recob::Track>> allTracks;
173  if (evt.getByLabel(fTrackLabel, trackHandle)) art::fill_ptr_vector(allTracks, trackHandle);
174 
175  art::FindManyP<recob::PFParticle> fmSlicePFP(sliceHandle, evt, fPFPLabel);
176  art::FindManyP<recob::Track> fmPFPTrack(pfpHandle, evt, fTrackLabel);
177  art::FindManyP<recob::SpacePoint> fmPFPSP(pfpHandle, evt, fPFPLabel);
178  art::FindManyP<recob::Cluster> fmPFPCluster(pfpHandle, evt, fPFPLabel);
179  art::FindManyP<recob::Vertex> fmPFPVertex(pfpHandle, evt, fPFPLabel);
180  art::FindManyP<recob::Hit> fmClusterHit(clusterHandle, evt, fPFPLabel);
181  art::FindManyP<recob::Hit> fmSPHit(spHandle, evt, fPFPLabel);
182  art::FindManyP<recob::Hit> fmSliceHit(sliceHandle, evt, fPFPLabel);
184 
185  // Check the assns that are necessary, others are optional and will be checked
186  // when they are used to create the new assns
187  if (!fmSlicePFP.isValid()) {
188  throw cet::exception("SCECorrection") << "FindMany Slice-PFP is not Valid" << std::endl;
189  }
190  if (!fmPFPSP.isValid()) {
191  throw cet::exception("SCECorrection") << "FindMany PFP-SpacePoint is not Valid" << std::endl;
192  }
193  if (!fmSPHit.isValid()) {
194  throw cet::exception("SCECorrection") << "FindMany SpacePoint-Hit is not Valid" << std::endl;
195  }
196 
197  // For each slice, get all the PFPs and tracks and check for T0 tags
198  // std::cout<<"Test: Slices: "<<allSlices.size()<<std::endl;
199  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
200  auto const detProp =
202 
203  for (auto const& slice : allSlices) {
204 
205  //Cretae a new slice
206  recob::Slice newSlice(*slice);
207  sliceCollection->push_back(newSlice);
208  art::Ptr<recob::Slice> newSlicePtr = slicePtrMaker(sliceCollection->size() - 1);
209 
210  // Get the pfps and hits associated to the slice
211  const std::vector<art::Ptr<recob::PFParticle>> slicePFPs = fmSlicePFP.at(slice.key());
212 
213  const std::map<art::Ptr<anab::T0>, bool> sliceT0CorrectMap =
214  getSliceT0s(evt, slicePFPs, pfpHandle, trackHandle, fmPFPTrack);
215 
216  const std::pair<art::Ptr<anab::T0>, bool> sliceT0CorrectPair =
217  getSliceBestT0(sliceT0CorrectMap);
218 
219  if (sliceT0CorrectPair.first.isNull() && !fCorrectNoT0Tag) { continue; }
220 
221  art::Ptr<anab::T0> newT0Ptr;
222  double t0Offset(0);
223  if (!sliceT0CorrectPair.first.isNull()) {
224  // Calculate the shift we need to apply for the t0
225  t0Offset = detProp.DriftVelocity() * sliceT0CorrectPair.first->Time() / 1e3;
226  // Create a new T0
227  t0Collection->push_back(*sliceT0CorrectPair.first);
228  newT0Ptr = t0PtrMaker(t0Collection->size() - 1);
229  // t0SliceAssn->addSingle(newT0Ptr, newSlicePtr);
230  }
231 
232  // Make an association with the new slice and the old hits
233  if (fmSliceHit.isValid()) {
234  const std::vector<art::Ptr<recob::Hit>> sliceHits = fmSliceHit.at(slice.key());
235  for (const art::Ptr<recob::Hit>& hitPtr : sliceHits) {
236  sliceHitAssn->addSingle(newSlicePtr, hitPtr);
237  }
238  }
239 
240  // Correct all PFPs in the slice
241  for (auto const& pfp : slicePFPs) {
242 
243  // Create new PFPs and associate them to the slice
244  recob::PFParticle newPFP(*pfp);
245  pfpCollection->push_back(newPFP);
246  art::Ptr<recob::PFParticle> newPFPPtr = pfpPtrMaker(pfpCollection->size() - 1);
247  pfpSliceAssn->addSingle(newPFPPtr, newSlicePtr);
248 
249  if (!newT0Ptr.isNull()) { t0PFPAssn->addSingle(newT0Ptr, newPFPPtr); }
250 
251  std::vector<art::Ptr<recob::SpacePoint>> pfpSPs = fmPFPSP.at(pfp.key());
252  // Get the vertex associated to the PFP
253  if (fmPFPVertex.isValid()) {
254  std::vector<art::Ptr<recob::Vertex>> pfpVertices = fmPFPVertex.at(pfp.key());
255  for (auto const& pfpVertex : pfpVertices) {
256 
257  geo::Point_t vtxPos(pfpVertex->position());
258  //Find the closest SP to the vertex
259  // If the PFP has no space points, look in the whole event
260  std::vector<art::Ptr<recob::SpacePoint>> vtxSPs = pfpSPs.size() ? pfpSPs : allSpacePoints;
261 
262  double minVtxSPDist = std::numeric_limits<double>::max();
264  for (auto const& sp : vtxSPs) {
265  geo::Point_t spPos(sp->XYZ()[0], sp->XYZ()[1], sp->XYZ()[2]);
266  geo::Vector_t vtxSPDiff = vtxPos - spPos;
267  if (vtxSPDiff.Mag2() < minVtxSPDist) {
268  spPtr = sp;
269  minVtxSPDist = vtxSPDiff.Mag2();
270  }
271  }
272 
273  if (spPtr.isNull()) continue;
274 
275  // Get the hit and TPC Id associated to closest SP
276  art::Ptr<recob::Hit> spHitPtr = fmSPHit.at(spPtr.key()).front();
277  geo::TPCID tpcId = spHitPtr->WireID().asTPCID();
278 
279  if (!sliceT0CorrectPair.first.isNull() && sliceT0CorrectPair.second) {
280  geo::Vector_t posOffset = applyT0Shift(t0Offset, tpcId);
281  vtxPos += posOffset;
282  }
283 
285  geo::Vector_t posOffset = fSCE->GetCalPosOffsets(vtxPos, tpcId.TPC);
286  if (fSCEXCorrFlip) { posOffset.SetX(-posOffset.X()); }
287  vtxPos += posOffset;
288  }
289 
290  // Create a new vertex and associate it to the PFP
291  recob::Vertex newVtx(
292  vtxPos, pfpVertex->covariance(), pfpVertex->chi2(), pfpVertex->ndof(), pfpVertex->ID());
293  vtxCollection->push_back(newVtx);
294  art::Ptr<recob::Vertex> newVtxPtr = vtxPtrMaker(vtxCollection->size() - 1);
295  pfpVtxAssn->addSingle(newPFPPtr, newVtxPtr);
296  }
297  }
298 
299  for (auto const& sp : pfpSPs) {
300 
301  //Get the spacepoint position in a nicer form
302  geo::Point_t spPos(sp->XYZ()[0], sp->XYZ()[1], sp->XYZ()[2]);
303 
304  // Get the hit so we know what TPC the sp was in
305  // N.B. We can't use SP position to infer the TPC as it could be
306  // shifted into another TPC
307  art::Ptr<recob::Hit> spHitPtr = fmSPHit.at(sp.key()).front();
308  geo::TPCID tpcId = spHitPtr->WireID().asTPCID();
309 
310  if (!sliceT0CorrectPair.first.isNull() && sliceT0CorrectPair.second) {
311  geo::Vector_t posOffset = applyT0Shift(t0Offset, tpcId);
312  spPos += posOffset;
313  }
314 
316  geo::Vector_t posOffset = fSCE->GetCalPosOffsets(spPos, tpcId.TPC);
317  if (fSCEXCorrFlip) { posOffset.SetX(-posOffset.X()); }
318  spPos += posOffset;
319  }
320 
321  // Create new spacepoint and associate it to the pfp and hit
322  Double32_t spXYZ[3] = {spPos.X(), spPos.Y(), spPos.Z()};
323  recob::SpacePoint correctedSP(spXYZ, sp->ErrXYZ(), sp->Chisq(), sp->ID());
324 
325  spCollection->push_back(correctedSP);
326  art::Ptr<recob::SpacePoint> spPtr = spPtrMaker(spCollection->size() - 1);
327  pfpSPAssn->addSingle(newPFPPtr, spPtr);
328  spHitAssn->addSingle(spPtr, spHitPtr);
329  } // pspSPs
330 
331  // Create new clusters and associations
332  if (fmPFPCluster.isValid() && fmClusterHit.isValid()) {
333  std::vector<art::Ptr<recob::Cluster>> pfpClusters = fmPFPCluster.at(pfp.key());
334  for (auto const& pfpCluster : pfpClusters) {
335  recob::Cluster newCluster(*pfpCluster);
336  clusterCollection->push_back(newCluster);
337  art::Ptr<recob::Cluster> newClusterPtr = clusterPtrMaker(clusterCollection->size() - 1);
338 
339  std::vector<art::Ptr<recob::Hit>> clusterHits = fmClusterHit.at(pfpCluster.key());
340  pfpClusterAssn->addSingle(newPFPPtr, newClusterPtr);
341  for (auto const& clusterHit : clusterHits) {
342  clusterHitAssn->addSingle(newClusterPtr, clusterHit);
343  }
344  }
345  }
346 
347  // Create new PFParticle Metadata objects and associations
348  if (fmPFPMeta.isValid()) {
349  const std::vector<art::Ptr<larpandoraobj::PFParticleMetadata>> pfpMetas =
350  fmPFPMeta.at(pfp.key());
351  for (const art::Ptr<larpandoraobj::PFParticleMetadata>& pfpMeta : pfpMetas) {
352  larpandoraobj::PFParticleMetadata newPFPMeta(*pfpMeta);
353  pfpMetaCollection->push_back(newPFPMeta);
355  pfpMetaPtrMaker(pfpMetaCollection->size() - 1);
356  pfpMetaAssn->addSingle(newPFPPtr, newPFPMetaPtr);
357  }
358  }
359  } // slicePFPs
360  } // slice
361 
362  // std::cout<<"Test: SPs: "<<spCollection->size()<<std::endl;
363 
364  // Put all the things we just produced into the event
365  evt.put(std::move(t0Collection));
366  evt.put(std::move(sliceCollection));
367  evt.put(std::move(clusterCollection));
368  evt.put(std::move(pfpCollection));
369  evt.put(std::move(spCollection));
370  evt.put(std::move(vtxCollection));
371  evt.put(std::move(pfpMetaCollection));
372 
373  evt.put(std::move(t0PFPAssn));
374  // evt.put(std::move(t0SliceAssn));
375  evt.put(std::move(sliceHitAssn));
376  evt.put(std::move(pfpSPAssn));
377  evt.put(std::move(spHitAssn));
378  evt.put(std::move(pfpVtxAssn));
379  evt.put(std::move(pfpSliceAssn));
380  evt.put(std::move(pfpClusterAssn));
381  evt.put(std::move(clusterHitAssn));
382  evt.put(std::move(pfpMetaAssn));
383 }
384 
386  const geo::TPCID& tpcId) const
387 {
388 
389  const geo::TPCGeo& tpcGeo = fGeom->GetElement(tpcId);
390  int driftDirection = tpcGeo.DetectDriftDirection();
391 
392  switch (std::abs(driftDirection)) {
393  case 1: return geo::Vector_t{t0Offset * driftDirection, 0, 0};
394  case 2: return geo::Vector_t{0, t0Offset * driftDirection, 0};
395  case 3: return geo::Vector_t{0, 0, t0Offset * driftDirection};
396  default:
397  throw cet::exception("SCECorrection")
398  << "Drift direction unknown: " << driftDirection << std::endl;
399  }
400 }
401 
402 std::map<art::Ptr<anab::T0>, bool> sce::SCECorrection::getSliceT0s(
403  const art::Event& evt,
404  const std::vector<art::Ptr<recob::PFParticle>>& slicePFPs,
405  const art::Handle<std::vector<recob::PFParticle>>& pfpHandle,
406  const art::Handle<std::vector<recob::Track>>& trackHandle,
407  const art::FindManyP<recob::Track>& fmPFPTrack) const
408 {
409 
410  std::map<art::Ptr<anab::T0>, bool> pfpT0CorrectMap;
411  // Loop over all of the PFPs in the slice
412  for (auto const& pfp : slicePFPs) {
413 
414  // Loop over all of the T0 labels
415  // We will take the first label to have a T0, so the order matters
416  for (unsigned int i = 0; i < fT0Labels.size(); i++) {
417  std::string t0Label = fT0Labels.at(i);
418 
419  // Get the T0
420  art::FindManyP<anab::T0> fmPFPT0(pfpHandle, evt, t0Label);
421  if (fmPFPT0.isValid()) {
422  std::vector<art::Ptr<anab::T0>> pfpT0s = fmPFPT0.at(pfp.key());
423  if (pfpT0s.size() == 1) {
424  pfpT0CorrectMap[pfpT0s.front()] = fT0LabelsCorrectT0.at(i);
425  break;
426  }
427  }
428  // If not, Check the track associated to the PFP
429  if (!fmPFPTrack.isValid()) continue;
430  std::vector<art::Ptr<recob::Track>> pfpTracks = fmPFPTrack.at(pfp.key());
431  if (pfpTracks.size() != 1) { continue; }
432  art::Ptr<recob::Track> pfpTrack = pfpTracks.front();
433 
434  // Check if the track has a T0
435  art::FindManyP<anab::T0> fmTrackT0(trackHandle, evt, t0Label);
436  if (fmTrackT0.isValid()) {
437  std::vector<art::Ptr<anab::T0>> trackT0s = fmTrackT0.at(pfpTrack.key());
438  if (trackT0s.size() == 1) {
439  pfpT0CorrectMap[trackT0s.front()] = fT0LabelsCorrectT0.at(i);
440  break;
441  }
442  }
443  } // fT0Labels
444  } // slicePFPs
445  return pfpT0CorrectMap;
446 }
447 
448 std::pair<art::Ptr<anab::T0>, bool> sce::SCECorrection::getSliceBestT0(
449  const std::map<art::Ptr<anab::T0>, bool>& sliceT0CorrectMap) const
450 {
451 
452  if (!sliceT0CorrectMap.size()) { return std::pair<art::Ptr<anab::T0>, bool>(); }
453 
454  double minT0 = std::numeric_limits<double>::max();
455  std::pair<art::Ptr<anab::T0>, bool> sliceT0CorrectPair;
456  for (auto const& sliceT0CorrectIter : sliceT0CorrectMap) {
457  double t0Time = abs(sliceT0CorrectIter.first->Time());
458  if (t0Time < minT0) {
459  minT0 = t0Time;
460  sliceT0CorrectPair = sliceT0CorrectIter;
461  }
462  }
463  return sliceT0CorrectPair;
464 }
465 
code to link reconstructed objects back to the MC truth information
SCECorrection(fhicl::ParameterSet const &p)
geo::GeometryCore const * fGeom
Utilities related to art service access.
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag > Vector_t
Type for representation of momenta in 3D space.
Definition: geo_vectors.h:160
virtual geo::Vector_t GetCalPosOffsets(geo::Point_t const &point, int const &TPCid) const =0
Declaration of signal hit object.
geo::Vector_t applyT0Shift(const double &t0, const geo::TPCID &tpcId) const
EDProducer(fhicl::ParameterSet const &pset)
Definition: EDProducer.cc:6
Geometry information for a single TPC.
Definition: TPCGeo.h:36
constexpr auto abs(T v)
Returns the absolute value of the argument.
Set of hits with a 2D structure.
Definition: Cluster.h:69
geo::WireID const & WireID() const
Initial tdc tick for hit.
Definition: Hit.h:280
CryostatGeo const & GetElement(CryostatID const &cryoid) const
Returns the specified cryostat.
Definition: GeometryCore.h:465
Definition of vertex object for LArSoft.
Definition: Vertex.h:35
void produce(art::Event &evt) override
spacecharge::SpaceCharge const * fSCE
PutHandle< PROD > put(std::unique_ptr< PROD > &&edp, std::string const &instance={})
Definition: Event.h:77
auto vector(Vector const &v)
Returns a manipulator which will print the specified array.
Definition: DumpUtils.h:289
Access the description of detector geometry.
std::map< art::Ptr< anab::T0 >, bool > getSliceT0s(const art::Event &evt, const std::vector< art::Ptr< recob::PFParticle >> &slicePFPs, const art::Handle< std::vector< recob::PFParticle >> &pfpHandle, const art::Handle< std::vector< recob::Track >> &trackHandle, const art::FindManyP< recob::Track > &fmPFPTrack) const
#define DEFINE_ART_MODULE(klass)
Definition: ModuleMacros.h:65
Metadata associated to PFParticles.
const std::string fPFPLabel
const std::vector< bool > fT0LabelsCorrectT0
key_type key() const noexcept
Definition: Ptr.h:166
bool isNull() const noexcept
Definition: Ptr.h:211
Provides recob::Track data product.
std::pair< art::Ptr< anab::T0 >, bool > getSliceBestT0(const std::map< art::Ptr< anab::T0 >, bool > &sliceT0CorrectMap) const
The data type to uniquely identify a TPC.
Definition: geo_types.h:381
Description of geometry of one entire detector.
Definition: GeometryCore.h:119
Declaration of cluster object.
constexpr TPCID const & asTPCID() const
Conversion to TPCID (for convenience of notation).
Definition: geo_types.h:438
const std::string fTrackLabel
ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< double >, ROOT::Math::GlobalCoordinateSystemTag > Point_t
Type for representation of position in physical 3D space.
Definition: geo_vectors.h:180
virtual bool EnableCalSpatialSCE() const =0
Hierarchical representation of particle flow.
Definition: PFParticle.h:44
bool getByLabel(std::string const &label, std::string const &instance, Handle< PROD > &result) const
Utility object to perform functions of association.
short int DetectDriftDirection() const
Returns the expected drift direction based on geometry.
Definition: TPCGeo.cxx:149
TCEvent evt
Definition: DataStructs.cxx:8
void fill_ptr_vector(std::vector< Ptr< T >> &ptrs, H const &h)
Definition: Ptr.h:306
TPCID_t TPC
Index of the TPC within its cryostat.
Definition: geo_types.h:399
art framework interface to geometry description
const std::vector< std::string > fT0Labels
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
SCECorrection & operator=(SCECorrection const &)=delete