Public Member Functions | Private Attributes | List of all members
cosmic::CosmicTrackTagger Class Reference
Inheritance diagram for cosmic::CosmicTrackTagger:
art::EDProducer art::detail::Producer art::detail::LegacyModule art::Modifier art::ModuleBase art::ProductRegistryHelper

Public Member Functions

 CosmicTrackTagger (fhicl::ParameterSet const &p)
 
void produce (art::Event &e) override
 
- Public Member Functions inherited from art::EDProducer
 EDProducer (fhicl::ParameterSet const &pset)
 
template<typename Config >
 EDProducer (Table< Config > const &config)
 
std::string workerType () const
 
- Public Member Functions inherited from art::detail::Producer
virtual ~Producer () noexcept
 
 Producer (fhicl::ParameterSet const &)
 
 Producer (Producer const &)=delete
 
 Producer (Producer &&)=delete
 
Producer & operator= (Producer const &)=delete
 
Producer & operator= (Producer &&)=delete
 
void doBeginJob (SharedResources const &resources)
 
void doEndJob ()
 
void doRespondToOpenInputFile (FileBlock const &fb)
 
void doRespondToCloseInputFile (FileBlock const &fb)
 
void doRespondToOpenOutputFiles (FileBlock const &fb)
 
void doRespondToCloseOutputFiles (FileBlock const &fb)
 
bool doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
 
bool doEndRun (RunPrincipal &rp, ModuleContext const &mc)
 
bool doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
 
bool doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
 
bool doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
 
- Public Member Functions inherited from art::Modifier
 ~Modifier () noexcept
 
 Modifier ()
 
 Modifier (Modifier const &)=delete
 
 Modifier (Modifier &&)=delete
 
Modifier & operator= (Modifier const &)=delete
 
Modifier & operator= (Modifier &&)=delete
 
- Public Member Functions inherited from art::ModuleBase
virtual ~ModuleBase () noexcept
 
 ModuleBase ()
 
ModuleDescription const & moduleDescription () const
 
void setModuleDescription (ModuleDescription const &)
 
std::array< std::vector< ProductInfo >, NumBranchTypes > const & getConsumables () const
 
void sortConsumables (std::string const &current_process_name)
 
template<typename T , BranchType BT>
ViewToken< T > consumesView (InputTag const &tag)
 
template<typename T , BranchType BT>
ViewToken< T > mayConsumeView (InputTag const &tag)
 

Private Attributes

std::string fTrackModuleLabel
 
int fEndTickPadding
 
int fDetectorWidthTicks
 
float fTPCXBoundary
 
float fTPCYBoundary
 
float fTPCZBoundary
 
float fDetHalfHeight
 
float fDetWidth
 
float fDetLength
 
int fMinTickDrift
 
int fMaxTickDrift
 

Additional Inherited Members

- Public Types inherited from art::EDProducer
using ModuleType = EDProducer
 
using WorkerType = WorkerT< EDProducer >
 
- Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using Table = Modifier::Table< UserConfig, KeysToIgnore >
 
- Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >
 
- Static Public Member Functions inherited from art::EDProducer
static void commitEvent (EventPrincipal &ep, Event &e)
 
- Protected Member Functions inherited from art::ModuleBase
ConsumesCollector & consumesCollector ()
 
template<typename T , BranchType = InEvent>
ProductToken< T > consumes (InputTag const &)
 
template<typename Element , BranchType = InEvent>
ViewToken< Element > consumesView (InputTag const &)
 
template<typename T , BranchType = InEvent>
void consumesMany ()
 
template<typename T , BranchType = InEvent>
ProductToken< T > mayConsume (InputTag const &)
 
template<typename Element , BranchType = InEvent>
ViewToken< Element > mayConsumeView (InputTag const &)
 
template<typename T , BranchType = InEvent>
void mayConsumeMany ()
 

Detailed Description

Definition at line 34 of file CosmicTrackTagger_module.cc.

Constructor & Destructor Documentation

cosmic::CosmicTrackTagger::CosmicTrackTagger ( fhicl::ParameterSet const &  p)
explicit

Definition at line 49 of file CosmicTrackTagger_module.cc.

49  : EDProducer{p}
50 {
51  auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
52  auto const detp =
53  art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clock_data);
54  auto const* geo = lar::providerFrom<geo::Geometry>();
55 
56  fDetHalfHeight = geo->DetHalfHeight();
57  fDetWidth = 2. * geo->DetHalfWidth();
58  fDetLength = geo->DetLength();
59 
60  float fSamplingRate = sampling_rate(clock_data);
61 
62  fTrackModuleLabel = p.get<std::string>("TrackModuleLabel", "track");
63  fEndTickPadding = p.get<int>("EndTickPadding", 50);
64 
65  fTPCXBoundary = p.get<float>("TPCXBoundary", 5);
66  fTPCYBoundary = p.get<float>("TPCYBoundary", 5);
67  fTPCZBoundary = p.get<float>("TPCZBoundary", 5);
68 
69  const double driftVelocity = detp.DriftVelocity(detp.Efield(), detp.Temperature()); // cm/us
70 
71  fDetectorWidthTicks =
72  2 * geo->DetHalfWidth() / (driftVelocity * fSamplingRate / 1000); // ~3200 for uB
73  fMinTickDrift = clock_data.Time2Tick(clock_data.TriggerTime());
74  fMaxTickDrift = fMinTickDrift + fDetectorWidthTicks + fEndTickPadding;
75 
76  produces<std::vector<anab::CosmicTag>>();
77  produces<art::Assns<recob::Track, anab::CosmicTag>>();
78 }
string
std::string string
Definition: nybbler.cc:12
art::EDProducer::EDProducer
EDProducer(fhicl::ParameterSet const &pset)
Definition: EDProducer.h:20
test.p
p
Definition: test.py:223
detinfo::sampling_rate
double sampling_rate(DetectorClocksData const &data)
Returns the period of the TPC readout electronics clock.
Definition: DetectorClocksData.h:643
geo
LArSoft geometry interface.
Definition: ChannelGeo.h:16

Member Function Documentation

void cosmic::CosmicTrackTagger::produce ( art::Event &  e)
overridevirtual

Implements art::EDProducer.

Definition at line 81 of file CosmicTrackTagger_module.cc.

82 {
83  // Implementation of required member function here.
84 
85  std::unique_ptr<std::vector<anab::CosmicTag>> cosmicTagTrackVector(
86  new std::vector<anab::CosmicTag>);
87  std::unique_ptr<art::Assns<recob::Track, anab::CosmicTag>> assnOutCosmicTagTrack(
88  new art::Assns<recob::Track, anab::CosmicTag>);
89 
90  TStopwatch ts;
91 
92  art::Handle<std::vector<recob::Track>> Trk_h;
93  e.getByLabel(fTrackModuleLabel, Trk_h);
94  std::vector<art::Ptr<recob::Track>> TrkVec;
95  art::fill_ptr_vector(TrkVec, Trk_h);
96 
97  /////////////////////////////////
98  // LOOPING OVER INSPILL TRACKS
99  /////////////////////////////////
100 
101  art::FindManyP<recob::Hit> hitsSpill(Trk_h, e, fTrackModuleLabel);
102 
103  for (unsigned int iTrack = 0; iTrack < Trk_h->size(); iTrack++) {
104 
105  int isCosmic = 0;
106  anab::CosmicTagID_t tag_id = anab::CosmicTagID_t::kNotTagged;
107 
108  art::Ptr<recob::Track> tTrack = TrkVec.at(iTrack);
109  std::vector<art::Ptr<recob::Hit>> HitVec = hitsSpill.at(iTrack);
110 
111  if (iTrack != tTrack.key()) { std::cout << "Mismatch in track index/key" << std::endl; }
112 
113  // A BETTER WAY OF FINDING END POINTS:
114  auto tVector1 = tTrack->Vertex();
115  auto tVector2 = tTrack->End();
116 
117  float trackEndPt1_X = tVector1.X();
118  float trackEndPt1_Y = tVector1.Y();
119  float trackEndPt1_Z = tVector1.Z();
120  float trackEndPt2_X = tVector2.X();
121  float trackEndPt2_Y = tVector2.Y();
122  float trackEndPt2_Z = tVector2.Z();
123 
124  if (trackEndPt1_X != trackEndPt1_X || trackEndPt1_Y != trackEndPt1_Y ||
125  trackEndPt1_Z != trackEndPt1_Z || trackEndPt2_X != trackEndPt2_X ||
126  trackEndPt2_Y != trackEndPt2_Y || trackEndPt2_Z != trackEndPt2_Z) {
127  std::cerr << "!!! FOUND A PROBLEM... the length is: " << tTrack->Length()
128  << " np: " << tTrack->NumberTrajectoryPoints() << " id: " << tTrack->ID() << " "
129  << tTrack << std::endl;
130  std::vector<float> tempPt1, tempPt2;
131  tempPt1.push_back(-999);
132  tempPt1.push_back(-999);
133  tempPt1.push_back(-999);
134  tempPt2.push_back(-999);
135  tempPt2.push_back(-999);
136  tempPt2.push_back(-999);
137  cosmicTagTrackVector->emplace_back(tempPt1, tempPt2, -999, tag_id);
138  util::CreateAssn(*this, e, *cosmicTagTrackVector, tTrack, *assnOutCosmicTagTrack);
139  continue; // I don't want to deal with these "tracks"
140  }
141 
142  /////////////////////////////////////
143  // Getting first and last ticks
144  /////////////////////////////////////
145  float tick1 = 9999;
146  float tick2 = -9999;
147  bool dumpMe(false);
148 
149  for (unsigned int p = 0; p < HitVec.size(); p++) {
150  if (dumpMe) {
151  std::cout << "###>> Hit key: " << HitVec[p].key()
152  << ", peak - RMS: " << HitVec[p]->PeakTimeMinusRMS()
153  << ", peak + RMS: " << HitVec[p]->PeakTimePlusRMS() << std::endl;
154  }
155  if (HitVec[p]->PeakTimeMinusRMS() < tick1) tick1 = HitVec[p]->PeakTimeMinusRMS();
156  if (HitVec[p]->PeakTimePlusRMS() > tick2) tick2 = HitVec[p]->PeakTimePlusRMS();
157  }
158 
159  /////////////////////////////////////////////////////////
160  // Are any of the ticks outside of the ReadOutWindow ?
161  /////////////////////////////////////////////////////////
162  if (tick1 < fMinTickDrift || tick2 > fMaxTickDrift) {
163  isCosmic = 1;
164  tag_id = anab::CosmicTagID_t::kOutsideDrift_Partial;
165  }
166 
167  /////////////////////////////////
168  // Now check Y & Z boundaries:
169  /////////////////////////////////
170  int nBdY = 0, nBdZ = 0;
171  if (isCosmic == 0) {
172 
173  // Checking lower side of TPC
174  if (fabs(fDetHalfHeight + trackEndPt1_Y) < fTPCYBoundary ||
175  fabs(fDetHalfHeight + trackEndPt2_Y) < fTPCYBoundary || trackEndPt1_Y < -fDetHalfHeight ||
176  trackEndPt2_Y < -fDetHalfHeight)
177  nBdY++;
178 
179  // Checking upper side of TPC
180  if (fabs(fDetHalfHeight - trackEndPt1_Y) < fTPCYBoundary ||
181  fabs(fDetHalfHeight - trackEndPt2_Y) < fTPCYBoundary || trackEndPt1_Y > fDetHalfHeight ||
182  trackEndPt2_Y > fDetHalfHeight)
183  nBdY++;
184 
185  if (fabs(trackEndPt1_Z - fDetLength) < fTPCZBoundary ||
186  fabs(trackEndPt2_Z - fDetLength) < fTPCZBoundary)
187  nBdZ++;
188  if (fabs(trackEndPt1_Z) < fTPCZBoundary || fabs(trackEndPt2_Z) < fTPCZBoundary) nBdZ++;
189  if ((nBdY + nBdZ) > 1) {
190  isCosmic = 2;
191  if (nBdY > 1)
192  tag_id = anab::CosmicTagID_t::kGeometry_YY;
193  else if (nBdZ > 1)
194  tag_id = anab::CosmicTagID_t::kGeometry_ZZ;
195  else
196  tag_id = anab::CosmicTagID_t::kGeometry_YZ;
197  }
198  else if ((nBdY + nBdZ) == 1) {
199  isCosmic = 3;
200  if (nBdY == 1)
201  tag_id = anab::CosmicTagID_t::kGeometry_Y;
202  else if (nBdZ == 1)
203  tag_id = anab::CosmicTagID_t::kGeometry_Z;
204  }
205  }
206 
207  std::vector<float> endPt1;
208  std::vector<float> endPt2;
209  endPt1.push_back(trackEndPt1_X);
210  endPt1.push_back(trackEndPt1_Y);
211  endPt1.push_back(trackEndPt1_Z);
212  endPt2.push_back(trackEndPt2_X);
213  endPt2.push_back(trackEndPt2_Y);
214  endPt2.push_back(trackEndPt2_Z);
215 
216  float cosmicScore = isCosmic > 0 ? 1 : 0;
217  if (isCosmic == 3) cosmicScore = 0.5;
218 
219  ///////////////////////////////////////////////////////
220  // Doing a very basic check on X boundaries
221  // this gets the types of tracks that go through both X boundaries of the detector
222  if (fabs(trackEndPt1_X - trackEndPt2_X) > fDetWidth - fTPCXBoundary) {
223  cosmicScore = 1;
224  isCosmic = 4;
225  tag_id = anab::CosmicTagID_t::kGeometry_XX;
226  }
227 
228  cosmicTagTrackVector->emplace_back(endPt1, endPt2, cosmicScore, tag_id);
229 
230  util::CreateAssn(*this, e, *cosmicTagTrackVector, tTrack, *assnOutCosmicTagTrack);
231  }
232  // END OF LOOPING OVER INSPILL TRACKS
233 
234  ///////////////////////////////////////////////////////////////////////////////////////////////
235  //////TAGGING DELTA RAYS (and other stub) ASSOCIATED TO A ALREADY TAGGED COSMIC TRACK//////////
236  ///////////////////////////////////////////////////////////////////////////////////////////////
237  float dE = 0, dS = 0, temp = 0, IScore = 0;
238  unsigned int IndexE = 0, iTrk1 = 0, iTrk = 0;
239  anab::CosmicTagID_t IType = anab::CosmicTagID_t::kNotTagged;
240 
241  for (iTrk = 0; iTrk < Trk_h->size(); iTrk++) {
242  art::Ptr<recob::Track> tTrk = TrkVec.at(iTrk);
243  if ((*cosmicTagTrackVector)[iTrk].CosmicScore() == 0) {
244  auto tStart = tTrk->Vertex();
245  auto tEnd = tTrk->End();
246  unsigned int l = 0;
247  for (iTrk1 = 0; iTrk1 < Trk_h->size(); iTrk1++) {
248  art::Ptr<recob::Track> tTrk1 = TrkVec.at(iTrk1);
249  float getScore = (*cosmicTagTrackVector)[iTrk1].CosmicScore();
250  if (getScore == 1 || getScore == 0.5) {
251  anab::CosmicTagID_t getType = (*cosmicTagTrackVector)[iTrk1].CosmicType();
252  auto tStart1 = tTrk1->Vertex();
253  auto tEnd1 = tTrk1->End();
254  auto NumE = (tEnd - tStart1).Cross(tEnd - tEnd1);
255  auto DenE = tEnd1 - tStart1;
256  dE = NumE.R() / DenE.R();
257  if (l == 0) {
258  temp = dE;
259  IndexE = iTrk1;
260  IScore = getScore;
261  IType = getType;
262  }
263  if (dE < temp) {
264  temp = dE;
265  IndexE = iTrk1;
266  IScore = getScore;
267  IType = getType;
268  }
269  l++;
270  }
271  } //End Trk1 loop
272  art::Ptr<recob::Track> tTrkI = TrkVec.at(IndexE);
273  auto tStartI = tTrkI->Vertex();
274  auto tEndI = tTrkI->End();
275  auto NumS = (tStart - tStartI).Cross(tStart - tEndI);
276  auto DenS = tEndI - tStartI;
277  dS = NumS.R() / DenS.R();
278  if (((dS < 5 && temp < 5) || (dS < temp && dS < 5)) && (tTrk->Length() < 60)) {
279  (*cosmicTagTrackVector)[iTrk].CosmicScore() = IScore - 0.05;
280  (*cosmicTagTrackVector)[iTrk].CosmicType() = IType;
281  }
282  } // end cosmicScore==0 loop
283  } // end iTrk loop
284 
285  e.put(std::move(cosmicTagTrackVector));
286  e.put(std::move(assnOutCosmicTagTrack));
287 
288  TrkVec.clear();
289 
290 } // end of produce
art::detail::getType
std::string getType(cet::LibraryManager const &lm, std::string const &fullSpec)
Definition: PluginSymbolResolvers.cc:52
anab::CosmicTagID_t
enum anab::cosmic_tag_id CosmicTagID_t
recob::Track::NumberTrajectoryPoints
size_t NumberTrajectoryPoints() const
Various functions related to the presence and the number of (valid) points.
Definition: Track.h:102
l
static QStrList * l
Definition: config.cpp:1044
art::DataViewImpl::getByLabel
bool getByLabel(std::string const &label, std::string const &instance, Handle< PROD > &result) const
Definition: DataViewImpl.h:633
recob::Track::Length
double Length(size_t p=0) const
Access to various track properties.
Definition: Track.h:167
submit_ppfxjobs.temp
temp
Definition: submit_ppfxjobs.py:110
wirecell.gen.depos.move
def move(depos, offset)
Definition: depos.py:107
art::Ptr::key
key_type key() const noexcept
Definition: Ptr.h:216
recob::Track::Vertex
Point_t const & Vertex() const
Definition: Track.h:124
test.p
p
Definition: test.py:223
art::DataViewImpl::put
ProductID put(std::unique_ptr< PROD > &&edp, std::string const &instance={})
Definition: DataViewImpl.h:686
util::CreateAssn
bool CreateAssn(PRODUCER const &prod, art::Event &evt, std::vector< T > const &a, art::Ptr< U > const &b, art::Assns< U, T > &assn, std::string a_instance, size_t indx=UINT_MAX)
Creates a single one-to-one association.
Definition: AssociationUtil.h:601
recob::Track::ID
int ID() const
Definition: Track.h:198
recob::Track::End
Point_t const & End() const
Definition: Track.h:125
art::fill_ptr_vector
void fill_ptr_vector(std::vector< Ptr< T >> &ptrs, H const &h)
Definition: Ptr.h:297
endl
QTextStream & endl(QTextStream &s)
Definition: qtextstream.cpp:2030

Member Data Documentation

int cosmic::CosmicTrackTagger::fDetectorWidthTicks
private

Definition at line 43 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fDetHalfHeight
private

Definition at line 45 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fDetLength
private

Definition at line 45 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fDetWidth
private

Definition at line 45 of file CosmicTrackTagger_module.cc.

int cosmic::CosmicTrackTagger::fEndTickPadding
private

Definition at line 42 of file CosmicTrackTagger_module.cc.

int cosmic::CosmicTrackTagger::fMaxTickDrift
private

Definition at line 46 of file CosmicTrackTagger_module.cc.

int cosmic::CosmicTrackTagger::fMinTickDrift
private

Definition at line 46 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fTPCXBoundary
private

Definition at line 44 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fTPCYBoundary
private

Definition at line 44 of file CosmicTrackTagger_module.cc.

float cosmic::CosmicTrackTagger::fTPCZBoundary
private

Definition at line 44 of file CosmicTrackTagger_module.cc.

std::string cosmic::CosmicTrackTagger::fTrackModuleLabel
private

Definition at line 41 of file CosmicTrackTagger_module.cc.

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