LArSoft  v10_04_05
Liquid Argon Software toolkit - https://larsoft.org/
opdet Namespace Reference

Classes

class  DefaultOpDetResponse
 
class  FIFOHistogramAna
 
class  FlashHypothesis
 
class  FlashHypothesisAna
 
class  FlashHypothesisAnaAlg
 
class  FlashHypothesisCalculator
 
class  FlashHypothesisCollection
 
class  FlashHypothesisComparison
 
class  FlashHypothesisCreator
 
class  FlashUtilities
 
class  HitAlgoMakerToolBase
 Base art tool class wrapping a hit algorithm. More...
 
struct  IHitAlgoMakerTool
 Tool interface for creating a hit finder algorithm. More...
 
struct  IPedAlgoMakerTool
 Tool interface for creating a pedestal estimator algorithm. More...
 
class  LEDCalibrationAna
 
class  MicrobooneOpDetResponse
 
class  OpDetResponseInterface
 
class  OpDigiAna
 
class  OpDigiProperties
 
class  OpFlashAna
 
class  OpFlashAnaAlg
 
class  OpFlashFinder
 
class  OpFlashMCTruthAna
 
class  OpFlashSimpleAna
 
class  OpHitAna
 
class  OpHitFinder
 
class  OpMCDigi
 
class  OptDetDigitizer
 
class  OpticalRawDigitReformatter
 
class  PedAlgoMakerToolBase
 Base art tool class wrapping a pedestal estimator algorithm. More...
 
class  PhotonInf
 
class  SimPhotonCounter
 
class  SimPhotonCounterAlg
 

Functions

void writeHistogram (std::vector< double > const &binned)
 
void checkOnBeamFlash (std::vector< recob::OpFlash > const &FlashVector)
 
void RunFlashFinder (std::vector< recob::OpHit > const &HitVector, std::vector< recob::OpFlash > &FlashVector, std::vector< std::vector< int >> &AssocList, double const BinWidth, geo::GeometryCore const &geom, geo::WireReadoutGeom const &wireReadoutGeom, float const FlashThreshold, float const WidthTolerance, detinfo::DetectorClocksData const &ClocksData, float const TrigCoinc)
 
unsigned int GetAccumIndex (double const PeakTime, double const MinTime, double const BinWidth, double const BinOffset)
 
void FillAccumulator (unsigned int const &AccumIndex, unsigned int const &HitIndex, double const PE, float const FlashThreshold, std::vector< double > &Binned, std::vector< std::vector< int >> &Contributors, std::vector< int > &FlashesInAccumulator)
 
void FillFlashesBySizeMap (std::vector< int > const &FlashesInAccumulator, std::vector< double > const &BinnedPE, int const &Accumulator, std::map< double, std::map< int, std::vector< int >>, std::greater< double >> &FlashesBySize)
 
void FillHitsThisFlash (std::vector< std::vector< int >> const &Contributors, int const &Bin, std::vector< int > const &HitClaimedByFlash, std::vector< int > &HitsThisFlash)
 
void ClaimHits (std::vector< recob::OpHit > const &HitVector, std::vector< int > const &HitsThisFlash, float const FlashThreshold, std::vector< std::vector< int >> &HitsPerFlash, std::vector< int > &HitClaimedByFlash)
 
void AssignHitsToFlash (std::vector< int > const &FlashesInAccumulator1, std::vector< int > const &FlashesInAccumulator2, std::vector< double > const &Binned1, std::vector< double > const &Binned2, std::vector< std::vector< int >> const &Contributors1, std::vector< std::vector< int >> const &Contributors2, std::vector< recob::OpHit > const &HitVector, std::vector< std::vector< int >> &HitsPerFlash, float const FlashThreshold)
 
void FindSeedHit (std::map< double, std::vector< int >, std::greater< double >> const &HitsBySize, std::vector< bool > &HitsUsed, std::vector< recob::OpHit > const &HitVector, std::vector< int > &HitsThisRefinedFlash, double &PEAccumulated, double &FlashMaxTime, double &FlashMinTime)
 
void AddHitToFlash (int const &HitID, std::vector< bool > &HitsUsed, recob::OpHit const &currentHit, double const WidthTolerance, std::vector< int > &HitsThisRefinedFlash, double &PEAccumulated, double &FlashMaxTime, double &FlashMinTime)
 
void CheckAndStoreFlash (std::vector< std::vector< int >> &RefinedHitsPerFlash, std::vector< int > const &HitsThisRefinedFlash, double const PEAccumulated, float const FlashThreshold, std::vector< bool > &HitsUsed)
 
void RefineHitsInFlash (std::vector< int > const &HitsThisFlash, std::vector< recob::OpHit > const &HitVector, std::vector< std::vector< int >> &RefinedHitsPerFlash, float const WidthTolerance, float const FlashThreshold)
 
void AddHitContribution (recob::OpHit const &currentHit, double &MaxTime, double &MinTime, double &AveTime, double &FastToTotal, double &AveAbsTime, double &TotalPE, std::vector< double > &PEs)
 
void GetHitGeometryInfo (recob::OpHit const &currentHit, geo::GeometryCore const &geom, geo::WireReadoutGeom const &wireReadoutGeom, std::vector< double > &sumw, std::vector< double > &sumw2, double &sumy, double &sumy2, double &sumz, double &sumz2)
 
double CalculateWidth (double const sum, double const sum_squared, double const weights_sum)
 
void ConstructFlash (std::vector< int > const &HitsPerFlashVec, std::vector< recob::OpHit > const &HitVector, std::vector< recob::OpFlash > &FlashVector, geo::GeometryCore const &geom, geo::WireReadoutGeom const &wireReadoutGeom, detinfo::DetectorClocksData const &ClocksData, float const TrigCoinc)
 
double GetLikelihoodLateLight (double const iPE, double const iTime, double const iWidth, double const jPE, double const jTime, double const jWidth)
 
void MarkFlashesForRemoval (std::vector< recob::OpFlash > const &FlashVector, size_t const BeginFlash, std::vector< bool > &MarkedForRemoval)
 
void RemoveFlashesFromVectors (std::vector< bool > const &MarkedForRemoval, std::vector< recob::OpFlash > &FlashVector, size_t const BeginFlash, std::vector< std::vector< int >> &RefinedHitsPerFlash)
 
void RemoveLateLight (std::vector< recob::OpFlash > &FlashVector, std::vector< std::vector< int >> &RefinedHitsPerFlash)
 
template<typename T , typename Compare >
std::vector< int > sort_permutation (std::vector< T > const &vec, int offset, Compare compare)
 
template<typename T >
void apply_permutation (std::vector< T > &vec, std::vector< int > const &p)
 
void RunHitFinder (std::vector< raw::OpDetWaveform > const &opDetWaveformVector, std::vector< recob::OpHit > &hitVector, pmtana::PulseRecoManager const &pulseRecoMgr, pmtana::PMTPulseRecoBase const &threshAlg, geo::WireReadoutGeom const &wireReadoutGeom, float hitThreshold, detinfo::DetectorClocksData const &clocksData, calib::IPhotonCalibrator const &calibrator, bool use_start_time)
 
void ConstructHit (float hitThreshold, int channel, double timeStamp, pmtana::pulse_param const &pulse, std::vector< recob::OpHit > &hitVector, detinfo::DetectorClocksData const &clocksData, calib::IPhotonCalibrator const &calibrator, bool use_start_time)
 

Detailed Description

Title: FlashHypothesis Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that represents a flash hypothesis (PEs per opdet) and its error

Title: FlashUtilities Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that contains utility functions for flash and flash hypotheses: — compare a flash hypothesis to a truth or reco vector — get an extent of a flash (central point, width) These classes should operate using simple objects, and will need other classes/functions to fill those vectors properly.

Title: OpFlash Algorithims Authors, editors: Ben Jones, MIT Wes Ketchum wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov Gleb Sinev gleb..nosp@m.sine.nosp@m.v@duk.nosp@m.e.ed.nosp@m.u Alex Himmel ahimm.nosp@m.el@f.nosp@m.nal.g.nosp@m.ov

Description: These are the algorithms used by OpFlashFinder to produce flashes.

Title: OpHit Algorithims Authors, editors: Ben Jones, MIT Wes Ketchum wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov Gleb Sinev gleb..nosp@m.sine.nosp@m.v@duk.nosp@m.e.ed.nosp@m.u Alex Himmel ahimm.nosp@m.el@f.nosp@m.nal.g.nosp@m.ov Kevin Wood kevin.nosp@m..woo.nosp@m.d@sto.nosp@m.nybr.nosp@m.ook.e.nosp@m.du

Description: These are the algorithms used by OpHitFinder to produce optical hits.

Function Documentation

void opdet::AddHitContribution ( recob::OpHit const &  currentHit,
double &  MaxTime,
double &  MinTime,
double &  AveTime,
double &  FastToTotal,
double &  AveAbsTime,
double &  TotalPE,
std::vector< double > &  PEs 
)

Definition at line 443 of file OpFlashAlg.cxx.

References recob::OpHit::FastToTotal(), recob::OpHit::OpChannel(), recob::OpHit::PE(), recob::OpHit::PeakTime(), and recob::OpHit::PeakTimeAbs().

Referenced by ConstructFlash().

451  {
452  double PEThisHit = currentHit.PE();
453  double TimeThisHit = currentHit.PeakTime();
454  if (TimeThisHit > MaxTime) MaxTime = TimeThisHit;
455  if (TimeThisHit < MinTime) MinTime = TimeThisHit;
456 
457  // These quantities for the flash are defined
458  // as the weighted averages over the hits
459  AveTime += PEThisHit * TimeThisHit;
460  FastToTotal += PEThisHit * currentHit.FastToTotal();
461  AveAbsTime += PEThisHit * currentHit.PeakTimeAbs();
462 
463  // These are totals
464  TotalPE += PEThisHit;
465  PEs.at(static_cast<unsigned int>(currentHit.OpChannel())) += PEThisHit;
466  }
void opdet::AddHitToFlash ( int const &  HitID,
std::vector< bool > &  HitsUsed,
recob::OpHit const &  currentHit,
double const  WidthTolerance,
std::vector< int > &  HitsThisRefinedFlash,
double &  PEAccumulated,
double &  FlashMaxTime,
double &  FlashMinTime 
)

Definition at line 321 of file OpFlashAlg.cxx.

References util::abs(), recob::OpHit::PE(), recob::OpHit::PeakTime(), and recob::OpHit::Width().

Referenced by RefineHitsInFlash().

329  {
330  if (HitsUsed.at(HitID)) return;
331 
332  double HitTime = currentHit.PeakTime();
333  double HitWidth = 0.5 * currentHit.Width();
334  double FlashTime = 0.5 * (FlashMaxTime + FlashMinTime);
335  double FlashWidth = 0.5 * (FlashMaxTime - FlashMinTime);
336 
337  if (std::abs(HitTime - FlashTime) > WidthTolerance * (HitWidth + FlashWidth)) return;
338 
339  HitsThisRefinedFlash.push_back(HitID);
340  FlashMaxTime = std::max(FlashMaxTime, HitTime + HitWidth);
341  FlashMinTime = std::min(FlashMinTime, HitTime - HitWidth);
342  PEAccumulated += currentHit.PE();
343  HitsUsed[HitID] = true;
344 
345  } // End AddHitToFlash
constexpr auto abs(T v)
Returns the absolute value of the argument.
template<typename T >
void opdet::apply_permutation ( std::vector< T > &  vec,
std::vector< int > const &  p 
)

Definition at line 684 of file OpFlashAlg.cxx.

Referenced by RemoveLateLight().

685  {
686 
687  std::vector<T> sorted_vec(p.size());
688  std::transform(p.begin(), p.end(), sorted_vec.begin(), [&](int i) { return vec[i]; });
689  vec = sorted_vec;
690  }
void opdet::AssignHitsToFlash ( std::vector< int > const &  FlashesInAccumulator1,
std::vector< int > const &  FlashesInAccumulator2,
std::vector< double > const &  Binned1,
std::vector< double > const &  Binned2,
std::vector< std::vector< int >> const &  Contributors1,
std::vector< std::vector< int >> const &  Contributors2,
std::vector< recob::OpHit > const &  HitVector,
std::vector< std::vector< int >> &  HitsPerFlash,
float const  FlashThreshold 
)

Definition at line 242 of file OpFlashAlg.cxx.

References ClaimHits(), FillFlashesBySizeMap(), and FillHitsThisFlash().

Referenced by RunFlashFinder().

251  {
252  // Sort all the flashes found by size. The structure is:
253  // FlashesBySize[flash size][accumulator_num] = [flash_index1, flash_index2...]
254  std::map<double, std::map<int, std::vector<int>>, std::greater<double>> FlashesBySize;
255 
256  // Sort the flashes by size using map
257  FillFlashesBySizeMap(FlashesInAccumulator1, Binned1, 1, FlashesBySize);
258  FillFlashesBySizeMap(FlashesInAccumulator2, Binned2, 2, FlashesBySize);
259 
260  // This keeps track of which hits are claimed by which flash
261  std::vector<int> HitClaimedByFlash(HitVector.size(), -1);
262 
263  // Walk from largest to smallest, claiming hits.
264  // The biggest flash always gets dibbs,
265  // but we keep track of overlaps for re-merging later (do we? ---WK)
266  for (auto const& itFlash : FlashesBySize)
267  // If several with same size, walk through accumulators
268  for (auto const& itAcc : itFlash.second) {
269 
270  int Accumulator = itAcc.first;
271 
272  // Walk through flash-tagged bins in this accumulator
273  for (auto const& Bin : itAcc.second) {
274 
275  std::vector<int> HitsThisFlash;
276 
277  if (Accumulator == 1)
278  FillHitsThisFlash(Contributors1, Bin, HitClaimedByFlash, HitsThisFlash);
279  else if (Accumulator == 2)
280  FillHitsThisFlash(Contributors2, Bin, HitClaimedByFlash, HitsThisFlash);
281 
282  ClaimHits(HitVector, HitsThisFlash, FlashThreshold, HitsPerFlash, HitClaimedByFlash);
283 
284  } // End loop over this accumulator
285 
286  } // End loops over accumulators
287  // End of loops over sorted flashes
288 
289  } // End AssignHitsToFlash
void FillHitsThisFlash(std::vector< std::vector< int >> const &Contributors, int const &Bin, std::vector< int > const &HitClaimedByFlash, std::vector< int > &HitsThisFlash)
Definition: OpFlashAlg.cxx:208
void ClaimHits(std::vector< recob::OpHit > const &HitVector, std::vector< int > const &HitsThisFlash, float const FlashThreshold, std::vector< std::vector< int >> &HitsPerFlash, std::vector< int > &HitClaimedByFlash)
Definition: OpFlashAlg.cxx:220
void FillFlashesBySizeMap(std::vector< int > const &FlashesInAccumulator, std::vector< double > const &BinnedPE, int const &Accumulator, std::map< double, std::map< int, std::vector< int >>, std::greater< double >> &FlashesBySize)
Definition: OpFlashAlg.cxx:197
double opdet::CalculateWidth ( double const  sum,
double const  sum_squared,
double const  weights_sum 
)

Definition at line 500 of file OpFlashAlg.cxx.

Referenced by ConstructFlash().

501  {
502  if (sum_squared * weights_sum - sum * sum < 0)
503  return 0;
504  else
505  return std::sqrt(sum_squared * weights_sum - sum * sum) / weights_sum;
506  }
Double_t sum
Definition: plot.C:31
void opdet::CheckAndStoreFlash ( std::vector< std::vector< int >> &  RefinedHitsPerFlash,
std::vector< int > const &  HitsThisRefinedFlash,
double const  PEAccumulated,
float const  FlashThreshold,
std::vector< bool > &  HitsUsed 
)

Definition at line 348 of file OpFlashAlg.cxx.

Referenced by RefineHitsInFlash().

353  {
354  // If above threshold, we just add hits to the flash vector, and move on
355  if (PEAccumulated >= FlashThreshold) {
356  RefinedHitsPerFlash.push_back(HitsThisRefinedFlash);
357  return;
358  }
359 
360  // If there is only one hit in collection, we can immediately move on
361  if (HitsThisRefinedFlash.size() == 1) return;
362 
363  // We need to release all other hits (allow possible reuse)
364  for (std::vector<int>::const_iterator hitIterator = std::next(HitsThisRefinedFlash.begin());
365  hitIterator != HitsThisRefinedFlash.end();
366  ++hitIterator)
367  HitsUsed.at(*hitIterator) = false;
368 
369  } // End CheckAndStoreFlash
intermediate_table::const_iterator const_iterator
void opdet::checkOnBeamFlash ( std::vector< recob::OpFlash > const &  FlashVector)

Definition at line 53 of file OpFlashAlg.cxx.

54  {
55  for (auto const& flash : FlashVector)
56  if (flash.OnBeamTime() == 1)
57  std::cout << "OnBeamFlash with time " << flash.Time() << std::endl;
58  }
void opdet::ClaimHits ( std::vector< recob::OpHit > const &  HitVector,
std::vector< int > const &  HitsThisFlash,
float const  FlashThreshold,
std::vector< std::vector< int >> &  HitsPerFlash,
std::vector< int > &  HitClaimedByFlash 
)

Definition at line 220 of file OpFlashAlg.cxx.

Referenced by AssignHitsToFlash().

225  {
226  // Check for newly claimed hits
227  double PE = 0;
228  for (auto const& Hit : HitsThisFlash)
229  PE += HitVector.at(Hit).PE();
230 
231  if (PE < FlashThreshold) return;
232 
233  // Add the flash to the list
234  HitsPerFlash.push_back(HitsThisFlash);
235 
236  // And claim all the hits
237  for (auto const& Hit : HitsThisFlash)
238  if (HitClaimedByFlash.at(Hit) == -1) HitClaimedByFlash.at(Hit) = HitsPerFlash.size() - 1;
239  }
void opdet::ConstructFlash ( std::vector< int > const &  HitsPerFlashVec,
std::vector< recob::OpHit > const &  HitVector,
std::vector< recob::OpFlash > &  FlashVector,
geo::GeometryCore const &  geom,
geo::WireReadoutGeom const &  wireReadoutGeom,
detinfo::DetectorClocksData const &  ClocksData,
float const  TrigCoinc 
)

Definition at line 509 of file OpFlashAlg.cxx.

References util::abs(), AddHitContribution(), CalculateWidth(), detinfo::ElecClock::Frame(), GetHitGeometryInfo(), geo::WireReadoutGeom::MaxOpChannel(), geo::WireReadoutGeom::Nplanes(), detinfo::DetectorClocksData::OpticalClock(), and detinfo::DetectorClocksData::TriggerTime().

Referenced by RunFlashFinder().

516  {
517  double MaxTime = -std::numeric_limits<double>::max();
518  double MinTime = std::numeric_limits<double>::max();
519 
520  std::vector<double> PEs(wireReadoutGeom.MaxOpChannel() + 1, 0.0);
521  unsigned int Nplanes = wireReadoutGeom.Nplanes();
522  std::vector<double> sumw(Nplanes, 0.0);
523  std::vector<double> sumw2(Nplanes, 0.0);
524 
525  double TotalPE = 0;
526  double AveTime = 0;
527  double AveAbsTime = 0;
528  double FastToTotal = 0;
529  double sumy = 0;
530  double sumz = 0;
531  double sumy2 = 0;
532  double sumz2 = 0;
533 
534  for (auto const& HitID : HitsPerFlashVec) {
536  HitVector.at(HitID), MaxTime, MinTime, AveTime, FastToTotal, AveAbsTime, TotalPE, PEs);
538  HitVector.at(HitID), geom, wireReadoutGeom, sumw, sumw2, sumy, sumy2, sumz, sumz2);
539  }
540 
541  AveTime /= TotalPE;
542  AveAbsTime /= TotalPE;
543  FastToTotal /= TotalPE;
544 
545  double meany = sumy / TotalPE;
546  double meanz = sumz / TotalPE;
547 
548  double widthy = CalculateWidth(sumy, sumy2, TotalPE);
549  double widthz = CalculateWidth(sumz, sumz2, TotalPE);
550 
551  std::vector<double> WireCenters(Nplanes, 0.0);
552  std::vector<double> WireWidths(Nplanes, 0.0);
553 
554  for (size_t p = 0; p != Nplanes; ++p) {
555  WireCenters.at(p) = sumw.at(p) / TotalPE;
556  WireWidths.at(p) = CalculateWidth(sumw.at(p), sumw2.at(p), TotalPE);
557  }
558 
559  // Emprical corrections to get the Frame right.
560  // Eventual solution - remove frames
561  int Frame = ClocksData.OpticalClock().Frame(AveAbsTime - 18.1);
562  if (Frame == 0) Frame = 1;
563 
564  int BeamFrame = ClocksData.OpticalClock().Frame(ClocksData.TriggerTime());
565  bool InBeamFrame = false;
566  if (!(ClocksData.TriggerTime() < 0)) InBeamFrame = (Frame == BeamFrame);
567 
568  double TimeWidth = (MaxTime - MinTime) / 2.0;
569 
570  int OnBeamTime = 0;
571  if (InBeamFrame && (std::abs(AveTime) < TrigCoinc)) OnBeamTime = 1;
572 
573  FlashVector.emplace_back(AveTime,
574  TimeWidth,
575  AveAbsTime,
576  Frame,
577  PEs,
578  InBeamFrame,
579  OnBeamTime,
580  FastToTotal,
581  meany,
582  widthy,
583  meanz,
584  widthz,
585  WireCenters,
586  WireWidths);
587  }
void AddHitContribution(recob::OpHit const &currentHit, double &MaxTime, double &MinTime, double &AveTime, double &FastToTotal, double &AveAbsTime, double &TotalPE, std::vector< double > &PEs)
Definition: OpFlashAlg.cxx:443
constexpr auto abs(T v)
Returns the absolute value of the argument.
double CalculateWidth(double const sum, double const sum_squared, double const weights_sum)
Definition: OpFlashAlg.cxx:500
void GetHitGeometryInfo(recob::OpHit const &currentHit, geo::GeometryCore const &geom, geo::WireReadoutGeom const &wireReadoutGeom, std::vector< double > &sumw, std::vector< double > &sumw2, double &sumy, double &sumy2, double &sumz, double &sumz2)
Definition: OpFlashAlg.cxx:469
void opdet::ConstructHit ( float  hitThreshold,
int  channel,
double  timeStamp,
pmtana::pulse_param const &  pulse,
std::vector< recob::OpHit > &  hitVector,
detinfo::DetectorClocksData const &  clocksData,
calib::IPhotonCalibrator const &  calibrator,
bool  use_start_time 
)

Definition at line 68 of file OpHitAlg.cxx.

References pmtana::pulse_param::area, detinfo::ElecClock::Frame(), detinfo::DetectorClocksData::OpticalClock(), calib::IPhotonCalibrator::PE(), pmtana::pulse_param::peak, pmtana::pulse_param::t_end, pmtana::pulse_param::t_max, pmtana::pulse_param::t_rise, pmtana::pulse_param::t_start, detinfo::ElecClock::TickPeriod(), detinfo::DetectorClocksData::TriggerTime(), and calib::IPhotonCalibrator::UseArea().

Referenced by RunHitFinder().

76  {
77  if (pulse.peak < hitThreshold) return;
78 
79  double absTime = timeStamp + clocksData.OpticalClock().TickPeriod() *
80  (use_start_time ? pulse.t_start : pulse.t_max);
81 
82  double relTime = absTime - clocksData.TriggerTime();
83 
84  double startTime =
85  timeStamp + clocksData.OpticalClock().TickPeriod() * pulse.t_start - clocksData.TriggerTime();
86 
87  double riseTime = clocksData.OpticalClock().TickPeriod() * pulse.t_rise;
88 
89  int frame = clocksData.OpticalClock().Frame(timeStamp);
90 
91  double PE = 0.0;
92  if (calibrator.UseArea())
93  PE = calibrator.PE(pulse.area, channel);
94  else
95  PE = calibrator.PE(pulse.peak, channel);
96 
97  double width = (pulse.t_end - pulse.t_start) * clocksData.OpticalClock().TickPeriod();
98 
99  hitVector.emplace_back(channel,
100  relTime,
101  absTime,
102  startTime,
103  riseTime,
104  frame,
105  width,
106  pulse.area,
107  pulse.peak,
108  PE,
109  0.0);
110  }
void opdet::FillAccumulator ( unsigned int const &  AccumIndex,
unsigned int const &  HitIndex,
double const  PE,
float const  FlashThreshold,
std::vector< double > &  Binned,
std::vector< std::vector< int >> &  Contributors,
std::vector< int > &  FlashesInAccumulator 
)

Definition at line 178 of file OpFlashAlg.cxx.

Referenced by RunFlashFinder().

185  {
186 
187  Contributors.at(AccumIndex).push_back(HitIndex);
188 
189  Binned.at(AccumIndex) += PE;
190 
191  // If this wasn't a flash already, add it to the list
192  if (Binned.at(AccumIndex) >= FlashThreshold && (Binned.at(AccumIndex) - PE) < FlashThreshold)
193  FlashesInAccumulator.push_back(AccumIndex);
194  }
void opdet::FillFlashesBySizeMap ( std::vector< int > const &  FlashesInAccumulator,
std::vector< double > const &  BinnedPE,
int const &  Accumulator,
std::map< double, std::map< int, std::vector< int >>, std::greater< double >> &  FlashesBySize 
)

Definition at line 197 of file OpFlashAlg.cxx.

Referenced by AssignHitsToFlash().

202  {
203  for (auto const& flash : FlashesInAccumulator)
204  FlashesBySize[BinnedPE.at(flash)][Accumulator].push_back(flash);
205  }
void opdet::FillHitsThisFlash ( std::vector< std::vector< int >> const &  Contributors,
int const &  Bin,
std::vector< int > const &  HitClaimedByFlash,
std::vector< int > &  HitsThisFlash 
)

Definition at line 208 of file OpFlashAlg.cxx.

Referenced by AssignHitsToFlash().

212  {
213  // For each hit in the flash
214  for (auto const& HitIndex : Contributors.at(Bin))
215  // If unclaimed, claim it
216  if (HitClaimedByFlash.at(HitIndex) == -1) HitsThisFlash.push_back(HitIndex);
217  }
void opdet::FindSeedHit ( std::map< double, std::vector< int >, std::greater< double >> const &  HitsBySize,
std::vector< bool > &  HitsUsed,
std::vector< recob::OpHit > const &  HitVector,
std::vector< int > &  HitsThisRefinedFlash,
double &  PEAccumulated,
double &  FlashMaxTime,
double &  FlashMinTime 
)

Definition at line 292 of file OpFlashAlg.cxx.

Referenced by RefineHitsInFlash().

299  {
300  for (auto const& itHit : HitsBySize)
301  for (auto const& HitID : itHit.second) {
302 
303  if (HitsUsed.at(HitID)) continue;
304 
305  PEAccumulated = HitVector.at(HitID).PE();
306  FlashMaxTime = HitVector.at(HitID).PeakTime() + 0.5 * HitVector.at(HitID).Width();
307  FlashMinTime = HitVector.at(HitID).PeakTime() - 0.5 * HitVector.at(HitID).Width();
308 
309  HitsThisRefinedFlash.clear();
310  HitsThisRefinedFlash.push_back(HitID);
311 
312  HitsUsed.at(HitID) = true;
313  return;
314 
315  } // End loop over inner vector
316  // End loop over HitsBySize map
317 
318  } // End FindSeedHit
unsigned int opdet::GetAccumIndex ( double const  PeakTime,
double const  MinTime,
double const  BinWidth,
double const  BinOffset 
)

Definition at line 169 of file OpFlashAlg.cxx.

Referenced by RunFlashFinder().

173  {
174  return static_cast<unsigned int>((PeakTime - MinTime + BinOffset) / BinWidth);
175  }
void opdet::GetHitGeometryInfo ( recob::OpHit const &  currentHit,
geo::GeometryCore const &  geom,
geo::WireReadoutGeom const &  wireReadoutGeom,
std::vector< double > &  sumw,
std::vector< double > &  sumw2,
double &  sumy,
double &  sumy2,
double &  sumz,
double &  sumz2 
)

Definition at line 469 of file OpFlashAlg.cxx.

References geo::GeometryCore::FindTPCAtPosition(), geo::CryostatID::isValid, geo::PlaneGeo::NearestWireID(), geo::WireReadoutGeom::Nplanes(), recob::OpHit::OpChannel(), geo::WireReadoutGeom::OpDetGeoFromOpChannel(), recob::OpHit::PE(), geo::WireReadoutGeom::Plane(), w, and geo::WireID::Wire.

Referenced by ConstructFlash().

478  {
479  auto const xyz = wireReadoutGeom.OpDetGeoFromOpChannel(currentHit.OpChannel()).GetCenter();
480  double PEThisHit = currentHit.PE();
481 
482  geo::TPCID tpc = geom.FindTPCAtPosition(xyz);
483  // if the point does not fall into any TPC,
484  // it does not contribute to the average wire position
485  if (tpc.isValid) {
486  for (size_t p = 0; p != wireReadoutGeom.Nplanes(); ++p) {
487  geo::PlaneID const planeID(tpc, p);
488  unsigned int w = wireReadoutGeom.Plane(planeID).NearestWireID(xyz).Wire;
489  sumw.at(p) += PEThisHit * w;
490  sumw2.at(p) += PEThisHit * w * w;
491  }
492  } // if we found the TPC
493  sumy += PEThisHit * xyz.Y();
494  sumy2 += PEThisHit * xyz.Y() * xyz.Y();
495  sumz += PEThisHit * xyz.Z();
496  sumz2 += PEThisHit * xyz.Z() * xyz.Z();
497  }
The data type to uniquely identify a Plane.
Definition: geo_types.h:364
bool isValid
Whether this ID points to a valid element.
Definition: geo_types.h:194
The data type to uniquely identify a TPC.
Definition: geo_types.h:306
Float_t w
Definition: plot.C:20
double opdet::GetLikelihoodLateLight ( double const  iPE,
double const  iTime,
double const  iWidth,
double const  jPE,
double const  jTime,
double const  jWidth 
)

Definition at line 590 of file OpFlashAlg.cxx.

Referenced by MarkFlashesForRemoval().

596  {
597  if (iTime > jTime) return 1e6;
598 
599  // Calculate hypothetical PE if this were actually a late flash from i.
600  // Argon time const is 1600 ns, so 1.6.
601  double HypPE = iPE * jWidth / iWidth * std::exp(-(jTime - iTime) / 1.6);
602  double nsigma = (jPE - HypPE) / std::sqrt(HypPE);
603  return nsigma;
604  }
void opdet::MarkFlashesForRemoval ( std::vector< recob::OpFlash > const &  FlashVector,
size_t const  BeginFlash,
std::vector< bool > &  MarkedForRemoval 
)

Definition at line 607 of file OpFlashAlg.cxx.

References GetLikelihoodLateLight().

Referenced by RemoveLateLight().

610  {
611  for (size_t iFlash = BeginFlash; iFlash != FlashVector.size(); ++iFlash) {
612 
613  double iTime = FlashVector.at(iFlash).Time();
614  double iPE = FlashVector.at(iFlash).TotalPE();
615  double iWidth = FlashVector.at(iFlash).TimeWidth();
616 
617  for (size_t jFlash = iFlash + 1; jFlash != FlashVector.size(); ++jFlash) {
618 
619  if (MarkedForRemoval.at(jFlash - BeginFlash)) continue;
620 
621  double jTime = FlashVector.at(jFlash).Time();
622  double jPE = FlashVector.at(jFlash).TotalPE();
623  double jWidth = FlashVector.at(jFlash).TimeWidth();
624 
625  // If smaller than, or within 2sigma of expectation,
626  // attribute to late light and toss out
627  if (GetLikelihoodLateLight(iPE, iTime, iWidth, jPE, jTime, jWidth) < 3.0)
628  MarkedForRemoval.at(jFlash - BeginFlash) = true;
629  }
630  }
631  }
double GetLikelihoodLateLight(double const iPE, double const iTime, double const iWidth, double const jPE, double const jTime, double const jWidth)
Definition: OpFlashAlg.cxx:590
void opdet::RefineHitsInFlash ( std::vector< int > const &  HitsThisFlash,
std::vector< recob::OpHit > const &  HitVector,
std::vector< std::vector< int >> &  RefinedHitsPerFlash,
float const  WidthTolerance,
float const  FlashThreshold 
)

Definition at line 372 of file OpFlashAlg.cxx.

References AddHitToFlash(), CheckAndStoreFlash(), and FindSeedHit().

Referenced by RunFlashFinder().

377  {
378  // Sort the hits by their size using map
379  // HitsBySize[HitSize] = [hit1, hit2 ...]
380  std::map<double, std::vector<int>, std::greater<double>> HitsBySize;
381  for (auto const& HitID : HitsThisFlash)
382  HitsBySize[HitVector.at(HitID).PE()].push_back(HitID);
383 
384  // Heres what we do:
385  // 1.Start with the biggest remaining hit
386  // 2.Look for any within one width of this hit
387  // 3.Find the new upper and lower bounds of the flash
388  // 4.Collect again
389  // 5.Repeat until no new hits collected
390  // 6.Remove these hits from consideration and repeat
391 
392  std::vector<bool> HitsUsed(HitVector.size(), false);
393  double PEAccumulated, FlashMaxTime, FlashMinTime;
394  std::vector<int> HitsThisRefinedFlash;
395 
396  while (true) {
397 
398  HitsThisRefinedFlash.clear();
399  PEAccumulated = 0;
400  FlashMaxTime = 0;
401  FlashMinTime = 0;
402 
403  FindSeedHit(HitsBySize,
404  HitsUsed,
405  HitVector,
406  HitsThisRefinedFlash,
407  PEAccumulated,
408  FlashMaxTime,
409  FlashMinTime);
410 
411  if (HitsThisRefinedFlash.size() == 0) return;
412 
413  // Start this at zero to do the while at least once
414  size_t NHitsThisRefinedFlash = 0;
415 
416  // If size of HitsThisRefinedFlash is same size,
417  // that means we're not adding anymore
418  while (NHitsThisRefinedFlash < HitsThisRefinedFlash.size()) {
419  NHitsThisRefinedFlash = HitsThisRefinedFlash.size();
420 
421  for (auto const& itHit : HitsBySize)
422  for (auto const& HitID : itHit.second)
423  AddHitToFlash(HitID,
424  HitsUsed,
425  HitVector.at(HitID),
426  WidthTolerance,
427  HitsThisRefinedFlash,
428  PEAccumulated,
429  FlashMaxTime,
430  FlashMinTime);
431  }
432 
433  // We did our collecting, now check if the flash is
434  // still good and push back
436  RefinedHitsPerFlash, HitsThisRefinedFlash, PEAccumulated, FlashThreshold, HitsUsed);
437 
438  } // End while there are hits left
439 
440  } // End RefineHitsInFlash
void CheckAndStoreFlash(std::vector< std::vector< int >> &RefinedHitsPerFlash, std::vector< int > const &HitsThisRefinedFlash, double const PEAccumulated, float const FlashThreshold, std::vector< bool > &HitsUsed)
Definition: OpFlashAlg.cxx:348
void FindSeedHit(std::map< double, std::vector< int >, std::greater< double >> const &HitsBySize, std::vector< bool > &HitsUsed, std::vector< recob::OpHit > const &HitVector, std::vector< int > &HitsThisRefinedFlash, double &PEAccumulated, double &FlashMaxTime, double &FlashMinTime)
Definition: OpFlashAlg.cxx:292
void AddHitToFlash(int const &HitID, std::vector< bool > &HitsUsed, recob::OpHit const &currentHit, double const WidthTolerance, std::vector< int > &HitsThisRefinedFlash, double &PEAccumulated, double &FlashMaxTime, double &FlashMinTime)
Definition: OpFlashAlg.cxx:321
void opdet::RemoveFlashesFromVectors ( std::vector< bool > const &  MarkedForRemoval,
std::vector< recob::OpFlash > &  FlashVector,
size_t const  BeginFlash,
std::vector< std::vector< int >> &  RefinedHitsPerFlash 
)

Definition at line 634 of file OpFlashAlg.cxx.

Referenced by RemoveLateLight().

638  {
639  for (int iFlash = MarkedForRemoval.size() - 1; iFlash != -1; --iFlash)
640  if (MarkedForRemoval.at(iFlash)) {
641  RefinedHitsPerFlash.erase(RefinedHitsPerFlash.begin() + iFlash);
642  FlashVector.erase(FlashVector.begin() + BeginFlash + iFlash);
643  }
644  }
void opdet::RemoveLateLight ( std::vector< recob::OpFlash > &  FlashVector,
std::vector< std::vector< int >> &  RefinedHitsPerFlash 
)

Definition at line 647 of file OpFlashAlg.cxx.

References apply_permutation(), MarkFlashesForRemoval(), RemoveFlashesFromVectors(), and sort_permutation().

Referenced by RunFlashFinder().

649  {
650  std::vector<bool> MarkedForRemoval(RefinedHitsPerFlash.size(), false);
651 
652  size_t const BeginFlash = FlashVector.size() - RefinedHitsPerFlash.size();
653 
654  recob::OpFlashSortByTime sort_flash_by_time;
655 
656  // Determine the sort of FlashVector starting at BeginFlash
657  auto sort_order = sort_permutation(FlashVector, BeginFlash, sort_flash_by_time);
658 
659  // Sort the RefinedHitsPerFlash in the same way as tail end of FlashVector
660  apply_permutation(RefinedHitsPerFlash, sort_order);
661 
662  std::sort(FlashVector.begin() + BeginFlash, FlashVector.end(), sort_flash_by_time);
663 
664  MarkFlashesForRemoval(FlashVector, BeginFlash, MarkedForRemoval);
665 
666  RemoveFlashesFromVectors(MarkedForRemoval, FlashVector, BeginFlash, RefinedHitsPerFlash);
667 
668  } // End RemoveLateLight
void apply_permutation(std::vector< T > &vec, std::vector< int > const &p)
Definition: OpFlashAlg.cxx:684
void MarkFlashesForRemoval(std::vector< recob::OpFlash > const &FlashVector, size_t const BeginFlash, std::vector< bool > &MarkedForRemoval)
Definition: OpFlashAlg.cxx:607
std::vector< int > sort_permutation(std::vector< T > const &vec, int offset, Compare compare)
Definition: OpFlashAlg.cxx:672
void RemoveFlashesFromVectors(std::vector< bool > const &MarkedForRemoval, std::vector< recob::OpFlash > &FlashVector, size_t const BeginFlash, std::vector< std::vector< int >> &RefinedHitsPerFlash)
Definition: OpFlashAlg.cxx:634
void opdet::RunFlashFinder ( std::vector< recob::OpHit > const &  HitVector,
std::vector< recob::OpFlash > &  FlashVector,
std::vector< std::vector< int >> &  AssocList,
double const  BinWidth,
geo::GeometryCore const &  geom,
geo::WireReadoutGeom const &  wireReadoutGeom,
float const  FlashThreshold,
float const  WidthTolerance,
detinfo::DetectorClocksData const &  ClocksData,
float const  TrigCoinc 
)

Definition at line 61 of file OpFlashAlg.cxx.

References AssignHitsToFlash(), ConstructFlash(), FillAccumulator(), GetAccumIndex(), RefineHitsInFlash(), and RemoveLateLight().

Referenced by opdet::OpFlashFinder::produce().

71  {
72  // Initial size for accumulators - will be automatically extended if needed
73  int initialsize = 6400;
74 
75  // These are the accumulators which will hold broad-binned light yields
76  std::vector<double> Binned1(initialsize);
77  std::vector<double> Binned2(initialsize);
78 
79  // These will keep track of which pulses put activity in each bin
80  std::vector<std::vector<int>> Contributors1(initialsize);
81  std::vector<std::vector<int>> Contributors2(initialsize);
82 
83  // These will keep track of where we have met the flash condition
84  // (in order to prevent second pointless loop)
85  std::vector<int> FlashesInAccumulator1;
86  std::vector<int> FlashesInAccumulator2;
87 
88  double minTime = std::numeric_limits<float>::max();
89  for (auto const& hit : HitVector)
90  if (hit.PeakTime() < minTime) minTime = hit.PeakTime();
91 
92  for (auto const& hit : HitVector) {
93 
94  double peakTime = hit.PeakTime();
95 
96  unsigned int AccumIndex1 = GetAccumIndex(peakTime, minTime, BinWidth, 0.0);
97 
98  unsigned int AccumIndex2 = GetAccumIndex(peakTime, minTime, BinWidth, BinWidth / 2.0);
99 
100  // Extend accumulators if needed (2 always larger than 1)
101  if (AccumIndex2 >= Binned1.size()) {
102  std::cout << "Extending vectors to " << AccumIndex2 * 1.2 << std::endl;
103  Binned1.resize(AccumIndex2 * 1.2);
104  Binned2.resize(AccumIndex2 * 1.2);
105  Contributors1.resize(AccumIndex2 * 1.2);
106  Contributors2.resize(AccumIndex2 * 1.2);
107  }
108 
109  size_t const hitIndex = &hit - &HitVector[0];
110 
111  FillAccumulator(AccumIndex1,
112  hitIndex,
113  hit.PE(),
114  FlashThreshold,
115  Binned1,
116  Contributors1,
117  FlashesInAccumulator1);
118 
119  FillAccumulator(AccumIndex2,
120  hitIndex,
121  hit.PE(),
122  FlashThreshold,
123  Binned2,
124  Contributors2,
125  FlashesInAccumulator2);
126 
127  } // End loop over hits
128 
129  // Now start to create flashes.
130  // First, need vector to keep track of which hits belong to which flashes
131  std::vector<std::vector<int>> HitsPerFlash;
132 
133  AssignHitsToFlash(FlashesInAccumulator1,
134  FlashesInAccumulator2,
135  Binned1,
136  Binned2,
137  Contributors1,
138  Contributors2,
139  HitVector,
140  HitsPerFlash,
141  FlashThreshold);
142 
143  // Now we do the fine grained part.
144  // Subdivide each flash into sub-flashes with overlaps within hit widths
145  // (assumed wider than photon travel time)
146  std::vector<std::vector<int>> RefinedHitsPerFlash;
147  for (auto const& HitsThisFlash : HitsPerFlash)
149  HitsThisFlash, HitVector, RefinedHitsPerFlash, WidthTolerance, FlashThreshold);
150 
151  // Now we have all our hits assigned to a flash.
152  // Make the recob::OpFlash objects
153  for (auto const& HitsPerFlashVec : RefinedHitsPerFlash)
155  HitsPerFlashVec, HitVector, FlashVector, geom, wireReadoutGeom, ClocksData, TrigCoinc);
156 
157  RemoveLateLight(FlashVector, RefinedHitsPerFlash);
158 
159  //checkOnBeamFlash(FlashVector);
160 
161  // Finally, write the association list.
162  // back_inserter tacks the result onto the end of AssocList
163  for (auto& HitIndicesThisFlash : RefinedHitsPerFlash)
164  AssocList.push_back(HitIndicesThisFlash);
165 
166  } // End RunFlashFinder
void AssignHitsToFlash(std::vector< int > const &FlashesInAccumulator1, std::vector< int > const &FlashesInAccumulator2, std::vector< double > const &Binned1, std::vector< double > const &Binned2, std::vector< std::vector< int >> const &Contributors1, std::vector< std::vector< int >> const &Contributors2, std::vector< recob::OpHit > const &HitVector, std::vector< std::vector< int >> &HitsPerFlash, float const FlashThreshold)
Definition: OpFlashAlg.cxx:242
void RemoveLateLight(std::vector< recob::OpFlash > &FlashVector, std::vector< std::vector< int >> &RefinedHitsPerFlash)
Definition: OpFlashAlg.cxx:647
Detector simulation of raw signals on wires.
void RefineHitsInFlash(std::vector< int > const &HitsThisFlash, std::vector< recob::OpHit > const &HitVector, std::vector< std::vector< int >> &RefinedHitsPerFlash, float const WidthTolerance, float const FlashThreshold)
Definition: OpFlashAlg.cxx:372
unsigned int GetAccumIndex(double const PeakTime, double const MinTime, double const BinWidth, double const BinOffset)
Definition: OpFlashAlg.cxx:169
void ConstructFlash(std::vector< int > const &HitsPerFlashVec, std::vector< recob::OpHit > const &HitVector, std::vector< recob::OpFlash > &FlashVector, geo::GeometryCore const &geom, geo::WireReadoutGeom const &wireReadoutGeom, detinfo::DetectorClocksData const &ClocksData, float const TrigCoinc)
Definition: OpFlashAlg.cxx:509
void FillAccumulator(unsigned int const &AccumIndex, unsigned int const &HitIndex, double const PE, float const FlashThreshold, std::vector< double > &Binned, std::vector< std::vector< int >> &Contributors, std::vector< int > &FlashesInAccumulator)
Definition: OpFlashAlg.cxx:178
void opdet::RunHitFinder ( std::vector< raw::OpDetWaveform > const &  opDetWaveformVector,
std::vector< recob::OpHit > &  hitVector,
pmtana::PulseRecoManager const &  pulseRecoMgr,
pmtana::PMTPulseRecoBase const &  threshAlg,
geo::WireReadoutGeom const &  wireReadoutGeom,
float  hitThreshold,
detinfo::DetectorClocksData const &  clocksData,
calib::IPhotonCalibrator const &  calibrator,
bool  use_start_time 
)

Definition at line 29 of file OpHitAlg.cxx.

References ConstructHit(), pmtana::PMTPulseRecoBase::GetPulses(), geo::WireReadoutGeom::IsValidOpChannel(), and pmtana::PulseRecoManager::Reconstruct().

Referenced by opdet::OpHitFinder::produce().

38  {
39  for (auto const& waveform : opDetWaveformVector) {
40  const int channel = static_cast<int>(waveform.ChannelNumber());
41 
42  if (!wireReadoutGeom.IsValidOpChannel(channel)) {
43  mf::LogError("OpHitFinder")
44  << "Error! unrecognized channel number " << channel << ". Ignoring pulse";
45  continue;
46  }
47 
48  pulseRecoMgr.Reconstruct(waveform);
49 
50  // Get the result
51  auto const& pulses = threshAlg.GetPulses();
52 
53  const double timeStamp = waveform.TimeStamp();
54 
55  for (auto const& pulse : pulses)
56  ConstructHit(hitThreshold,
57  channel,
58  timeStamp,
59  pulse,
60  hitVector,
61  clocksData,
62  calibrator,
63  use_start_time);
64  }
65  }
MaybeLogger_< ELseverityLevel::ELsev_error, false > LogError
void ConstructHit(float hitThreshold, int channel, double timeStamp, pmtana::pulse_param const &pulse, std::vector< recob::OpHit > &hitVector, detinfo::DetectorClocksData const &clocksData, calib::IPhotonCalibrator const &calibrator, bool use_start_time)
Definition: OpHitAlg.cxx:68
template<typename T , typename Compare >
std::vector< int > opdet::sort_permutation ( std::vector< T > const &  vec,
int  offset,
Compare  compare 
)

Definition at line 672 of file OpFlashAlg.cxx.

Referenced by RemoveLateLight().

673  {
674 
675  std::vector<int> p(vec.size() - offset);
676  std::iota(p.begin(), p.end(), 0);
677  std::sort(
678  p.begin(), p.end(), [&](int i, int j) { return compare(vec[i + offset], vec[j + offset]); });
679  return p;
680  }
void opdet::writeHistogram ( std::vector< double > const &  binned)

Definition at line 35 of file OpFlashAlg.cxx.

36  {
37  TH1D* binned_histogram = new TH1D("binned_histogram",
38  "Collection of All OpHits;Time (ms);PEs",
39  binned.size(),
40  0,
41  binned.size());
42  for (size_t i = 0; i < binned.size(); ++i)
43  binned_histogram->SetBinContent(i, binned.at(i));
44 
45  TFile f_out("output_hist.root", "RECREATE");
46  binned_histogram->Write();
47  f_out.Close();
48 
49  delete binned_histogram;
50  }