dune::RobustHitFinder Class Reference

Inheritance diagram for dune::RobustHitFinder:

Public Member Functions
	RobustHitFinder (fhicl::ParameterSet const &p)
	RobustHitFinder (RobustHitFinder const &)=delete
	RobustHitFinder (RobustHitFinder &&)=delete
RobustHitFinder &	operator= (RobustHitFinder const &)=delete
RobustHitFinder &	operator= (RobustHitFinder &&)=delete
void	produce (art::Event &e) override
void	beginJob () override
void	reconfigure (fhicl::ParameterSet const &p)
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 ()
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 Member Functions
void	SetTreeVariables (const dune::ChannelInformation &chan, const dune::HitInformation &hit, const dune::HitLineFitAlg::HitLineFitResults &fitresult)
void	SetTreeVariablesMCTruth (const ChanMap_t &chanMap, art::Event &e)
void	MakeupMissedHits (ChanMap_t &chanMap, HitVec_t &hitVec)
void	FillHitInformation (dune::ChannelInformation &chan, dune::HitVec_t &hitVec, bool assumedHit)
bool	ValidTrigger (std::vector< unsigned int > evtTriggers, unsigned int &c1arg, unsigned int &c2arg, unsigned int &trignumarg)
float	TimeToDriftDist (float thistime, unsigned int thistpc)
float	TimeToDisplacement (float thistime)
float	TimeToX (float thistime, unsigned int thistpc)
float	hitGeomDist (TVector3 hitloc, TVector3 trigloc1, TVector3 trigloc2)
void	Reset ()

Private Attributes
TH1I *	hEventsByTrigger
TH1I *	hTracksByTrigger
TTree *	fAllTree
TTree *	fGoodTree
TTree *	fTree
int	run
int	subrun
int	event
double	t0
unsigned int	c1
unsigned int	c2
unsigned int	trignum
float	c1x
float	c1y
float	c1z
float	c2x
float	c2y
float	c2z
float	distancecut
std::vector< int >	allchannels
std::vector< int >	channel
std::vector< int >	wire
std::vector< int >	tpc
std::vector< int >	signalsize
std::vector< std::vector< float > >	signal
std::vector< std::vector< float > >	signalFilter
std::vector< float >	baseline
std::vector< float >	rms
std::vector< float >	baselineFilter
std::vector< float >	rmsFilter
std::vector< float >	pedmean
std::vector< float >	pedrms
std::vector< float >	integral
std::vector< float >	integralFilter
std::vector< float >	sumADC
std::vector< float >	sigmaintegral
std::vector< float >	sigmaintegralFilter
std::vector< float >	amplitude
std::vector< float >	amplitudeFilter
std::vector< float >	peaktick
std::vector< float >	peaktickFilter
std::vector< float >	peaktime
std::vector< float >	peaktimeFilter
std::vector< int >	begintick
std::vector< int >	endtick
std::vector< int >	width
std::vector< float >	hitx
std::vector< float >	hity
std::vector< float >	hitz
std::vector< float >	hiterrxlo
std::vector< float >	hiterrxhi
std::vector< float >	hiterrylo
std::vector< float >	hiterryhi
std::vector< float >	hiterrzlo
std::vector< float >	hiterrzhi
std::vector< float >	perpdist
std::vector< float >	hitt
std::vector< float >	driftdist
std::vector< bool >	countercut
float	fitconstant
float	fitconstanterr
float	fitlinear
float	fitlinearerr
float	fitquadratic
float	fitquadraticerr
float	fitchi2
float	fitsumsqrresidual
float	fitndf
float	fitmle
bool	fitsuccess
std::vector< bool >	fitrealhit
std::vector< float >	segmentlength
std::vector< bool >	assumedhit
std::vector< int >	numGoodHitsChan
std::vector< bool >	ismctruth
int	nwiresTPC0
int	nwiresTPC1
int	nwiresTPC2
int	nwiresTPC3
int	nwiresTPC4
int	nwiresTPC5
int	nwiresTPC6
int	nwiresTPC7
bool	fMakeTree
float	fHitGeomDistanceCut
std::string	fWireModuleLabel
std::string	fCounterT0ModuleLabel
std::vector< float >	fEfield
int	fSearchPreTicks
int	fSearchPostTicks
bool	fMakeupMissedHits
int	fMissedBufferTicksLow
int	fMissedBufferTicksHigh
float	fMinPedMean
float	fMaxPedMean
float	fMinPedRms
float	fMaxPedRms
bool	fUseMeasuredCounterPositions
bool	fConstantHitWidth
int	fPreHitTicks
int	fPostHitTicks
bool	fSimulation
float	fMCScale
float	fHorizRangeMin
float	fHorizRangeMax
float	fVertRangeMin
float	fVertRangeMax
float	fC1Vert
float	fC1Horiz
float	fC2Vert
float	fC2Horiz
std::map< unsigned int, std::pair< TVector3, std::vector< TVector3 > > >	fCounterPositionMap
dune::HitLineFitAlg	fFitAlg
dune::RMSHitFinderAlg	fHitFinderAlg
art::ServiceHandle< geo::Geometry >	fGeom
art::ServiceHandle< art::TFileService >	fTfs
detinfo::DetectorClocks const *	fClks
detinfo::DetectorProperties const *	fDetProp
const lariov::DetPedestalProvider &	fPedestalRetrievalAlg = *(lar::providerFrom<lariov::DetPedestalService>())
float	temppedmean
float	temppedrms
CLHEP::HepRandomEngine &	fEngine

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 95 of file RobustHitFinder_module.cc.

Constructor & Destructor Documentation

dune::RobustHitFinder::RobustHitFinder ( fhicl::ParameterSet const &  p )

explicit

Definition at line 274 of file RobustHitFinder_module.cc.

  : EDProducer{p},
    fFitAlg(p.get<fhicl::ParameterSet>("HitLineFitAlg")),
    fHitFinderAlg(p.get<fhicl::ParameterSet>("RMSHitFinderAlg")),
    fClks(lar::providerFrom<detinfo::DetectorClocksService>()),
    fDetProp(lar::providerFrom<detinfo::DetectorPropertiesService>()),
    fEngine(art::ServiceHandle<rndm::NuRandomService>{}->createEngine(*this,"HepJamesRandom","Seed"))
{
  this->reconfigure(p);

  recob::HitCollectionCreator::declare_products(producesCollector());
}

dune::RobustHitFinder::RobustHitFinder ( RobustHitFinder const &  )

delete

dune::RobustHitFinder::RobustHitFinder ( RobustHitFinder &&  )

delete

Member Function Documentation

void dune::RobustHitFinder::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 558 of file RobustHitFinder_module.cc.

{
  DAQToOffline::MakeCounterPositionMap("","counterInformation.txt",fCounterPositionMap,0,0,0);

  if (fMakeTree)
    {
      hEventsByTrigger = fTfs->make<TH1I>("hEventsByTrigger","Num events by trigger",3716,0,3716);
      hTracksByTrigger = fTfs->make<TH1I>("hTracksByTrigger","Num reconstructed tracks by trigger",3716,0,3716);

      fAllTree = fTfs->make<TTree>("AllTree","AllTree");
      fAllTree->Branch("run",&run,"run/I");
      fAllTree->Branch("subrun",&subrun,"subrun/I");
      fAllTree->Branch("event",&event,"event/I");
      fAllTree->Branch("c1",&c1,"c1/i");
      fAllTree->Branch("c2",&c2,"c2/i");
      fAllTree->Branch("trignum",&trignum,"trignum/i");

      fGoodTree = fTfs->make<TTree>("GoodTree","GoodTree");
      fGoodTree->Branch("run",&run,"run/I");
      fGoodTree->Branch("subrun",&subrun,"subrun/I");
      fGoodTree->Branch("event",&event,"event/I");
      fGoodTree->Branch("c1",&c1,"c1/i");
      fGoodTree->Branch("c2",&c2,"c2/i");
      fGoodTree->Branch("trignum",&trignum,"trignum/i");

      fTree = fTfs->make<TTree>("RobustHitFinder","RobustHitFinder");
      fTree->Branch("run",&run,"run/I");
      fTree->Branch("subrun",&subrun,"subrun/I");
      fTree->Branch("event",&event,"event/I");
      fTree->Branch("t0",&t0,"t0/D");
      fTree->Branch("c1",&c1,"c1/i");
      fTree->Branch("c2",&c2,"c2/i");
      fTree->Branch("trignum",&trignum,"trignum/i");
      fTree->Branch("c1x",&c1x,"c1x/F");
      fTree->Branch("c1y",&c1y,"c1y/F");
      fTree->Branch("c1z",&c1z,"c1z/F");
      fTree->Branch("c2x",&c2x,"c2x/F");
      fTree->Branch("c2y",&c2y,"c2y/F");
      fTree->Branch("c2z",&c2z,"c2z/F");
      fTree->Branch("distancecut",&distancecut,"distancecut/F");
      fTree->Branch("allchannels",&allchannels);
      fTree->Branch("channel",&channel);
      fTree->Branch("wire",&wire);
      fTree->Branch("tpc",&tpc);
      fTree->Branch("signalsize",&signalsize);
      //fTree->Branch("signal",&signal);
      //fTree->Branch("signalFilter",&signalFilter);
      fTree->Branch("baseline",&baseline);
      fTree->Branch("rms",&rms);
      fTree->Branch("baselineFilter",&baselineFilter);
      fTree->Branch("rmsFilter",&rmsFilter);
      fTree->Branch("pedmean",&pedmean);
      fTree->Branch("pedrms",&pedrms);
      fTree->Branch("integral",&integral);
      fTree->Branch("integralFilter",&integralFilter);
      fTree->Branch("sumADC",&sumADC);
      fTree->Branch("sigmaintegral",&sigmaintegral);
      fTree->Branch("sigmaintegralFilter",&sigmaintegralFilter);
      fTree->Branch("amplitude",&amplitude);
      fTree->Branch("amplitudeFilter",&amplitudeFilter);
      fTree->Branch("peaktick",&peaktick);
      fTree->Branch("peaktickFilter",&peaktickFilter);
      fTree->Branch("peaktime",&peaktime);
      fTree->Branch("peaktimeFilter",&peaktimeFilter);
      fTree->Branch("begintick",&begintick);
      fTree->Branch("endtick",&endtick);
      fTree->Branch("width",&width);
      fTree->Branch("hitx",&hitx);
      fTree->Branch("hity",&hity);
      fTree->Branch("hitz",&hitz);
      fTree->Branch("hiterrxlo",&hiterrxlo);
      fTree->Branch("hiterrxhi",&hiterrxhi);
      fTree->Branch("hiterrylo",&hiterrylo);
      fTree->Branch("hiterryhi",&hiterryhi);
      fTree->Branch("hiterrzlo",&hiterrzlo);
      fTree->Branch("hiterrzhi",&hiterrzhi);
      fTree->Branch("perpdist",&perpdist);
      fTree->Branch("hitt",&hitt);
      fTree->Branch("driftdist",&driftdist);
      fTree->Branch("countercut",&countercut);
      fTree->Branch("fitconstant",&fitconstant,"fitconstant/F");
      fTree->Branch("fitconstanterr",&fitconstanterr,"fitconstanterr/F");
      fTree->Branch("fitlinear",&fitlinear,"fitlinear/F");
      fTree->Branch("fitlinearerr",&fitlinearerr,"fitlinearerr/F");
      fTree->Branch("fitquadratic",&fitquadratic,"fitquadratic/F");
      fTree->Branch("fitquadraticerr",&fitquadraticerr,"fitquadraticerr/F");
      fTree->Branch("fitchi2",&fitchi2,"fitchi2/F");
      fTree->Branch("fitsumsqrresidual",&fitsumsqrresidual,"fitsumsqrresidual/F");
      fTree->Branch("fitndf",&fitndf,"fitndf/F");
      fTree->Branch("fitmle",&fitmle,"fitmle/F");
      fTree->Branch("fitsuccess",&fitsuccess,"fitsuccess/O");
      fTree->Branch("fitrealhit",&fitrealhit);
      fTree->Branch("assumedhit",&assumedhit);
      fTree->Branch("segmentlength",&segmentlength);
      fTree->Branch("numGoodHitsChan",&numGoodHitsChan);
      fTree->Branch("ismctruth",&ismctruth);
      fTree->Branch("nwiresTPC0",&nwiresTPC0,"nwiresTPC0/I");
      fTree->Branch("nwiresTPC1",&nwiresTPC1,"nwiresTPC1/I");
      fTree->Branch("nwiresTPC2",&nwiresTPC2,"nwiresTPC2/I");
      fTree->Branch("nwiresTPC3",&nwiresTPC3,"nwiresTPC3/I");
      fTree->Branch("nwiresTPC4",&nwiresTPC4,"nwiresTPC4/I");
      fTree->Branch("nwiresTPC5",&nwiresTPC5,"nwiresTPC5/I");
      fTree->Branch("nwiresTPC6",&nwiresTPC6,"nwiresTPC6/I");
      fTree->Branch("nwiresTPC7",&nwiresTPC7,"nwiresTPC7/I");
    }
}

void dune::RobustHitFinder::FillHitInformation ( dune::ChannelInformation &  chan, dune::HitVec_t &  hitVec, bool  assumedHit  )

private

Definition at line 887 of file RobustHitFinder_module.cc.

{
  //TF1 * gaus = new TF1("gaus","([0]/([2]*sqrt(2*3.1415926)))*exp(-0.5*(x-[1])*(x-[1])/([2]*[2]))+[3]+x*[4]",0,32000);
  //gaus->SetNpx(64000);

  for (size_t i_hit = 0; i_hit < chan.pulse_ends.size(); i_hit++)
    {
      dune::HitInformation hit;
      hit.channelID = chan.channelID;
      int begin_index,end_index;
      if (fConstantHitWidth)
        {
          std::vector<float>::iterator bi = chan.signalVec.begin()+chan.pulse_ends[i_hit].first;
          std::vector<float>::iterator ei = chan.signalVec.begin()+chan.pulse_ends[i_hit].second;
          float peak = std::distance(chan.signalVec.begin(),std::max_element(bi,ei));
          begin_index = (int)(peak-fPreHitTicks);
          end_index = (int)(peak+fPostHitTicks);
        }
      else
        {
          begin_index = chan.pulse_ends[i_hit].first;
          end_index = chan.pulse_ends[i_hit].second;
        }
      hit.hitBeginTick = begin_index;
      hit.hitEndTick = end_index;
      std::vector<float>::iterator beginitr = chan.signalVec.begin()+begin_index;
      std::vector<float>::iterator enditr = chan.signalVec.begin()+end_index;
      std::vector<float> pulse(beginitr,enditr);
      std::vector<float>::iterator fbeginitr = chan.signalFilterVec.begin()+begin_index;
      std::vector<float>::iterator fenditr = chan.signalFilterVec.begin()+end_index;
      std::vector<float> pulseFilter(fbeginitr,fenditr);
      hit.hitAmplitude = *std::max_element(beginitr,enditr)-chan.baseline;
      hit.hitAmplitudeFilter = *std::max_element(fbeginitr,fenditr)-chan.baselineFilter;
      hit.hitWidth = end_index-begin_index;
      hit.hitIntegral = std::accumulate(beginitr,enditr,0)-(hit.hitWidth*chan.baseline);
      hit.hitSumADC = hit.hitIntegral;
      hit.hitIntegralFilter = std::accumulate(fbeginitr,fenditr,0)-(hit.hitWidth*chan.baselineFilter);
      hit.hitSigmaIntegral = TMath::Sqrt(pulse.size())*TMath::RMS(pulse.size(),pulse.data());
      hit.hitSigmaIntegralFilter = TMath::Sqrt(pulseFilter.size())*TMath::RMS(pulseFilter.size(),pulseFilter.data());
      hit.hitPeakTick = std::distance(chan.signalVec.begin(),std::max_element(beginitr,enditr));
      hit.hitPeakTickFilter = std::distance(chan.signalFilterVec.begin(),std::max_element(fbeginitr,fenditr));
      hit.hitPeakTime = fClks->TPCTick2TrigTime(hit.hitPeakTick);
      hit.hitPeakTimeFilter = fClks->TPCTick2TrigTime(hit.hitPeakTickFilter);

      /*
         gaus->SetParameter(1,hit.hitPeakTick);
         gaus->SetParLimits(1,hit.hitPeakTick-10,hit.hitPeakTick+10);
         gaus->SetParameter(2,5);
         gaus->SetParLimits(2,1,end_index-begin_index);
         TGraph * gr = new TGraph();
         Int_t tick = 0;
         for (auto adc : chan.signalVec)
         {
          gr->SetPoint(tick,(Double_t)tick,(Double_t)adc);
         ++tick;
         }
         gr->Fit(gaus,"BQ0");

         hit.hitAmplitude = gaus->GetParameter(0)/(gaus->GetParameter(2)*sqrt(2*3.1415926));
         hit.hitIntegral = gaus->GetParameter(0);
         hit.hitSigmaIntegral = gaus->GetParError(0);
         hit.hitSumADC = std::accumulate(beginitr,enditr,0)-((end_index-begin_index)*chan.baseline);
         hit.hitWidth = gaus->GetParameter(2);
         hit.hitPeakTick = gaus->GetParameter(1);
         hit.hitPeakTime = fClks->TPCTick2TrigTime(hit.hitPeakTick);

         delete gr;
       */

      hit.hitt = hit.hitPeakTime - t0/1000;

      hit.hitx = TimeToX(hit.hitt,chan.tpcNum);
      hit.hity = 2.;
      hit.hitz = chan.chanz;
      hit.hiterrxlo = TMath::Sqrt(fabs(hit.hitx-TimeToDisplacement(fClks->TPCTick2TrigTime(hit.hitBeginTick)-t0/1000)));
      hit.hiterrxhi = TMath::Sqrt(fabs(hit.hitx-TimeToDisplacement(fClks->TPCTick2TrigTime(hit.hitEndTick)-t0/1000)));
      hit.hiterrylo = 0.;
      hit.hiterryhi = 0.;
      hit.hiterrzlo = 0.5/sqrt(12.0);
      hit.hiterrzhi = 0.5/sqrt(12.0);
      hit.driftdist = TimeToDriftDist(hit.hitt,chan.tpcNum);
      hit.perpdist = hitGeomDist(TVector3(hit.hitx,2.,hit.hitz),TVector3(c1x,2.,c1z),TVector3(c2x,2.,c2z));
      hit.countercut = (hit.perpdist < distancecut) ? true : false;
      hit.fitrealhit = false;
      hit.assumedhit = assumedHit;

      float tempsegmentlength = 0.449;
      if (trignum == 111)
        {
          double thetayz = TMath::ATan2((hit.hitx+1)-(hit.hitx-1),2);
          double tan2thetayz = TMath::Power(TMath::Tan(thetayz),2);
          double y2z2 = ((c1y-c2y)*(c1y-c2y))/((c1z-c2z)*(c1z-c2z));
          double projL = sqrt(1+tan2thetayz+y2z2);
          tempsegmentlength *= static_cast<float>(projL);
        }
      else if (trignum == 112 || trignum == 113)
        {
          double thetayx = TMath::ATan2(2,(hit.hitz+1)-(hit.hitz-1));
          double tan2thetayx = TMath::Power(TMath::Tan(thetayx),2);
          double y2x2 = ((c1y-c2y)*(c1y-c2y))/((c1x-c2x)*(c1x-c2x));
          double projL = sqrt(1+tan2thetayx*(1+y2x2));
          tempsegmentlength *= static_cast<float>(projL);
        }
      hit.pitchgamma = tempsegmentlength;


      recob::HitCreator temphit(*(chan.artWire),
                                fGeom->ChannelToWire(chan.channelID)[0],
                                hit.hitBeginTick,
                                hit.hitEndTick,
                                hit.hitWidth/sqrt(12.0),
                                hit.hitPeakTick,
                                hit.hitWidth/sqrt(12.0),
                                hit.hitAmplitude,
                                hit.hitAmplitude/sqrt(12.0),
                                hit.hitIntegral,
                                hit.hitSigmaIntegral,
                                hit.hitSumADC,
                                1,
                                -1,
                                0,
                                (int)(hit.hitWidth-2));
      hit.artHit = temphit.move();
      if (hit.hitx > -400 && hit.countercut) hitVec.push_back(hit);
    }
}

float dune::RobustHitFinder::hitGeomDist ( TVector3  hitloc, TVector3  trigloc1, TVector3  trigloc2  )

private

Definition at line 1322 of file RobustHitFinder_module.cc.

{
  return (((hitloc-trigloc1).Cross(hitloc-trigloc2)).Mag()/(trigloc2-trigloc1).Mag());
}

void dune::RobustHitFinder::MakeupMissedHits ( ChanMap_t &  chanMap, HitVec_t &  hitVec  )

private

Definition at line 689 of file RobustHitFinder_module.cc.

{
  for (int i_tpc = 0; i_tpc<8; ++i_tpc)
    {
      float chanbeginz = 99999;
      float chanendz = -99999;
      int chanbeginid = 99999;
      int chanendid = -99999;
      for (auto & chanitr : chanMap)
        {
          if (chanitr.second.tpcNum != i_tpc) continue;
          chanitr.second.nGoodHits = 0;
          for (auto & hit : hitVec)
            {
              if (hit.channelID == chanitr.first && hit.fitrealhit)
                {
                  chanitr.second.goodHitStartTick = hit.hitBeginTick;
                  chanitr.second.goodHitEndTick = hit.hitEndTick;
                  chanitr.second.nGoodHits++;
                }
            }
          if (chanitr.second.nGoodHits > 0 && chanitr.second.chanz < chanbeginz)
            {
              chanbeginz = chanitr.second.chanz;
              chanbeginid = chanitr.first;
            }
          if (chanitr.second.nGoodHits > 0 && chanitr.second.chanz > chanendz)
            {
              chanendz = chanitr.second.chanz;
              chanendid = chanitr.first;
            }
        }

      if (chanendz < chanbeginz)
        {
          mf::LogError("RobustHitFinder") << "Problem: chanbeginz=" << chanbeginz << " is greater than chanendz=" << chanendz;
          continue;
        }

      if (chanbeginid == 99999 || chanendid == -99999)
        {
          mf::LogError("RobustHitFinder") << "Track not found. No assumed hits added." << std::endl;
          continue;
        }

      if (chanMap[chanbeginid].tpcNum % 2 != chanMap[chanendid].tpcNum % 2)
        {
          mf::LogError("RobustHitFinder") << "Track crosses APA. Don't know how to deal with this yet.";
          continue;
        }

      std::vector<std::pair<float,int> > trackchans;
      for (auto const & chanitr : chanMap)
        {
          if (chanitr.second.tpcNum != i_tpc) continue;
          if (chanitr.second.chanz >= chanbeginz && chanitr.second.chanz <= chanendz && chanitr.second.tpcNum % 2 == chanMap[chanbeginid].tpcNum % 2)
            {
              trackchans.push_back(std::make_pair(chanitr.second.chanz,chanitr.first));
            }
        }
      std::sort(trackchans.begin(),trackchans.end());

      for (size_t i_tc = 0; i_tc < trackchans.size(); ++i_tc)
        {
          dune::ChannelInformation ch = chanMap[trackchans[i_tc].second];

          if (ch.nGoodHits == 0 && ch.chanz >= chanbeginz && ch.chanz <= chanendz)
            {
              int sub = 0;
              dune::ChannelInformation chnearlow = ch;
              while (chnearlow.nGoodHits != 1 && chnearlow.chanz >= chanbeginz)
                {
                  ++sub;
                  chnearlow = chanMap[trackchans[i_tc-sub].second];
                }

              int add = 0;
              dune::ChannelInformation chnearhigh = ch;
              while (chnearhigh.nGoodHits != 1 && chnearhigh.chanz <= chanendz)
                {
                  ++add;
                  chnearhigh = chanMap[trackchans[i_tc+add].second];
                }

              if (ch.tpcNum != chnearlow.tpcNum || ch.tpcNum != chnearhigh.tpcNum) continue;

              int cls = chnearlow.goodHitStartTick;
              int chs = chnearhigh.goodHitStartTick;
              int cle = chnearlow.goodHitEndTick;
              int che = chnearhigh.goodHitEndTick;
              double clz = chnearlow.chanz;
              double chz = chnearhigh.chanz;

              int chstart = cls + (((chs - cls) / (chz - clz)) * (ch.chanz - clz));
              int chend   = cle + (((che - cle) / (chz - clz)) * (ch.chanz - clz));

              if (!fConstantHitWidth)
                {
                  chstart -= fMissedBufferTicksLow;
                  chend   += fMissedBufferTicksHigh;
                }

              if (chz-clz < 0) continue;  // something really weird must've happened

              ch.pulse_ends.push_back(std::make_pair(chstart,chend));

              FillHitInformation(ch,hitVec,true);
            }
        }
    }
}

RobustHitFinder& dune::RobustHitFinder::operator= ( RobustHitFinder const &  )

delete

RobustHitFinder& dune::RobustHitFinder::operator= ( RobustHitFinder &&  )

delete

void dune::RobustHitFinder::produce ( art::Event &  e )

overridevirtual

Implements art::EDProducer.

Definition at line 287 of file RobustHitFinder_module.cc.

{
  Reset();

  recob::HitCollectionCreator hcol(e);

  fFitAlg.SetSeed(fEngine.getSeed());

  // get recob::Wires
  art::Handle< std::vector< recob::Wire> > wireHandle;
  if (!e.getByLabel(fWireModuleLabel,wireHandle))
    {
      mf::LogError("RobustHitFinder") << "No recob::Wires found when expected";
      hcol.put_into(e);
      return;
    }

  // get associated raw digits
  art::FindOneP<raw::RawDigit> rawdigits(wireHandle,e,fWireModuleLabel);

  // Get all T0 products
  art::Handle< std::vector< anab::T0> > t0Handle;
  if (!e.getByLabel(fCounterT0ModuleLabel,t0Handle))
    {
      mf::LogError("RobustHitFinder") << "No T0s found in this event";
      hcol.put_into(e);
      return;
    }

  // get associated external triggers
  art::FindManyP<raw::ExternalTrigger> triggers(t0Handle,e,fCounterT0ModuleLabel);

  run = e.run();
  subrun = e.subRun();
  event = e.event();

  const lariov::ChannelStatusProvider* fCSP = &art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
  for (size_t iwire = 0; iwire < wireHandle->size(); ++iwire)
    {
      art::Ptr<recob::Wire> wire(wireHandle,iwire);
      if (wire->View() != geo::kZ) continue;
      if (fCSP->IsBad(wire->Channel())) continue;
      int temptpc = fGeom->ChannelToWire(wire->Channel())[0].TPC;
      if (temptpc==0) nwiresTPC0++;
      else if (temptpc==1) nwiresTPC1++;
      else if (temptpc==2) nwiresTPC2++;
      else if (temptpc==3) nwiresTPC3++;
      else if (temptpc==4) nwiresTPC4++;
      else if (temptpc==5) nwiresTPC5++;
      else if (temptpc==6) nwiresTPC6++;
      else if (temptpc==7) nwiresTPC7++;
      else mf::LogVerbatim("RobustHitFinder") << "Unknown TPC";
      allchannels.push_back(wire->Channel());
    }

  for (size_t i_t0 = 0; i_t0 < t0Handle->size(); i_t0++)
    {
      art::Ptr<anab::T0> pt0(t0Handle,i_t0);
      t0 = pt0->Time();

      unsigned int tick0 = static_cast<unsigned int>(fClks->TPCG4Time2Tick(t0));
      mf::LogVerbatim("RobustHitFinder") << "Found t0 at TPC tick = " << tick0;

      std::vector<art::Ptr<raw::ExternalTrigger> > trigvec = triggers.at(i_t0);

      std::vector<unsigned int> evtTriggers;
      for (auto const &trig : trigvec) evtTriggers.push_back(trig->GetTrigID());

      if (!ValidTrigger(evtTriggers,c1,c2,trignum))
        {
          continue;
        }

      if (fUseMeasuredCounterPositions)
        {
          c1x = fCounterPositionMap[c1].first.X();
          c1y = fCounterPositionMap[c1].first.Y();
          c1z = fCounterPositionMap[c1].first.Z();
          c2x = fCounterPositionMap[c2].first.X();
          c2y = fCounterPositionMap[c2].first.Y();
          c2z = fCounterPositionMap[c2].first.Z();
        }
      else
        {
          try
            {
              const geo::AuxDetGeo & ad = fGeom->AuxDet(c1);
              double center[3] = {0.,0.,0.5*ad.Length()};
              ad.GetCenter(center);
              c1x = center[0];
              c1y = center[1];
              c1z = center[2];
            }
          catch (...)
            {
              std::cout << "AuxDet " << c1 << " not found. Aborting..." << std::endl;
              continue;
            }
          try
            {
              const geo::AuxDetGeo & ad = fGeom->AuxDet(c2);
              double center[3] = {0.,0.,0.5*ad.Length()};
              ad.GetCenter(center);
              c2x = center[0];
              c2y = center[1];
              c2z = center[2];
            }
          catch (...)
            {
              std::cout << "AuxDet " << c2 << " not found. Aborting..." << std::endl;
              continue;
            }
        }

      int triggercode = 100*c1+c2; //gives a 4 digit number, ABCD, where AB is c1 ID and CD is c2 ID
      hEventsByTrigger->Fill(triggercode);
      fAllTree->Fill();

      distancecut = fHitGeomDistanceCut;
      if (trignum == 111)
        {
          fHorizRangeMin = -10;
          fHorizRangeMax = 170;
          fVertRangeMin = -50;
          fVertRangeMax = 250;
          fC1Vert = c1x;
          fC1Horiz = c1z;
          fC2Vert = c2x;
          fC2Horiz = c2z;
          distancecut *= fabs(TMath::Sin(TMath::ATan2(c1z-c2z,c1x-c2x)));
        }
      if (trignum == 112 || trignum == 113)
        {
          fHorizRangeMin = -50;
          fHorizRangeMax = 250;
          fVertRangeMin = -10;
          fVertRangeMax = 170;
          fC1Vert = c1z;
          fC1Horiz = c1x;
          fC2Vert = c2z;
          fC2Horiz = c2x;
          distancecut *= fabs(TMath::Cos(TMath::ATan2(c1z-c2z,c1x-c2x)));
        }
      double counterslope = ((fC1Vert-fC2Vert)/(fC1Horiz-fC2Horiz));
      fFitAlg.SetParameter(0,10,fVertRangeMin,fVertRangeMax);
      fFitAlg.SetParameter(1,1,counterslope-0.15,counterslope+0.15);
      fFitAlg.SetParameter(2,0,-0.0002,0.0002);
      fFitAlg.SetHorizVertRanges(fHorizRangeMin,fHorizRangeMax,fVertRangeMin,fVertRangeMax);

      dune::ChanMap_t chanMap;

      for (size_t iwire = 0; iwire < wireHandle->size(); ++iwire)
        {
          art::Ptr<recob::Wire> pwire(wireHandle,iwire);
          if (fCSP->IsBad(pwire->Channel())) continue;
          art::Ptr<raw::RawDigit> prawdigit = rawdigits.at(iwire);

          if (pwire->View() != geo::kZ) continue;

          dune::ChannelInformation chan;

          chan.artWire = pwire;
          chan.artRawDigit = prawdigit;

          chan.signalVec.clear();
          chan.signalFilterVec.clear();

          chan.channelID = pwire->Channel();
          chan.wireID = fGeom->ChannelToWire(chan.channelID)[0].Wire;
          chan.tpcNum = fGeom->ChannelToWire(chan.channelID)[0].TPC;

          chan.signalVec = pwire->Signal();
          chan.signalSize = chan.signalVec.size();

          double wirexyz[3];
          fGeom->Wire(*(fGeom->ChannelToWire(chan.channelID).begin())).GetCenter(wirexyz);
          chan.chanz = static_cast<float>(wirexyz[2]);

          fHitFinderAlg.SetSearchTicks(tick0 - ((fSearchPreTicks>0) ? fSearchPreTicks : 0),
                                       tick0 + ((fSearchPostTicks>0) ? fSearchPostTicks : chan.signalSize));
          fHitFinderAlg.FilterWaveform(chan.signalVec,chan.signalFilterVec);
          fHitFinderAlg.RobustRMSBase(chan.signalVec,chan.baseline,chan.rms);
          fHitFinderAlg.RobustRMSBase(chan.signalFilterVec,chan.baselineFilter,chan.rmsFilter);

          temppedmean = fPedestalRetrievalAlg.PedMean(chan.channelID);
          temppedrms = fPedestalRetrievalAlg.PedRms(chan.channelID);

          if (temppedmean > fMaxPedMean || temppedmean < fMinPedMean || temppedrms > fMaxPedRms || temppedrms < fMinPedRms) continue;

          fHitFinderAlg.FindHits(chan);

          chanMap.emplace(std::make_pair(chan.channelID,chan));
        }

      if (chanMap.size() == 0)
        {
          continue;
        }

      dune::HitVec_t hitVec;
      for (auto & chanmapitr : chanMap)
        {
          FillHitInformation(chanmapitr.second,hitVec,false);
        }
      if (hitVec.size() == 0)
        {
          continue;
        }

      std::vector<dune::HitLineFitAlg::HitLineFitData> fitdata;
      for (auto & hit : hitVec)
        {
          dune::HitLineFitAlg::HitLineFitData hlfd;
          if (trignum == 111)
            {
              hlfd.hitHoriz = hit.hitz;
              hlfd.hitVert = hit.hitx;
              hlfd.hitHorizErrLo = hit.hiterrzlo;
              hlfd.hitHorizErrHi = hit.hiterrzhi;
              hlfd.hitVertErrLo = hit.hiterrxlo;
              hlfd.hitVertErrHi = hit.hiterrxhi;
            }
          else if (trignum == 112 || trignum == 113)
            {
              hlfd.hitHoriz = hit.hitx;
              hlfd.hitVert = hit.hitz;
              hlfd.hitHorizErrLo = hit.hiterrxlo;
              hlfd.hitHorizErrHi = hit.hiterrxhi;
              hlfd.hitVertErrLo = hit.hiterrzlo;
              hlfd.hitVertErrHi = hit.hiterrzhi;
            }
          hlfd.hitREAL = false;
          fitdata.push_back(hlfd);
        }

      dune::HitLineFitAlg::HitLineFitResults fitresult;
      int retval = fFitAlg.FitLine(fitdata,fitresult);

      for (size_t i_h = 0; i_h < fitdata.size(); ++i_h)
        {
          hitVec[i_h].fitrealhit = fitdata[i_h].hitREAL;
        }

      if (fMakeupMissedHits && retval == 1) MakeupMissedHits(chanMap,hitVec);

      if (retval == 1 || retval == 0)
        {
          if (fitresult.fitsuccess)
            {
              hTracksByTrigger->Fill(triggercode);
              fGoodTree->Fill();
            }

          for (auto & hit : hitVec)
            {
              dune::ChannelInformation & chan = chanMap[hit.channelID];

              SetTreeVariables(chan,hit,fitresult);

              if (hit.fitrealhit && fitresult.fitsuccess)
                {
                  hcol.emplace_back(hit.artHit,chan.artWire,chan.artRawDigit);
                }
            }
        }
      if (fSimulation) SetTreeVariablesMCTruth(chanMap,e);
      if (fMakeTree) fTree->Fill();
    }
  hcol.put_into(e);
}

void dune::RobustHitFinder::reconfigure

(

fhicl::ParameterSet const &

p

)

Definition at line 665 of file RobustHitFinder_module.cc.

{
  fMakeTree = p.get<bool>("MakeTree");
  fHitGeomDistanceCut = p.get<float>("HitGeomDistanceCut");
  fCounterT0ModuleLabel = p.get<std::string>("CounterT0ModuleLabel");
  fWireModuleLabel = p.get<std::string>("WireModuleLabel");
  fEfield = p.get<std::vector<float> >("Efield");
  fSearchPreTicks = p.get<int>("SearchPreTicks",-1);
  fSearchPostTicks = p.get<int>("SearchPostTicks",-1);
  fMinPedMean = p.get<float>("MinPedMean");
  fMaxPedMean = p.get<float>("MaxPedMean");
  fMinPedRms = p.get<float>("MinPedRms");
  fMaxPedRms = p.get<float>("MaxPedRms");
  fMakeupMissedHits = p.get<bool>("MakeupMissedHits",true);
  fMissedBufferTicksLow = p.get<int>("MissedBufferTicksLow",0);
  fMissedBufferTicksHigh = p.get<int>("MissedBufferTicksHigh",0);
  fUseMeasuredCounterPositions = p.get<bool>("UseMeasuredCounterPositions");
  fPreHitTicks = p.get<int>("PreHitTicks",100);
  fPostHitTicks = p.get<int>("PostHitTicks",200);
  fConstantHitWidth = p.get<bool>("ConstantHitWidth",true);
  fSimulation = p.get<bool>("Simulation");
  fMCScale = p.get<float>("PreviousMCScale",1.0);
}

void dune::RobustHitFinder::Reset ( )

private

Definition at line 1327 of file RobustHitFinder_module.cc.

{
  run = -99999;
  subrun = -99999;
  event = -99999;
  t0 = -99999;
  c1 = 99999;
  c2 = 99999;
  trignum = 99999;
  c1x = -99999;
  c1y = -99999;
  c1z = -99999;
  c2x = -99999;
  c2y = -99999;
  c2z = -99999;
  channel.clear();
  tpc.clear();
  wire.clear();
  distancecut = -99999;
  signalsize.clear();
  signal.clear();
  signalFilter.clear();
  baseline.clear();
  rms.clear();
  baselineFilter.clear();
  rmsFilter.clear();
  pedmean.clear();
  pedrms.clear();
  integral.clear();
  integralFilter.clear();
  sumADC.clear();
  sigmaintegral.clear();
  sigmaintegralFilter.clear();
  amplitude.clear();
  amplitudeFilter.clear();
  peaktick.clear();
  peaktickFilter.clear();
  peaktime.clear();
  peaktimeFilter.clear();
  begintick.clear();
  endtick.clear();
  width.clear();
  hitx.clear();
  hity.clear();
  hitz.clear();
  hiterrxlo.clear();
  hiterrxhi.clear();
  hiterrylo.clear();
  hiterryhi.clear();
  hiterrzlo.clear();
  hiterrzhi.clear();
  perpdist.clear();
  hitt.clear();
  driftdist.clear();
  countercut.clear();
  fitconstant = -99999;
  fitconstanterr = -99999;
  fitlinear = -99999;
  fitlinearerr = -99999;
  fitquadratic = -99999;
  fitquadraticerr = -99999;
  fitchi2 = -99999;
  fitsumsqrresidual = -99999;
  fitndf = -99999;
  fitmle = -99999;
  fitsuccess = false;
  fitrealhit.clear();
  assumedhit.clear();
  segmentlength.clear();
  nwiresTPC0 = 0;
  nwiresTPC1 = 0;
  nwiresTPC2 = 0;
  nwiresTPC3 = 0;
  nwiresTPC4 = 0;
  nwiresTPC5 = 0;
  nwiresTPC6 = 0;
  nwiresTPC7 = 0;
  numGoodHitsChan.clear();
}

void dune::RobustHitFinder::SetTreeVariables ( const dune::ChannelInformation &  chan, const dune::HitInformation &  hit, const dune::HitLineFitAlg::HitLineFitResults &  fitresult  )

private

Definition at line 801 of file RobustHitFinder_module.cc.

{
  fitsuccess = fitresult.fitsuccess;
  TF1 * model = new TF1("model","pol2",fHorizRangeMin,fHorizRangeMax);
  if (fitsuccess)
    {
      fitconstant = fitresult.bestVal.at(0);
      fitconstanterr = fitresult.bestValError.at(0);
      fitlinear = fitresult.bestVal.at(1);
      fitlinearerr = fitresult.bestValError.at(1);
      fitquadratic = fitresult.bestVal.at(2);
      fitquadraticerr = fitresult.bestValError.at(2);
      fitchi2 = fitresult.chi2;
      fitsumsqrresidual = fitresult.sum2resid;
      fitmle = fitresult.mle;
      fitndf = fitresult.ndf;
      model->SetParameters(fitconstant,fitlinear,fitquadratic);
    }

  pedmean.push_back(temppedmean);
  pedrms.push_back(temppedrms);
  channel.push_back(chan.channelID);
  wire.push_back(chan.wireID);
  tpc.push_back(chan.tpcNum);
  signalsize.push_back(chan.signalSize);
  //signal = chan.signalVec;
  //signalFilter = chan.signalFilterVec;
  baseline.push_back(chan.baseline);
  rms.push_back(chan.rms);
  baselineFilter.push_back(chan.baselineFilter);
  rmsFilter.push_back(chan.rmsFilter);
  integral.push_back(hit.hitIntegral);
  integralFilter.push_back(hit.hitIntegralFilter);
  sumADC.push_back(hit.hitSumADC);
  sigmaintegral.push_back(hit.hitSigmaIntegral);
  sigmaintegralFilter.push_back(hit.hitSigmaIntegralFilter);
  amplitude.push_back(hit.hitAmplitude);
  amplitudeFilter.push_back(hit.hitAmplitudeFilter);
  peaktick.push_back(hit.hitPeakTick);
  peaktickFilter.push_back(hit.hitPeakTickFilter);
  peaktime.push_back(hit.hitPeakTime);
  peaktimeFilter.push_back(hit.hitPeakTimeFilter);
  begintick.push_back(hit.hitBeginTick);
  endtick.push_back(hit.hitEndTick);
  width.push_back(hit.hitWidth);
  hitx.push_back(hit.hitx);
  hity.push_back(hit.hity);
  hitz.push_back(hit.hitz);
  hiterrxlo.push_back(hit.hiterrxlo);
  hiterrxhi.push_back(hit.hiterrxhi);
  hiterrylo.push_back(hit.hiterrylo);
  hiterryhi.push_back(hit.hiterryhi);
  hiterrzlo.push_back(hit.hiterrzlo);
  hiterrzhi.push_back(hit.hiterrzhi);
  perpdist.push_back(hit.perpdist);
  hitt.push_back(hit.hitt);
  driftdist.push_back(hit.driftdist);
  countercut.push_back(hit.countercut);
  fitrealhit.push_back(hit.fitrealhit);
  assumedhit.push_back(hit.assumedhit);
  numGoodHitsChan.push_back(chan.nGoodHits);
  ismctruth.push_back(false);

  float tempsegmentlength = 0.449;
  if (fitsuccess && hit.fitrealhit)
    {
      if (trignum == 111)
        {
          double thetayz = TMath::ATan2(model->Eval(hit.hitz+1)-model->Eval(hit.hitz-1),2);
          double tan2thetayz = TMath::Power(TMath::Tan(thetayz),2);
          double y2z2 = ((c1y-c2y)*(c1y-c2y))/((c1z-c2z)*(c1z-c2z));
          double projL = sqrt(1+tan2thetayz+y2z2);
          tempsegmentlength *= static_cast<float>(projL);
        }
      else if (trignum == 112 || trignum == 113)
        {
          double thetayx = TMath::ATan2(2,model->Eval(hit.hitx+1)-model->Eval(hit.hitx-1));
          double tan2thetayx = TMath::Power(TMath::Tan(thetayx),2);
          double y2x2 = ((c1y-c2y)*(c1y-c2y))/((c1x-c2x)*(c1x-c2x));
          double projL = sqrt(1+tan2thetayx*(1+y2x2));
          tempsegmentlength *= static_cast<float>(projL);
        }
    }
  segmentlength.push_back(tempsegmentlength);
}

void dune::RobustHitFinder::SetTreeVariablesMCTruth ( const ChanMap_t &  chanMap, art::Event &  e  )

private

Definition at line 1014 of file RobustHitFinder_module.cc.

{
  std::vector<MCHit> MCHitVec;
  art::ServiceHandle<cheat::BackTrackerService> bt_serv;
  art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
  art::Handle< std::vector< recob::Wire> > wireHandle;
  if (!e.getByLabel(fWireModuleLabel,wireHandle)) return;
  const lariov::ChannelStatusProvider* fCSP = &art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();

  for (auto sc : bt_serv->SimChannels())
    {
      bool channelexists = false;
      for (size_t i_wire = 0; i_wire < wireHandle->size(); ++i_wire)
        {
          art::Ptr<recob::Wire> pwire(wireHandle,i_wire);
          if (pwire->Channel() == sc->Channel())
            {
              channelexists = true;
              break;
            }
        }
      if (!channelexists) continue;

      // also remove channels from absentChannels list if it has a Sim Hit
      if (fCSP->IsBad(sc->Channel())) continue;
      if (fGeom->SignalType(sc->Channel()) != geo::kCollection) continue;

      // Initialize a MCHit object for this channel
      dune::MCHit mchit;
      auto const& tdcidemap = sc->TDCIDEMap();
      // Loop over the track id and energies deposited on this channel
      for (auto const& tdcIt : tdcidemap)
        {
          // Get the vector of IDEs
          auto const& ideVec = tdcIt.second;

          // Get the TDC (time) of the deposit
          unsigned short tdc = tdcIt.first;

          // Loop over IDEs
          for (auto const& ideIt : ideVec)
            {
              // We want only primary muons which cross the detector.
              // Don't include deltas and other secondary particles because we want to
              // see how well the reconstruction discounts these other tracks
              if (abs(ideIt.trackID) != 1) continue;
              const simb::MCParticle * part = pi_serv->TrackIdToParticle_P(abs(ideIt.trackID));
              if (part->Mother() != 0) continue;

              // If the track is a primary muon, then collect this IDE for this channel
              mchit.idevec.push_back(ideIt);

              // Sanity check: make sure channel numbers match
              if (mchit.idevec.size() > 1 && mchit.channel != sc->Channel())
                throw cet::exception("RobustHitFinder") << "Channel IDs don't match!";

              // Check : if the IDE vector contains different particle codes, the something is weird
              mchit.channel = sc->Channel();
              if (mchit.idevec.size() > 1 && mchit.pdg != part->PdgCode())
                throw cet::exception("RobustHitFinder") << "Pdg from previous IDE (" << mchit.pdg << ") doesn't equal this IDE Pdg (" << part->PdgCode() << ")";

              // Fill the MCHit object, appending energy deposits in the case where more than one IDE exists on the channel
              // Usually, it's either one or two IDEs per channel with signal. Very rarely more than 2
              mchit.pdg = part->PdgCode();
              mchit.particlevec.push_back(part);
              mchit.tdcvec.push_back(tdc);
              // Here, adjust the signal size for the MCScale value used in the DataOverlay step
              // Otherwise, the charges wouldn't make any sense
              mchit.chargevec.push_back(ideIt.numElectrons*fMCScale);
            }
        }
      if (mchit.idevec.size()==0) continue;
      MCHitVec.push_back(mchit);
    }

  for (auto mchit : MCHitVec)
    {
      // Collect information about MCHit
      int mcchannel = mchit.channel;
      //int numIDEs = mchit.idevec.size();
      double meanSimTime = TMath::Mean(mchit.tdcvec.begin(),mchit.tdcvec.end(),mchit.chargevec.begin());   // charge weighted mean
      double sigmaSimTime = TMath::RMS(mchit.tdcvec.begin(),mchit.tdcvec.end(),mchit.chargevec.begin());   // charge weighted RMS
      double totalSimCharge = std::accumulate(mchit.chargevec.begin(),mchit.chargevec.end(),0);
      totalSimCharge *= 1.602e-4;   // convert # electrons to fC
      totalSimCharge *= 14.0*7.615;                   // convert fC to mV
      totalSimCharge *= 2.808; // convert to ADC

      pedmean.push_back(temppedmean);
      pedrms.push_back(temppedrms);
      channel.push_back(mcchannel); ///
      wire.push_back(chanMap.at(mcchannel).wireID);
      tpc.push_back(chanMap.at(mcchannel).tpcNum); ///
      //signalsize.push_back(chanMap.at(mcchannel).signalSize);
      //signal = chanMap.at(mcchannel).signalVec;
      //signalFilter = chanMap.at(mcchannel).signalFilterVec;
      baseline.push_back(chanMap.at(mcchannel).baseline); ///
      rms.push_back(chanMap.at(mcchannel).rms); ///
      baselineFilter.push_back(chanMap.at(mcchannel).baselineFilter);
      rmsFilter.push_back(chanMap.at(mcchannel).rmsFilter);
      integral.push_back(totalSimCharge); ///
      integralFilter.push_back(0);
      sumADC.push_back(0);
      sigmaintegral.push_back(0);
      sigmaintegralFilter.push_back(0);
      amplitude.push_back(0);
      amplitudeFilter.push_back(0);
      peaktick.push_back(0);
      peaktickFilter.push_back(0);
      peaktime.push_back(0);
      peaktimeFilter.push_back(0);
      begintick.push_back(0);
      endtick.push_back(0);
      width.push_back(sigmaSimTime); ///
      hitx.push_back(TimeToX(meanSimTime,chanMap.at(mcchannel).tpcNum));
      hity.push_back(0);
      hitz.push_back(chanMap.at(mcchannel).chanz);
      hiterrxlo.push_back(0);
      hiterrxhi.push_back(0);
      hiterrylo.push_back(0);
      hiterryhi.push_back(0);
      hiterrzlo.push_back(0);
      hiterrzhi.push_back(0);
      perpdist.push_back(0);
      hitt.push_back(meanSimTime); ///
      driftdist.push_back(0);
      countercut.push_back(0);
      fitrealhit.push_back(0);
      assumedhit.push_back(0);
      numGoodHitsChan.push_back(chanMap.at(mcchannel).nGoodHits);
      ismctruth.push_back(true);

      float tempsegmentlength = 0.449;
      if (trignum == 111)
        {
          double thetayz = TMath::ATan2(c1x-c2x,c1z-c2z);
          double tan2thetayz = TMath::Power(TMath::Tan(thetayz),2);
          double y2z2 = ((c1y-c2y)*(c1y-c2y))/((c1z-c2z)*(c1z-c2z));
          double projL = sqrt(1+tan2thetayz+y2z2);
          tempsegmentlength *= static_cast<float>(projL);
        }
      else if (trignum == 112 || trignum == 113)
        {
          double thetayx = TMath::ATan2(c1x-c2x,c1z-c2z);
          double tan2thetayx = TMath::Power(TMath::Tan(thetayx),2);
          double y2x2 = ((c1y-c2y)*(c1y-c2y))/((c1x-c2x)*(c1x-c2x));
          double projL = sqrt(1+tan2thetayx*(1+y2x2));
          tempsegmentlength *= static_cast<float>(projL);
        }
      segmentlength.push_back(tempsegmentlength); ///
    }
}

float dune::RobustHitFinder::TimeToDisplacement ( float  thistime )

private

Definition at line 1295 of file RobustHitFinder_module.cc.

{
  return thistime*fDetProp->DriftVelocity(fEfield[0]);
}

float dune::RobustHitFinder::TimeToDriftDist ( float  thistime, unsigned int  thistpc  )

private

Definition at line 1248 of file RobustHitFinder_module.cc.

{
  float vd = fDetProp->DriftVelocity(fEfield[0]);
  float v1 = fDetProp->DriftVelocity(fEfield[1]);
  float v2 = fDetProp->DriftVelocity(fEfield[2]);
  float v3 = fDetProp->DriftVelocity(fEfield[3]);

  float ld = -1, l1 = -1, l2 = -1, l3 = -1;

  try
    {
      if (thistpc == 1 || thistpc == 3 || thistpc == 5 || thistpc == 7)
        {
          ld = fGeom->TPC(thistpc).MaxX()-0.511;
          l1 = 0.511-fGeom->TPC(thistpc).PlaneLocation(0)[0];
          l2 = fGeom->TPC(thistpc).PlaneLocation(0)[0]-fGeom->TPC(thistpc).PlaneLocation(1)[0];
          l3 = fGeom->TPC(thistpc).PlaneLocation(1)[0]-fGeom->TPC(thistpc).PlaneLocation(2)[0];
        }
      else if (thistpc == 0 || thistpc == 2 || thistpc == 4 || thistpc == 6)
        {
          ld = -8.490-fGeom->TPC(thistpc).MinX();
          l1 = fGeom->TPC(thistpc).PlaneLocation(0)[0]+8.490;
          l2 = fGeom->TPC(thistpc).PlaneLocation(1)[0]-fGeom->TPC(thistpc).PlaneLocation(0)[0];
          l3 = fGeom->TPC(thistpc).PlaneLocation(2)[0]-fGeom->TPC(thistpc).PlaneLocation(1)[0];
        }
    }
  catch (cet::exception &e)
    {
      mf::LogError("RobustHitFinder") << e;
      return -99999;
    }

  if (ld < 0 || l1 < 0 || l2 < 0 || l3 < 0) return -99998;

  float t3max = l3/v3;
  float t2max = t3max+(l2/v2);
  float t1max = t2max+(l1/v1);
  float tdmax = t1max+(ld/vd);

  if      (0     <= thistime && thistime < t3max) return v3*thistime;
  else if (t3max <= thistime && thistime < t2max) return l3+v2*(thistime-t3max);
  else if (t2max <= thistime && thistime < t1max) return l3+l2+v1*(thistime-t2max);
  else if (t1max <= thistime && thistime < tdmax) return l3+l2+l1+vd*(thistime-t1max);

  return -99997;
}

float dune::RobustHitFinder::TimeToX ( float  thistime, unsigned int  thistpc  )

private

Definition at line 1300 of file RobustHitFinder_module.cc.

{
  float driftdistance = TimeToDriftDist(thistime,thistpc);
  if (driftdistance < -89999) return driftdistance;
  try
    {
      if (thistpc == 1 || thistpc == 3 || thistpc == 5 || thistpc == 7)
        {
          return (fGeom->TPC(thistpc).PlaneLocation(2)[0]+driftdistance);
        }
      else if (thistpc == 0 || thistpc == 2 || thistpc == 4 || thistpc == 6)
        {
          return (fGeom->TPC(thistpc).PlaneLocation(2)[0]-driftdistance);
        }
    }
  catch (cet::exception &e)
    {
      mf::LogError("RobustHitFinder") << e;
    }
  return -99995;
}

bool dune::RobustHitFinder::ValidTrigger ( std::vector< unsigned int >  evtTriggers, unsigned int &  c1arg, unsigned int &  c2arg, unsigned int &  trignumarg  )

private

Definition at line 1166 of file RobustHitFinder_module.cc.

{
  c1arg=999; c2arg=999;
  int contains_111 = 0, contains_112 = 0, contains_113 = 0;
  int contains_Ntrigs = 0, contains_NU = 0, contains_NL = 0, contains_SU = 0, contains_SL = 0;
  int contains_EL = 0, contains_WU = 0, contains_TEL = 0;
  for (size_t i_c = 0; i_c < evtTriggers.size(); i_c++)
    {
      unsigned int trigID = evtTriggers[i_c];
      // for c2: trigID is an unsigned int and always >= 0
      //if (trigID >= 0 && trigID <= 5) contains_SL++;
      if (trigID <= 5) contains_SL++;
      if (trigID >= 6 && trigID <= 15) contains_EL++;
      if (trigID >= 16 && trigID <= 21) contains_NL++;
      if (trigID >= 22 && trigID <= 27) contains_NU++;
      if (trigID >= 28 && trigID <= 37) contains_WU++;
      if (trigID >= 38 && trigID <= 43) contains_SU++;
      if (trigID >= 44 && trigID <= 92) contains_TEL++;
      if (trigID == 111) contains_111++;
      if (trigID == 112) contains_112++;
      if (trigID == 113) contains_113++;
      contains_Ntrigs++;
    }
  if (contains_111 + contains_112 + contains_113 != 1) return false;        // too many/few coincidences!
  if (contains_TEL &&
      (contains_NU || contains_NL || contains_SU || contains_SL || contains_EL || contains_WU)) return false;        // track probably doesn't go through detector
  if (contains_Ntrigs != 3) return false;        // too much/little going on!
  if (contains_111 && (contains_NU || contains_NL || contains_SU || contains_SL)) return false;        // 111 should not have NU/NL/SU/SL
  if (contains_112 && (contains_EL || contains_WU || contains_SU || contains_NL)) return false;        // 112 should not have EL/WU/SU/NL
  if (contains_113 && (contains_EL || contains_WU || contains_NU || contains_SL)) return false;        // 113 should not have EL/WU/NU/SL
  if (contains_111 && (!contains_EL || !contains_WU)) return false;        // incomplete trigger
  if (contains_112 && (!contains_NU || !contains_SL)) return false;        // incomplete trigger
  if (contains_113 && (!contains_SU || !contains_NL)) return false;        // incomplete trigger

  std::vector<unsigned int> counterIDs;
  trignumarg = 0;
  for (size_t i_c = 0; i_c < evtTriggers.size(); i_c++)
    {
      unsigned int trigID = evtTriggers[i_c];
      if (trigID >= 44 && trigID <= 100) continue;
      if (trigID >= 111 && trigID <= 113)
        {
          trignumarg = trigID;
          continue;
        }
      counterIDs.push_back(trigID);
    }
  if (counterIDs.size() != 2) return false;
  if (trignumarg == 0) return false;

  if (trignumarg == 112 || trignumarg == 113)
    {
      if (fCounterPositionMap[counterIDs[0]].first.X() > fCounterPositionMap[counterIDs[1]].first.X())
        {
          c1arg = counterIDs[0];
          c2arg = counterIDs[1];
        }
      else
        {
          c1arg = counterIDs[1];
          c2arg = counterIDs[0];
        }
    }
  else if (trignumarg == 111)
    {
      if (fCounterPositionMap[counterIDs[0]].first.Z() > fCounterPositionMap[counterIDs[1]].first.Z())
        {
          c1arg = counterIDs[0];
          c2arg = counterIDs[1];
        }
      else
        {
          c1arg = counterIDs[1];
          c2arg = counterIDs[0];
        }
    }
  if (c1arg == c2arg) return false;
  if (c1arg == 999 || c2arg == 999) return false;

  return true;
}

Member Data Documentation

std::vector<int> dune::RobustHitFinder::allchannels

private

Definition at line 160 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::amplitude

private

Definition at line 178 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::amplitudeFilter

private

Definition at line 179 of file RobustHitFinder_module.cc.

std::vector<bool> dune::RobustHitFinder::assumedhit

private

Definition at line 213 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::baseline

private

Definition at line 167 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::baselineFilter

private

Definition at line 169 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::begintick

private

Definition at line 184 of file RobustHitFinder_module.cc.

unsigned int dune::RobustHitFinder::c1

private

Definition at line 150 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c1x

private

Definition at line 153 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c1y

private

Definition at line 154 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c1z

private

Definition at line 155 of file RobustHitFinder_module.cc.

unsigned int dune::RobustHitFinder::c2

private

Definition at line 151 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c2x

private

Definition at line 156 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c2y

private

Definition at line 157 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::c2z

private

Definition at line 158 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::channel

private

Definition at line 161 of file RobustHitFinder_module.cc.

std::vector<bool> dune::RobustHitFinder::countercut

private

Definition at line 199 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::distancecut

private

Definition at line 159 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::driftdist

private

Definition at line 198 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::endtick

private

Definition at line 185 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::event

private

Definition at line 148 of file RobustHitFinder_module.cc.

TTree* dune::RobustHitFinder::fAllTree

private

Definition at line 129 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fC1Horiz

private

Definition at line 251 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fC1Vert

private

Definition at line 250 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fC2Horiz

private

Definition at line 253 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fC2Vert

private

Definition at line 252 of file RobustHitFinder_module.cc.

detinfo::DetectorClocks const* dune::RobustHitFinder::fClks

private

Definition at line 262 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fConstantHitWidth

private

Definition at line 240 of file RobustHitFinder_module.cc.

std::map<unsigned int, std::pair<TVector3, std::vector<TVector3> > > dune::RobustHitFinder::fCounterPositionMap

private

Definition at line 255 of file RobustHitFinder_module.cc.

std::string dune::RobustHitFinder::fCounterT0ModuleLabel

private

Definition at line 228 of file RobustHitFinder_module.cc.

detinfo::DetectorProperties const* dune::RobustHitFinder::fDetProp

private

Definition at line 263 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::fEfield

private

Definition at line 229 of file RobustHitFinder_module.cc.

CLHEP::HepRandomEngine& dune::RobustHitFinder::fEngine

private

Definition at line 270 of file RobustHitFinder_module.cc.

dune::HitLineFitAlg dune::RobustHitFinder::fFitAlg

private

Definition at line 257 of file RobustHitFinder_module.cc.

art::ServiceHandle<geo::Geometry> dune::RobustHitFinder::fGeom

private

Definition at line 260 of file RobustHitFinder_module.cc.

TTree* dune::RobustHitFinder::fGoodTree

private

Definition at line 137 of file RobustHitFinder_module.cc.

dune::RMSHitFinderAlg dune::RobustHitFinder::fHitFinderAlg

private

Definition at line 258 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fHitGeomDistanceCut

private

Definition at line 226 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fHorizRangeMax

private

Definition at line 247 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fHorizRangeMin

private

Definition at line 246 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitchi2

private

Definition at line 206 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitconstant

private

Definition at line 200 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitconstanterr

private

Definition at line 201 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitlinear

private

Definition at line 202 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitlinearerr

private

Definition at line 203 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitmle

private

Definition at line 209 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitndf

private

Definition at line 208 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitquadratic

private

Definition at line 204 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitquadraticerr

private

Definition at line 205 of file RobustHitFinder_module.cc.

std::vector<bool> dune::RobustHitFinder::fitrealhit

private

Definition at line 211 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fitsuccess

private

Definition at line 210 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fitsumsqrresidual

private

Definition at line 207 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fMakeTree

private

Definition at line 225 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fMakeupMissedHits

private

Definition at line 232 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fMaxPedMean

private

Definition at line 236 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fMaxPedRms

private

Definition at line 238 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fMCScale

private

Definition at line 244 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fMinPedMean

private

Definition at line 235 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fMinPedRms

private

Definition at line 237 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fMissedBufferTicksHigh

private

Definition at line 234 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fMissedBufferTicksLow

private

Definition at line 233 of file RobustHitFinder_module.cc.

const lariov::DetPedestalProvider& dune::RobustHitFinder::fPedestalRetrievalAlg = *(lar::providerFrom<lariov::DetPedestalService>())

private

Definition at line 264 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fPostHitTicks

private

Definition at line 242 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fPreHitTicks

private

Definition at line 241 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fSearchPostTicks

private

Definition at line 231 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::fSearchPreTicks

private

Definition at line 230 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fSimulation

private

Definition at line 243 of file RobustHitFinder_module.cc.

art::ServiceHandle<art::TFileService> dune::RobustHitFinder::fTfs

private

Definition at line 261 of file RobustHitFinder_module.cc.

TTree* dune::RobustHitFinder::fTree

private

Definition at line 145 of file RobustHitFinder_module.cc.

bool dune::RobustHitFinder::fUseMeasuredCounterPositions

private

Definition at line 239 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fVertRangeMax

private

Definition at line 249 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::fVertRangeMin

private

Definition at line 248 of file RobustHitFinder_module.cc.

std::string dune::RobustHitFinder::fWireModuleLabel

private

Definition at line 227 of file RobustHitFinder_module.cc.

TH1I* dune::RobustHitFinder::hEventsByTrigger

private

Definition at line 126 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterrxhi

private

Definition at line 191 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterrxlo

private

Definition at line 190 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterryhi

private

Definition at line 193 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterrylo

private

Definition at line 192 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterrzhi

private

Definition at line 195 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hiterrzlo

private

Definition at line 194 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hitt

private

Definition at line 197 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hitx

private

Definition at line 187 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hity

private

Definition at line 188 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::hitz

private

Definition at line 189 of file RobustHitFinder_module.cc.

TH1I* dune::RobustHitFinder::hTracksByTrigger

private

Definition at line 127 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::integral

private

Definition at line 173 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::integralFilter

private

Definition at line 174 of file RobustHitFinder_module.cc.

std::vector<bool> dune::RobustHitFinder::ismctruth

private

Definition at line 215 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::numGoodHitsChan

private

Definition at line 214 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC0

private

Definition at line 216 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC1

private

Definition at line 217 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC2

private

Definition at line 218 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC3

private

Definition at line 219 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC4

private

Definition at line 220 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC5

private

Definition at line 221 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC6

private

Definition at line 222 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::nwiresTPC7

private

Definition at line 223 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::peaktick

private

Definition at line 180 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::peaktickFilter

private

Definition at line 181 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::peaktime

private

Definition at line 182 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::peaktimeFilter

private

Definition at line 183 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::pedmean

private

Definition at line 171 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::pedrms

private

Definition at line 172 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::perpdist

private

Definition at line 196 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::rms

private

Definition at line 168 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::rmsFilter

private

Definition at line 170 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::run

private

Definition at line 146 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::segmentlength

private

Definition at line 212 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::sigmaintegral

private

Definition at line 176 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::sigmaintegralFilter

private

Definition at line 177 of file RobustHitFinder_module.cc.

std::vector<std::vector<float> > dune::RobustHitFinder::signal

private

Definition at line 165 of file RobustHitFinder_module.cc.

std::vector<std::vector<float> > dune::RobustHitFinder::signalFilter

private

Definition at line 166 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::signalsize

private

Definition at line 164 of file RobustHitFinder_module.cc.

int dune::RobustHitFinder::subrun

private

Definition at line 147 of file RobustHitFinder_module.cc.

std::vector<float> dune::RobustHitFinder::sumADC

private

Definition at line 175 of file RobustHitFinder_module.cc.

double dune::RobustHitFinder::t0

private

Definition at line 149 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::temppedmean

private

Definition at line 267 of file RobustHitFinder_module.cc.

float dune::RobustHitFinder::temppedrms

private

Definition at line 268 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::tpc

private

Definition at line 163 of file RobustHitFinder_module.cc.

unsigned int dune::RobustHitFinder::trignum

private

Definition at line 152 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::width

private

Definition at line 186 of file RobustHitFinder_module.cc.

std::vector<int> dune::RobustHitFinder::wire

private

Definition at line 162 of file RobustHitFinder_module.cc.

---

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

• dunetpc/dune/HitFinderDUNE/RobustHitFinder_module.cc