Inheritance diagram for reco_tool::CandHitICARUS:

Public Member Functions
	CandHitICARUS (const fhicl::ParameterSet &pset)

void	findHitCandidates (const recob::Wire::RegionsOfInterest_t::datarange_t &, size_t, size_t, size_t, HitCandidateVec &) const override

void	MergeHitCandidates (const recob::Wire::RegionsOfInterest_t::datarange_t &, const HitCandidateVec &, MergeHitCandidateVec &) const override

Private Member Functions
void	findHitCandidates (std::vector< float >::const_iterator, std::vector< float >::const_iterator, size_t, double, HitCandidateVec &) const

void	expandHit (HitCandidate &h, std::vector< float > holder, HitCandidateVec how)

void	prova ()

Private Member Functions inherited from reco_tool::ICandidateHitFinder
virtual	~ICandidateHitFinder () noexcept=default

Private Attributes
int	fInd1Width

int	fInd2Width

int	fColWidth

unsigned int	fInd1Window

unsigned int	fInd2Window

unsigned int	fColWindow

int	fInd1Threshold

int	fInd2Threshold

int	fColThreshold

int	fInd1Above

int	fInd2Above

int	fColAbove

int	fInd1Fall

int	fInd2Fall

int	fColFall

float	fMinHitHeight

size_t	fNumInterveningTicks

const geo::GeometryCore *	fGeometry = lar::providerFrom<geo::Geometry>()

Additional Inherited Members
Private Types inherited from reco_tool::ICandidateHitFinder
using	HitCandidateVec = std::vector< HitCandidate >

using	MergeHitCandidateVec = std::vector< HitCandidateVec >

using	Waveform = std::vector< float >

Detailed Description

Definition at line 21 of file CandHitICARUS_tool.cc.

Constructor & Destructor Documentation

reco_tool::CandHitICARUS::CandHitICARUS ( const fhicl::ParameterSet & pset )

explicit

Definition at line 70 of file CandHitICARUS_tool.cc.

 {
     // Start by recovering the parameters
 
     fInd1Width = pset.get< int  >("Ind1Width");
     fInd2Width = pset.get< int  >("Ind2Width");
     fColWidth = pset.get< int  >("ColWidth");
     fInd1Window = pset.get< unsigned int  >("Ind1Window");
     fInd2Window = pset.get< unsigned int  >("Ind2Window");
     fColWindow = pset.get< unsigned int  >("ColWindow");
     fInd1Threshold = pset.get< int  >("Ind1Threshold");
     fInd2Threshold = pset.get< int  >("Ind2Threshold");
     fColThreshold = pset.get< int  >("ColThreshold");
     fInd1Above = pset.get< int  >("Ind1Above");
     fInd2Above = pset.get< int  >("Ind2Above");
     fColAbove = pset.get< int  >("ColAbove");
     fInd1Fall = pset.get< int  >("Ind1Fall");
     fInd2Fall = pset.get< int  >("Ind2Fall");
     fColFall = pset.get< int  >("ColFall");
     fMinHitHeight        = pset.get< float  >("MinHitHeight",        1.0);
     fNumInterveningTicks = pset.get< size_t >("NumInterveningTicks", 6);
 
     return;
 }

Member Function Documentation

void reco_tool::CandHitICARUS::expandHit	(	HitCandidate &	h,
		std::vector< float >	holder,
		HitCandidateVec	how
	)

private

Definition at line 453 of file CandHitICARUS_tool.cc.

     {
         // Given a hit or hit candidate <hit> expand its limits to the closest minima
         int nsamp=50;
         int cut=1;
         int upordown;
         int found=0;
 
         unsigned int first=h.startTick;
         unsigned int last =h.stopTick;
 
         std::vector<HitCandidate>::iterator hiter;
         std::vector<HitCandidate> hlist;
 
         // fill list of existing hits on this wire
         for(unsigned int j=0;j<how.size();j++)
         {
             HitCandidate h2=how[j];
             if(h2.hitCenter!=h.hitCenter)
                 hlist.push_back(h2);
         }
 
 
         // look for first sample
         while(!found)
         {
             if(first==0)
                 break;
 
             for(hiter=hlist.begin();hiter!=hlist.end();hiter++)
             {
                HitCandidate h2=*hiter;
                 if(first==h2.stopTick)
                     found=1;
             }
 
             if(found==1) break;
 
             upordown=0;
             for(int l=0;l<nsamp/2;l++)
             {
                 if(first-nsamp/2+l<4095) {
                     if(holder[first-nsamp/2+l+1]-holder[first-nsamp/2+l]>0) upordown++;
                     else if(holder[first-nsamp/2+l+1]-holder[first-nsamp/2+l]<0) upordown--;
                 } }
             //std::cout << " checking " << first << " upordown " << upordown << std::endl;
             if(upordown>cut)
                 first--;
             else
                 found=1;
         }
 
         // look for last sample
         found=0;
         while(!found)
         {
             if(last==4095)
             {
                 found=1;
                 break;
             }
 
             for(hiter=hlist.begin();hiter!=hlist.end();hiter++)
             {
                 HitCandidate h2=*hiter;
                 if(first==h2.startTick)
                     found=1;
             }
 
             if(found==1) break;
 
             upordown=0;
             for(int l=0;l<nsamp/2;l++)
             {
                 if(last+nsamp/2-l>0) {
                     if(holder[last+nsamp/2-l]-holder[last+nsamp/2-l-1]>0) upordown++;
                     else if(holder[last+nsamp/2-l]-holder[last+nsamp/2-l-1]<0) upordown--;
                 } }
 
             if(upordown<-cut)
                 last++;
             else
                 found=1;
         }
 
         h.startTick=first;
         h.stopTick=last;
     }

void reco_tool::CandHitICARUS::findHitCandidates	(	const recob::Wire::RegionsOfInterest_t::datarange_t &	rangeData,
		size_t	roiStart,
		size_t	channel,
		size_t	cnt,
		HitCandidateVec &	hits
	)		const

overridevirtual

Implements reco_tool::ICandidateHitFinder.

Definition at line 95 of file CandHitICARUS_tool.cc.

 {
     // get the WireID for this hit
     std::vector<geo::WireID> wids = fGeometry->ChannelToWire(channel);
     // for now, just take the first option returned from ChannelToWire
     geo::WireID wid  = wids[0];
     // We need to know the plane to look up parameters
     geo::PlaneID::PlaneID_t plane = wid.Plane;
     //int wire = wid.Wire;
 
     const Waveform& waveform = rangeData.data();
 
    // if(plane==1) return;
     // if(wire>2639) return;
    // if(plane==0&&wire==528)
     // for( int j=0;j<4096;j++)
      // std::cout << " j " << j << " waveform " << waveform[j] << std::endl;
     int iflag;
     int localbellow,rising;
     int begin;
     // int nSamp=digitVec->Samples();
     int lastcomputedmean,count;
     int peakheight;
     int localminidx,localmin;
     // int jj, jcount;
     // float area;
     HitCandidate h;
     //std::vector<HitCandidate> hits;
     unsigned int i;
     // Hit finding parameters
     const int rise=5;
 
     double threshold=0;
     unsigned int window=0;
     int abovecut(0),fall(0);
     unsigned int width(0);
 
 
     // initialize parameters
     iflag=0;                // equal to one if we are within a hit candidate
     peakheight=-9999;       // last found hit maximum
     begin=-1;               // last found hit initial sample
     localbellow=0;          // number of times we are bellow peakheight
     lastcomputedmean=0;     // the value we compare with to know if we have a hit
     count=0;
     for(unsigned int j=0;j<window;j++)
         count+=waveform[j];
     lastcomputedmean=(count>=0)? 0 : count/window;
     //      negpeakwidth=0;
     //      if(lastcomputedmean<0) negpeakwidth++;
     localmin=9999;
     localminidx=-1;
 
     // loop on the selected samples
 
             //std::cout << "candhitfinderICARUS " << std::endl;
 
     if(plane == 0) threshold=fInd1Threshold;
     else if(plane == 1) threshold=fInd2Threshold;
     else if(plane == 2) threshold=fColThreshold;
     if(plane == 0) window=fInd1Window;
     else if(plane == 1) window=fInd2Window;
     else if(plane == 2) window=fColWindow;
     if(plane == 0) abovecut=fInd1Above;
     else if(plane == 1) abovecut=fInd2Above;
     else if(plane == 2) abovecut=fColAbove;
     if(plane == 0) fall=fInd1Fall;
     else if(plane == 1) fall=fInd2Fall;
     else if(plane == 2) fall=fColFall;
     if(plane == 0) width=fInd1Width;
     else if(plane == 1) width=fInd2Width;
     else if(plane == 2) width=fColWidth;
 
     for( i=0;i<4096;i++)
     { //2
         //std::cout << " i " << i << " waveform " << waveform[i] << std::endl;
         // skip sharp peaks
         //if(abs(waveform[i]-lastcomputedmean)>100)
         //  continue;
 
         if(!iflag)
             lastcomputedmean=0;
 
         if(waveform[i]-lastcomputedmean>threshold) // we're within a hit OR hit group
         { //3
             //      if(iwire==4526&&plane==2&&cryostat==0&&tpc==0)
              //   std::cout << " over threshold bin " << i << std::endl;
             iflag=1;
 
             // we're in the beginning of the hit
             if(begin<0) {
 
                 begin=i;     // hit starting point
             }
 
             // keep peak info
             if(waveform[i]-lastcomputedmean>peakheight)
             {
                 peakheight=waveform[i]-lastcomputedmean;
      //           h.hitCenter=waveform[i];
                 h.hitHeight=peakheight;
 //                h.iWire=iw;
                 h.hitCenter=i;
               //  std::cout << " hitcenter " << i << std::endl;
                 localbellow=0;
             }
 
             // resolve close hits
             //          if(*(pf+i)-(peakheight+lastcomputedmean)<-threshold) // we're in the slope down
             if(waveform[i]-(peakheight+lastcomputedmean)<-1) // we're in the slope down
             {
                 localbellow++;
              //   std::cout << " i " << i << " localbellow " << localbellow << " abovecut " << abovecut << std::endl;
             }
             if(localbellow>abovecut)
             { //4
                 // keep local minimum as border between consecutive hits
                 if(waveform[i]<localmin) {localmin=waveform[i];localminidx=i;}
 
                 // count the number of rising samples within the following n=<rise> samples
                 rising=0;
                 for(int l=0;l<rise;l++)
                 {
                     if(i+l<4096) {
                         if(waveform[i+l+1]-waveform[i+l]>0) rising++;
                         else if(waveform[i+l+1]-waveform[i+l]<0) rising--;
                     }
                 }
             //    std::cout << " rising " << rising << " abovecut " << abovecut << std::endl;
                 // if after a slope down there's a slope up save the previous hit
                 if(rising>abovecut)
                 { //5
                     h.startTick=begin;
                     //              h.finDrift=i+iniSamp;
                     h.stopTick=localminidx;
 
                 //std::cout << "  saving previous hit " << begin << " fin " << localminidx << std::endl;
 
                     if((h.stopTick-h.hitCenter)>=fall && h.stopTick-h.startTick>width)
                     { //6
                         h.minTick=h.startTick;
                         h.maxTick=h.stopTick;
                         // std::cout << " adding hit case 1" << std::endl;
                         h.hitSigma      = 0.5*(h.stopTick-h.startTick);
 
                         hits.push_back(h);
                         peakheight=-9999;
                         h.hitHeight=0;
                         //begin=i+iniSamp+1;
                         begin=localminidx+1;
                         localbellow=0;
                         localminidx=-1;
                         localmin=9999;
                     }
                 }
             }
         }
         else // outside the hit
         { //3
             //if (  typ == BasicData::ISBASICPLANE_PMT  && iw==1){
             //    cout << "out hit " << iflag << "iadc " << h.iAdcMax <<endl;
             //    cout << " in, fin " << begin << " " << i+iniSamp << "peak "<<h.iDrift <<endl;}
             if (iflag==1 && h.hitHeight) //just getting out of the latest hit
             { //4
                 h.startTick=begin;
                 h.stopTick=i;
 
                 if((h.stopTick-h.hitCenter)>=fall && (h.stopTick-h.startTick)>width)
                 { //5
                     h.minTick=h.startTick;
                     h.maxTick=h.stopTick;
                     //if(iwire==4526&&plane==1&&cryostat==0&&tpc==0)
                     //std::cout << " adding hit case 2, tick " << i << std::endl;
                  //   if(cryostat==0&&tpc==0&&plane==2&&h.iWire==2656)
                    //     std::cout << "  before expand ini " << h.iniDrift << " fin " << h.finDrift << std::endl;
                 //expandHit(h,waveform,hits);
 
                    // if(cryostat==0&&tpc==0&&plane==2&&h.iWire==2656)
                      //   std::cout << "  after expand ini " << h.iniDrift << " fin " << h.finDrift << std::endl;
                     h.hitSigma      = 0.5*(h.stopTick-h.startTick);
 
                     hits.push_back(h);
                     //InsertHit(&h);
                     //  if ( typ != BasicData::ISBASICPLANE_PMT)
 
                 }
 
                 peakheight=-9999;
                 begin=-1;
                 iflag=0;
                 localbellow=0;
             }
 
         }
 
         //keep the last mean value to which we have to come back after the hit
         if(i>=window && window) {
             if(waveform[i]-count/window>-10)
             {
                 count+=waveform[i];
                 count-=waveform[i-window];
                 //        if((float) count/window<0) negpeakwidth++;
                 //        else negpeakwidth=0;
             }
         }
     } //end loop on samples
 
     //if we were within a hit while reaching last sample, keep it
     if(iflag==1 && h.hitHeight) //just getting out of the latest hit
     { //3
         h.startTick=begin;
         h.stopTick=i-1;
 
         if((h.stopTick-h.hitCenter)>=fall && (h.stopTick-h.startTick)>width)
         {
           //  if(cryostat==0&&tpc==0&&plane==2&&h.iWire==2656)
 //                std::cout << "  before expand ini " << h.iniDrift << " fin " << h.finDrift << std::endl;
        // expandHit(h,waveform,hits);
 
   //          if(cryostat==0&&tpc==0&&plane==2&&h.iWire==2656)
     //            std::cout << "  after expand ini " << h.iniDrift << " fin " << h.finDrift << std::endl;
             h.minTick=h.startTick;
             h.maxTick=h.stopTick;
             //std::cout << " adding hit case 3 " << i << std::endl;
 
             h.hitSigma      = 0.5*(h.stopTick-h.startTick);
             hits.push_back(h);
             // InsertHit(&h);
         }
     }
   //  if(hits.size())
   //   std::cout << " wire " << wire << " found hits " << hits.size() << std::endl;
 
 
 
     return;
 }

void reco_tool::CandHitICARUS::findHitCandidates	(	std::vector< float >::const_iterator	startItr,
		std::vector< float >::const_iterator	stopItr,
		size_t	roiStartTick,
		double	roiThreshold,
		HitCandidateVec &	hitCandidateVec
	)		const

private

Definition at line 337 of file CandHitICARUS_tool.cc.

 {
     // Need a minimum number of ticks to do any work here
     if (std::distance(startItr,stopItr) > 4)
     {
         // Find the highest peak in the range given
         auto maxItr = std::max_element(startItr, stopItr);
 
         float maxValue = *maxItr;
         int   maxTime  = std::distance(startItr,maxItr);
 
         if (maxValue > roiThreshold)
         {
             // backwards to find first bin for this candidate hit
             auto firstItr = std::distance(startItr,maxItr) > 2 ? maxItr - 1 : startItr;
 
             while(firstItr != startItr)
             {
                 // Check for pathology where waveform goes too negative
                 if (*firstItr < -roiThreshold) break;
 
                 // Check both sides of firstItr and look for min/inflection point
                 if (*firstItr < *(firstItr+1) && *firstItr <= *(firstItr-1)) break;
 
                 firstItr--;
             }
 
             int firstTime = std::distance(startItr,firstItr);
 
             // Recursive call to find all candidate hits earlier than this peak
             findHitCandidates(startItr, firstItr + 1, roiStartTick, roiThreshold, hitCandidateVec);
 
             // forwards to find last bin for this candidate hit
             auto lastItr = std::distance(maxItr,stopItr) > 2 ? maxItr + 1 : stopItr - 1;
 
             while(lastItr != stopItr - 1)
             {
                 // Check for pathology where waveform goes too negative
                 if (*lastItr < -roiThreshold) break;
 
                 // Check both sides of firstItr and look for min/inflection point
                 if (*lastItr <= *(lastItr+1) && *lastItr < *(lastItr-1)) break;
 
                 lastItr++;
             }
 
             int lastTime = std::distance(startItr,lastItr);
 
             // Now save this candidate's start and max time info
             HitCandidate hitCandidate;
             hitCandidate.startTick     = roiStartTick + firstTime;
             hitCandidate.stopTick      = roiStartTick + lastTime;
             hitCandidate.maxTick       = roiStartTick + firstTime;
             hitCandidate.minTick       = roiStartTick + lastTime;
             hitCandidate.maxDerivative = *(startItr + firstTime);
             hitCandidate.minDerivative = *(startItr + lastTime);
             hitCandidate.hitCenter     = roiStartTick + maxTime;
             hitCandidate.hitSigma      = std::max(2.,float(lastTime - firstTime) / 6.);
             hitCandidate.hitHeight     = maxValue;
 
             hitCandidateVec.push_back(hitCandidate);
 
             // Recursive call to find all candidate hits later than this peak
             findHitCandidates(lastItr + 1, stopItr, roiStartTick + std::distance(startItr,lastItr + 1), roiThreshold, hitCandidateVec);
         }
     }
 
     return;
 }

void reco_tool::CandHitICARUS::MergeHitCandidates	(	const recob::Wire::RegionsOfInterest_t::datarange_t &	rangeData,
		const HitCandidateVec &	hitCandidateVec,
		MergeHitCandidateVec &	mergedHitsVec
	)		const

overridevirtual

Implements reco_tool::ICandidateHitFinder.

Definition at line 411 of file CandHitICARUS_tool.cc.

 {
     // If nothing on the input end then nothing to do
     if (hitCandidateVec.empty()) return;
 
     // The idea is to group hits that "touch" so they can be part of common fit, those that
     // don't "touch" are fit independently. So here we build the output vector to achieve that
     // Get a container for the hits...
     HitCandidateVec groupedHitVec;
 
     // Initialize the end of the last hit which we'll set to the first input hit's stop
     size_t lastStopTick = hitCandidateVec.front().stopTick;
 
     // Step through the input hit candidates and group them by proximity
     for(const auto& hitCandidate : hitCandidateVec)
     {
         // Small pulse height hits should not be considered?
         if (hitCandidate.hitHeight > fMinHitHeight)
         {
             // Check condition that we have a new grouping
             if (hitCandidate.startTick > lastStopTick + fNumInterveningTicks && !groupedHitVec.empty())
             {
                 mergedHitsVec.emplace_back(groupedHitVec);
 
                 groupedHitVec.clear();
             }
 
             // Add the current hit to the current group
             groupedHitVec.emplace_back(hitCandidate);
 
             lastStopTick = hitCandidate.stopTick;
         }
     }
 
     // Check end condition
     if (!groupedHitVec.empty()) mergedHitsVec.emplace_back(groupedHitVec);
 
     return;
 }

void reco_tool::CandHitICARUS::prova ( )

inlineprivate

Definition at line 45 of file CandHitICARUS_tool.cc.

45 {return ;}

Member Data Documentation

int reco_tool::CandHitICARUS::fColAbove

private

Definition at line 58 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fColFall

private

Definition at line 61 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fColThreshold

private

Definition at line 55 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fColWidth

private

Definition at line 49 of file CandHitICARUS_tool.cc.

unsigned int reco_tool::CandHitICARUS::fColWindow

private

Definition at line 52 of file CandHitICARUS_tool.cc.

const geo::GeometryCore* reco_tool::CandHitICARUS::fGeometry = lar::providerFrom<geo::Geometry>()

private

Definition at line 65 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd1Above

private

Definition at line 56 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd1Fall

private

Definition at line 59 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd1Threshold

private

Definition at line 53 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd1Width

private

Definition at line 47 of file CandHitICARUS_tool.cc.

unsigned int reco_tool::CandHitICARUS::fInd1Window

private

Definition at line 50 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd2Above

private

Definition at line 57 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd2Fall

private

Definition at line 60 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd2Threshold

private

Definition at line 54 of file CandHitICARUS_tool.cc.

int reco_tool::CandHitICARUS::fInd2Width

private

Definition at line 48 of file CandHitICARUS_tool.cc.

unsigned int reco_tool::CandHitICARUS::fInd2Window

private

Definition at line 51 of file CandHitICARUS_tool.cc.

float reco_tool::CandHitICARUS::fMinHitHeight

private

Definition at line 62 of file CandHitICARUS_tool.cc.

size_t reco_tool::CandHitICARUS::fNumInterveningTicks

private

Definition at line 63 of file CandHitICARUS_tool.cc.

The documentation for this class was generated from the following file:

CandHitICARUS_tool.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation