Inheritance diagram for hit::GausHitFinder:

Public Types
using	ModuleType = SharedProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	GausHitFinder (fhicl::ParameterSet const &pset, art::ProcessingFrame const &)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

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)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

hep::concurrency::SerialTaskQueueChain *	serialTaskQueueChain () const

std::set< std::string > const &	sharedResources () const

void	createQueues (SharedResources const &resources)

template<BranchType , typename... T>
void	serialize (T const &...resources)

template<BranchType , typename... T>
void	serializeExternal (T const &...resources)

Protected Member Functions
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 ()

template<BranchType BT = InEvent, typename... T>
void	serialize (T const &...)

template<BranchType BT = InEvent, typename... T>
void	serializeExternal (T const &...)

template<BranchType BT = InEvent>
void	async ()

Private Member Functions
void	produce (art::Event &evt, art::ProcessingFrame const &) override

void	beginJob (art::ProcessingFrame const &) override

std::vector< double >	FillOutHitParameterVector (const std::vector< double > &input)

Private Attributes
const bool	fFilterHits

const bool	fFillHists

const std::string	fCalDataModuleLabel

const std::string	fAllHitsInstanceName

const std::vector< int >	fLongMaxHitsVec
	Maximum number hits on a really long pulse train. More...

const std::vector< int >	fLongPulseWidthVec
	Sets width of hits used to describe long pulses. More...

const size_t	fMaxMultiHit
	maximum hits for multi fit More...

const int	fAreaMethod
	Type of area calculation. More...

const std::vector< double >	fAreaNormsVec
	factors for converting area to same units as peak height More...

const double	fChi2NDF

const std::vector< float >	fPulseHeightCuts
	maximum Chisquared / NDF allowed for a hit to be saved More...

const std::vector< float >	fPulseWidthCuts

const std::vector< float >	fPulseRatioCuts

std::atomic< size_t >	fEventCount {0}

std::vector< std::unique_ptr< reco_tool::ICandidateHitFinder > >	fHitFinderToolVec
	For finding candidate hits. More...

std::unique_ptr< reco_tool::IPeakFitter >	fPeakFitterTool
	Perform fit to candidate peaks. More...

std::unique_ptr< HitFilterAlg >	fHitFilterAlg
	algorithm used to filter out noise hits More...

TH1F *	fFirstChi2

TH1F *	fChi2

Detailed Description

Definition at line 62 of file GausHitFinder_module.cc.

Member Typedef Documentation

using art::SharedProducer::ModuleType = SharedProducer

inherited

Definition at line 20 of file SharedProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

hit::GausHitFinder::GausHitFinder	(	fhicl::ParameterSet const &	pset,
		art::ProcessingFrame const &
	)

explicit

Definition at line 109 of file GausHitFinder_module.cc.

References art::errors::Configuration, recob::HitAndAssociationsWriterBase::declare_products(), fAllHitsInstanceName, fAreaMethod, fAreaNormsVec, fCalDataModuleLabel, fChi2NDF, fFillHists, fFilterHits, fHitFilterAlg, fHitFinderToolVec, FillOutHitParameterVector(), fLongMaxHitsVec, fLongPulseWidthVec, fMaxMultiHit, fPeakFitterTool, fPulseHeightCuts, fPulseRatioCuts, fPulseWidthCuts, fhicl::ParameterSet::get(), fhicl::ParameterSet::get_pset_names(), art::Globals::instance(), and art::ProductRegistryHelper::producesCollector().

     : SharedProducer{pset}
     , fFilterHits(pset.get<bool>("FilterHits", false))
     , fFillHists(pset.get<bool>("FillHists", false))
     , fCalDataModuleLabel(pset.get<std::string>("CalDataModuleLabel"))
     , fAllHitsInstanceName(pset.get<std::string>("AllHitsInstanceName", ""))
     , fLongMaxHitsVec(pset.get<std::vector<int>>("LongMaxHits", std::vector<int>() = {25, 25, 25}))
     , fLongPulseWidthVec(
         pset.get<std::vector<int>>("LongPulseWidth", std::vector<int>() = {16, 16, 16}))
     , fMaxMultiHit(pset.get<int>("MaxMultiHit"))
     , fAreaMethod(pset.get<int>("AreaMethod"))
     , fAreaNormsVec(FillOutHitParameterVector(pset.get<std::vector<double>>("AreaNorms")))
     , fChi2NDF(pset.get<double>("Chi2NDF"))
     , fPulseHeightCuts(
         pset.get<std::vector<float>>("PulseHeightCuts", std::vector<float>() = {3.0, 3.0, 3.0}))
     , fPulseWidthCuts(
         pset.get<std::vector<float>>("PulseWidthCuts", std::vector<float>() = {2.0, 1.5, 1.0}))
     , fPulseRatioCuts(
         pset.get<std::vector<float>>("PulseRatioCuts", std::vector<float>() = {0.35, 0.40, 0.20}))
   {
     if (fFillHists && art::Globals::instance()->nthreads() > 1u) {
       throw art::Exception(art::errors::Configuration)
         << "Cannot fill histograms when multiple threads configured, please set fFillHists to "
            "false or change number of threads to 1\n";
     }
     async<art::InEvent>();
     if (fFilterHits) {
       fHitFilterAlg = std::make_unique<HitFilterAlg>(pset.get<fhicl::ParameterSet>("HitFilterAlg"));
     }
 
     // recover the tool to do the candidate hit finding
     // Recover the vector of fhicl parameters for the ROI tools
     const fhicl::ParameterSet& hitFinderTools = pset.get<fhicl::ParameterSet>("HitFinderToolVec");
 
     fHitFinderToolVec.resize(hitFinderTools.get_pset_names().size());
 
     for (const std::string& hitFinderTool : hitFinderTools.get_pset_names()) {
       const fhicl::ParameterSet& hitFinderToolParamSet =
         hitFinderTools.get<fhicl::ParameterSet>(hitFinderTool);
       size_t planeIdx = hitFinderToolParamSet.get<size_t>("Plane");
 
       fHitFinderToolVec.at(planeIdx) =
         art::make_tool<reco_tool::ICandidateHitFinder>(hitFinderToolParamSet);
     }
 
     // Recover the peak fitting tool
     fPeakFitterTool =
       art::make_tool<reco_tool::IPeakFitter>(pset.get<fhicl::ParameterSet>("PeakFitter"));
 
     // let HitCollectionCreator declare that we are going to produce
     // hits and associations with wires and raw digits
     // We want the option to output two hit collections, one filtered
     // and one with all hits. The key to doing this will be a non-null
     // instance name for the second collection
     // (with no particular product label)
     recob::HitCollectionCreator::declare_products(
       producesCollector(), fAllHitsInstanceName, true, false); //fMakeRawDigitAssns);
 
     // and now the filtered hits...
     if (fAllHitsInstanceName != "")
       recob::HitCollectionCreator::declare_products(
         producesCollector(), "", true, false); //fMakeRawDigitAssns);
 
     return;
   } // GausHitFinder::GausHitFinder()

Member Function Documentation

template<BranchType BT = InEvent>

void art::detail::SharedModule::async ( )

inlineprotectedinherited

Definition at line 38 of file SharedModule.h.

References art::detail::SharedModule::asyncDeclared_, art::detail::SharedModule::implicit_serialize(), art::InEvent, and art::detail::SharedModule::serialize_for().

     {
       static_assert(
         BT == InEvent,
         "async is currently supported only for the 'InEvent' level.");
       asyncDeclared_ = true;
     }

void hit::GausHitFinder::beginJob ( art::ProcessingFrame const & )

overrideprivatevirtual

Reimplemented from art::SharedProducer.

Definition at line 199 of file GausHitFinder_module.cc.

References fChi2, fFillHists, and fFirstChi2.

   {
     // get access to the TFile service
     art::ServiceHandle<art::TFileService const> tfs;
 
     // ======================================
     // === Hit Information for Histograms ===
     if (fFillHists) {
       fFirstChi2 = tfs->make<TH1F>("fFirstChi2", "#chi^{2}", 10000, 0, 5000);
       fChi2 = tfs->make<TH1F>("fChi2", "#chi^{2}", 10000, 0, 5000);
     }
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void art::detail::SharedModule::createQueues ( SharedResources const & resources )

inherited

Definition at line 34 of file SharedModule.cc.

References art::detail::SharedModule::asyncDeclared_, util::cbegin(), util::cend(), art::detail::SharedModule::chain_, art::detail::SharedResources::createQueues(), e, util::empty(), art::errors::LogicError, and art::detail::SharedModule::resourceNames_.

Referenced by art::OutputModule::doBeginJob(), art::SharedFilter::setupQueues(), art::SharedProducer::setupQueues(), art::SharedAnalyzer::setupQueues(), art::EDFilter::setupQueues(), art::EDProducer::setupQueues(), and art::EDAnalyzer::setupQueues().

   {
     Exception e{errors::LogicError,
                 "An error occurred while processing scheduling options for a "
                 "module.\n"};
     if (asyncDeclared_) {
       if (empty(resourceNames_)) {
         return;
       }
       throw e
         << "async<art::InEvent>() cannot be called in combination with any "
            "serialize<art::InEvent>(...) calls.\n";
     }
 
     if (empty(resourceNames_)) {
       throw e << "Either 'async<art::InEvent>()' or "
                  "'serialize<art::InEvent>(...)'\n"
                  "must be called in a shared module's constructor.\n";
     }
     std::vector<std::string> const names(cbegin(resourceNames_),
                                          cend(resourceNames_));
     auto queues = resources.createQueues(names);
     chain_ = std::make_unique<SerialTaskQueueChain>(queues);
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::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
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

std::vector< double > hit::GausHitFinder::FillOutHitParameterVector ( const std::vector< double > & input )

private

Definition at line 177 of file GausHitFinder_module.cc.

References geo::GeometryCore::Nplanes().

Referenced by GausHitFinder().

   {
     if (input.size() == 0)
       throw std::runtime_error(
         "GausHitFinder::FillOutHitParameterVector ERROR! Input config vector has zero size.");
 
     std::vector<double> output;
     art::ServiceHandle<geo::Geometry const> geom;
     const unsigned int N_PLANES = geom->Nplanes();
 
     if (input.size() == 1)
       output.resize(N_PLANES, input[0]);
     else if (input.size() == N_PLANES)
       output = input;
     else
       throw std::runtime_error("GausHitFinder::FillOutHitParameterVector ERROR! Input config "
                                "vector size !=1 and !=N_PLANES.");
     return output;
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

void hit::GausHitFinder::produce	(	art::Event &	evt,
		art::ProcessingFrame const &
	)

overrideprivatevirtual

Implements art::SharedProducer.

Definition at line 216 of file GausHitFinder_module.cc.

References recob::Wire::Channel(), geo::GeometryCore::ChannelToWire(), recob::HitCreator::copy(), DEFINE_ART_MODULE, recob::HitCollectionCreator::emplace_back(), fAllHitsInstanceName, fAreaMethod, fAreaNormsVec, fCalDataModuleLabel, fChi2, fChi2NDF, fEventCount, fFillHists, fFilterHits, fFirstChi2, fHitFilterAlg, fHitFinderToolVec, fLongMaxHitsVec, fLongPulseWidthVec, fMaxMultiHit, fPeakFitterTool, fPulseHeightCuts, fPulseRatioCuts, fPulseWidthCuts, art::ProductRetriever::getByLabel(), art::left(), recob::HitCreator::move(), lar::sparse_vector< T >::n_ranges(), reco_tool::IPeakFitter::PeakFitParams_t::peakAmplitude, reco_tool::IPeakFitter::PeakFitParams_t::peakAmplitudeError, reco_tool::IPeakFitter::PeakFitParams_t::peakCenter, reco_tool::IPeakFitter::PeakFitParams_t::peakCenterError, reco_tool::IPeakFitter::PeakFitParams_t::peakSigma, reco_tool::IPeakFitter::PeakFitParams_t::peakSigmaError, geo::PlaneID::Plane, recob::HitCollectionCreator::put_into(), lar::sparse_vector< T >::range(), art::right(), recob::Wire::SignalROI(), and tmp.

   {
     unsigned int count = fEventCount.fetch_add(1);
     //==================================================================================================
 
     TH1::AddDirectory(kFALSE);
 
     // Instantiate and Reset a stop watch
     //TStopwatch StopWatch;
     //StopWatch.Reset();
 
     // ################################
     // ### Calling Geometry service ###
     // ################################
     art::ServiceHandle<geo::Geometry const> geom;
 
     // ###############################################
     // ### Making a ptr vector to put on the event ###
     // ###############################################
     // this contains the hit collection
     // and its associations to wires and raw digits
     recob::HitCollectionCreator allHitCol(evt, fAllHitsInstanceName, true, false);
 
     // Handle the filtered hits collection...
     recob::HitCollectionCreator hcol(evt, "", true, false);
     recob::HitCollectionCreator* filteredHitCol = 0;
 
     if (fFilterHits) filteredHitCol = &hcol;
 
     //store in a thread safe way
     struct hitstruct {
       recob::Hit hit_tbb;
       art::Ptr<recob::Wire> wire_tbb;
     };
 
     tbb::concurrent_vector<hitstruct> hitstruct_vec;
     tbb::concurrent_vector<hitstruct> filthitstruct_vec;
 
     //    if (fAllHitsInstanceName != "") filteredHitCol = &hcol;
 
     // ##########################################
     // ### Reading in the Wire List object(s) ###
     // ##########################################
     art::Handle<std::vector<recob::Wire>> wireVecHandle;
     evt.getByLabel(fCalDataModuleLabel, wireVecHandle);
 
     //#################################################
     //###    Set the charge determination method    ###
     //### Default is to compute the normalized area ###
     //#################################################
     std::function<double(double, double, double, double, int, int)> chargeFunc =
       [](double /* peakMean */,
          double peakAmp,
          double peakWidth,
          double areaNorm,
          int /* low */,
          int /* hi */) { return std::sqrt(2 * TMath::Pi()) * peakAmp * peakWidth / areaNorm; };
 
     //##############################################
     //### Alternative is to integrate over pulse ###
     //##############################################
     if (fAreaMethod == 0)
       chargeFunc = [](double peakMean,
                       double peakAmp,
                       double peakWidth,
                       double /* areaNorm */,
                       int low,
                       int hi) {
         double charge(0);
         for (int sigPos = low; sigPos < hi; sigPos++)
           charge += peakAmp * TMath::Gaus(sigPos, peakMean, peakWidth);
         return charge;
       };
 
     //##############################
     //### Looping over the wires ###
     //##############################
     //for(size_t wireIter = 0; wireIter < wireVecHandle->size(); wireIter++)
     //{
     tbb::parallel_for(
       static_cast<std::size_t>(0),
       wireVecHandle->size(),
       [&](size_t& wireIter) {
         // ####################################
         // ### Getting this particular wire ###
         // ####################################
         art::Ptr<recob::Wire> wire(wireVecHandle, wireIter);
 
         // --- Setting Channel Number and Signal type ---
 
         raw::ChannelID_t channel = wire->Channel();
 
         // get the WireID for this hit
         std::vector<geo::WireID> wids = geom->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;
 
         // ----------------------------------------------------------
         // -- Setting the appropriate signal widths and thresholds --
         // --    for the right plane.      --
         // ----------------------------------------------------------
 
         // #################################################
         // ### Set up to loop over ROI's for this wire   ###
         // #################################################
         const recob::Wire::RegionsOfInterest_t& signalROI = wire->SignalROI();
 
         // for (const auto& range : signalROI.get_ranges()) {
         tbb::parallel_for(
           static_cast<std::size_t>(0),
           signalROI.n_ranges(),
           [&](size_t& rangeIter) {
             const auto& range = signalROI.range(rangeIter);
             // ROI start time
             raw::TDCtick_t roiFirstBinTick = range.begin_index();
 
             // ###########################################################
             // ### Scan the waveform and find candidate peaks + merge  ###
             // ###########################################################
 
             reco_tool::ICandidateHitFinder::HitCandidateVec hitCandidateVec;
             reco_tool::ICandidateHitFinder::MergeHitCandidateVec mergedCandidateHitVec;
 
             fHitFinderToolVec.at(plane)->findHitCandidates(
               range, 0, channel, count, hitCandidateVec);
             fHitFinderToolVec.at(plane)->MergeHitCandidates(
               range, hitCandidateVec, mergedCandidateHitVec);
 
             // #######################################################
             // ### Lets loop over the pulses we found on this wire ###
             // #######################################################
 
             for (auto& mergedCands : mergedCandidateHitVec) {
               int startT = mergedCands.front().startTick;
               int endT = mergedCands.back().stopTick;
 
               // ### Putting in a protection in case things went wrong ###
               // ### In the end, this primarily catches the case where ###
               // ### a fake pulse is at the start of the ROI           ###
               if (endT - startT < 5) continue;
 
               // #######################################################
               // ### Clearing the parameter vector for the new pulse ###
               // #######################################################
 
               // === Setting the number of Gaussians to try ===
               int nGausForFit = mergedCands.size();
 
               // ##################################################
               // ### Calling the function for fitting Gaussians ###
               // ##################################################
               double chi2PerNDF(0.);
               int NDF(1);
               /*stand alone
                 reco_tool::IPeakFitter::PeakParamsVec peakParamsVec(nGausForFit);
                 */
               reco_tool::IPeakFitter::PeakParamsVec peakParamsVec;
 
               // #######################################################
               // ### If # requested Gaussians is too large then punt ###
               // #######################################################
               if (mergedCands.size() <= fMaxMultiHit) {
                 fPeakFitterTool->findPeakParameters(
                   range.data(), mergedCands, peakParamsVec, chi2PerNDF, NDF);
 
                 // If the chi2 is infinite then there is a real problem so we bail
                 if (!(chi2PerNDF < std::numeric_limits<double>::infinity())) {
                   chi2PerNDF = 2. * fChi2NDF;
                   NDF = 2;
                 }
 
                 if (fFillHists) fFirstChi2->Fill(chi2PerNDF);
               }
 
               // #######################################################
               // ### If too large then force alternate solution      ###
               // ### - Make n hits from pulse train where n will     ###
               // ###   depend on the fhicl parameter fLongPulseWidth ###
               // ### Also do this if chi^2 is too large              ###
               // #######################################################
               if (mergedCands.size() > fMaxMultiHit || nGausForFit * chi2PerNDF > fChi2NDF) {
                 int longPulseWidth = fLongPulseWidthVec.at(plane);
                 int nHitsThisPulse = (endT - startT) / longPulseWidth;
 
                 if (nHitsThisPulse > fLongMaxHitsVec.at(plane)) {
                   nHitsThisPulse = fLongMaxHitsVec.at(plane);
                   longPulseWidth = (endT - startT) / nHitsThisPulse;
                 }
 
                 if (nHitsThisPulse * longPulseWidth < endT - startT) nHitsThisPulse++;
 
                 int firstTick = startT;
                 int lastTick = std::min(firstTick + longPulseWidth, endT);
 
                 peakParamsVec.clear();
                 nGausForFit = nHitsThisPulse;
                 NDF = 1.;
                 chi2PerNDF = chi2PerNDF > fChi2NDF ? chi2PerNDF : -1.;
 
                 for (int hitIdx = 0; hitIdx < nHitsThisPulse; hitIdx++) {
                   // This hit parameters
                   double sumADC =
                     std::accumulate(range.begin() + firstTick, range.begin() + lastTick, 0.);
                   double peakSigma = (lastTick - firstTick) / 3.; // Set the width...
                   double peakAmp = 0.3989 * sumADC / peakSigma;   // Use gaussian formulation
                   double peakMean = (firstTick + lastTick) / 2.;
 
                   // Store hit params
                   reco_tool::IPeakFitter::PeakFitParams_t peakParams;
 
                   peakParams.peakCenter = peakMean;
                   peakParams.peakCenterError = 0.1 * peakMean;
                   peakParams.peakSigma = peakSigma;
                   peakParams.peakSigmaError = 0.1 * peakSigma;
                   peakParams.peakAmplitude = peakAmp;
                   peakParams.peakAmplitudeError = 0.1 * peakAmp;
 
                   peakParamsVec.push_back(peakParams);
 
                   // set for next loop
                   firstTick = lastTick;
                   lastTick = std::min(lastTick + longPulseWidth, endT);
                 }
               }
 
               // #######################################################
               // ### Loop through returned peaks and make recob hits ###
               // #######################################################
 
               int numHits(0);
 
               // Make a container for what will be the filtered collection
               std::vector<recob::Hit> filteredHitVec;
 
               for (const auto& peakParams : peakParamsVec) {
                 // Extract values for this hit
                 float peakAmp = peakParams.peakAmplitude;
                 float peakMean = peakParams.peakCenter;
                 float peakWidth = peakParams.peakSigma;
 
                 // Place one bit of protection here
                 if (std::isnan(peakAmp)) {
                   std::cout << "**** hit peak amplitude is a nan! Channel: " << channel
                             << ", start tick: " << startT << std::endl;
                   continue;
                 }
 
                 // Extract errors
                 float peakAmpErr = peakParams.peakAmplitudeError;
                 float peakMeanErr = peakParams.peakCenterError;
                 float peakWidthErr = peakParams.peakSigmaError;
 
                 // ### Charge ###
                 float charge =
                   chargeFunc(peakMean, peakAmp, peakWidth, fAreaNormsVec[plane], startT, endT);
                 ;
                 float chargeErr =
                   std::sqrt(TMath::Pi()) * (peakAmpErr * peakWidthErr + peakWidthErr * peakAmpErr);
 
                 // ### limits for getting sums
                 std::vector<float>::const_iterator sumStartItr = range.begin() + startT;
                 std::vector<float>::const_iterator sumEndItr = range.begin() + endT;
 
                 // ### Sum of ADC counts
                 double sumADC = std::accumulate(sumStartItr, sumEndItr, 0.);
 
                 // ok, now create the hit
                 recob::HitCreator hitcreator(
                   *wire,                      // wire reference
                   wid,                        // wire ID
                   startT + roiFirstBinTick,   // start_tick TODO check
                   endT + roiFirstBinTick,     // end_tick TODO check
                   peakWidth,                  // rms
                   peakMean + roiFirstBinTick, // peak_time
                   peakMeanErr,                // sigma_peak_time
                   peakAmp,                    // peak_amplitude
                   peakAmpErr,                 // sigma_peak_amplitude
                   charge,                     // hit_integral
                   chargeErr,                  // hit_sigma_integral
                   sumADC,                     // summedADC FIXME
                   nGausForFit,                // multiplicity
                   numHits,                    // local_index TODO check that the order is correct
                   chi2PerNDF,                 // goodness_of_fit
                   NDF                         // dof
                 );
 
                 if (filteredHitCol) filteredHitVec.push_back(hitcreator.copy());
 
                 const recob::Hit hit(hitcreator.move());
 
                 // This loop will store ALL hits
                 hitstruct tmp{std::move(hit), wire};
                 hitstruct_vec.push_back(std::move(tmp));
 
                 numHits++;
               } // <---End loop over gaussians
 
               // Should we filter hits?
               if (filteredHitCol && !filteredHitVec.empty()) {
                 // #######################################################################
                 // Is all this sorting really necessary?  Would it be faster to just loop
                 // through the hits and perform simple cuts on amplitude and width on a
                 // hit-by-hit basis, either here in the module (using fPulseHeightCuts and
                 // fPulseWidthCuts) or in HitFilterAlg?
                 // #######################################################################
 
                 // Sort in ascending peak height
                 std::sort(filteredHitVec.begin(),
                           filteredHitVec.end(),
                           [](const auto& left, const auto& right) {
                             return left.PeakAmplitude() > right.PeakAmplitude();
                           });
 
                 // Reject if the first hit fails the PH/wid cuts
                 if (filteredHitVec.front().PeakAmplitude() < fPulseHeightCuts.at(plane) ||
                     filteredHitVec.front().RMS() < fPulseWidthCuts.at(plane))
                   filteredHitVec.clear();
 
                 // Now check other hits in the snippet
                 if (filteredHitVec.size() > 1) {
                   // The largest pulse height will now be at the front...
                   float largestPH = filteredHitVec.front().PeakAmplitude();
 
                   // Find where the pulse heights drop below threshold
                   float threshold(fPulseRatioCuts.at(plane));
 
                   std::vector<recob::Hit>::iterator smallHitItr =
                     std::find_if(filteredHitVec.begin(),
                                  filteredHitVec.end(),
                                  [largestPH, threshold](const auto& hit) {
                                    return hit.PeakAmplitude() < 8. &&
                                           hit.PeakAmplitude() / largestPH < threshold;
                                  });
 
                   // Shrink to fit
                   if (smallHitItr != filteredHitVec.end())
                     filteredHitVec.resize(std::distance(filteredHitVec.begin(), smallHitItr));
 
                   // Resort in time order
                   std::sort(filteredHitVec.begin(),
                             filteredHitVec.end(),
                             [](const auto& left, const auto& right) {
                               return left.PeakTime() < right.PeakTime();
                             });
                 }
 
                 // Copy the hits we want to keep to the filtered hit collection
                 for (const auto& filteredHit : filteredHitVec)
                   if (!fHitFilterAlg || fHitFilterAlg->IsGoodHit(filteredHit)) {
                     hitstruct tmp{std::move(filteredHit), wire};
                     filthitstruct_vec.push_back(std::move(tmp));
                   }
 
                 if (fFillHists) fChi2->Fill(chi2PerNDF);
               }
             } //<---End loop over merged candidate hits
           }   //<---End looping over ROI's
         );    //end tbb parallel for
       }       //<---End looping over all the wires
     );        //end tbb parallel for
 
     for (size_t i = 0; i < hitstruct_vec.size(); i++) {
       allHitCol.emplace_back(hitstruct_vec[i].hit_tbb, hitstruct_vec[i].wire_tbb);
     }
 
     for (size_t j = 0; j < filthitstruct_vec.size(); j++) {
       filteredHitCol->emplace_back(filthitstruct_vec[j].hit_tbb, filthitstruct_vec[j].wire_tbb);
     }
 
     //==================================================================================================
     // End of the event -- move the hit collection and the associations into the event
 
     if (filteredHitCol) {
 
       // If we filtered hits but no instance name was
       // specified for the "all hits" collection, then
       // only save the filtered hits to the event
       if (fAllHitsInstanceName == "") {
         filteredHitCol->put_into(evt);
 
         // otherwise, save both
       }
       else {
         filteredHitCol->put_into(evt);
         allHitCol.put_into(evt);
       }
     }
     else {
       allHitCol.put_into(evt);
     }
 
     // Keep track of events processed
     //fEventCount++;
 
   } // End of produce()

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

template<BranchType BT = InEvent, typename... T>

void art::detail::SharedModule::serialize ( T const & ... )

protectedinherited

Referenced by simfilter::FilterSimPhotonLiteTime::FilterSimPhotonLiteTime(), simfilter::FilterSimPhotonTime::FilterSimPhotonTime(), art::detail::LegacyModule::LegacyModule(), and art::OutputModule::OutputModule().

template<BranchType , typename... T>

void art::detail::SharedModule::serialize ( T const &... resources )

inherited

Definition at line 83 of file SharedModule.h.

References art::detail::SharedModule::serialize_for_resource().

   {
     serialize_for_resource(resources...);
   }

template<BranchType BT = InEvent, typename... T>

void art::detail::SharedModule::serializeExternal ( T const & ... )

protectedinherited

Referenced by wcls::WireCellToolkit::WireCellToolkit().

template<BranchType , typename... T>

void art::detail::SharedModule::serializeExternal ( T const &... resources )

inherited

Definition at line 90 of file SharedModule.h.

References art::detail::SharedModule::serialize_for_external_resource().

   {
     serialize_for_external_resource(resources...);
   }

SerialTaskQueueChain * art::detail::SharedModule::serialTaskQueueChain ( ) const

inherited

Definition at line 22 of file SharedModule.cc.

References art::detail::SharedModule::chain_.

   {
     return chain_.get();
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

std::set< std::string > const & art::detail::SharedModule::sharedResources ( ) const

inherited

Definition at line 28 of file SharedModule.cc.

References art::detail::SharedModule::resourceNames_.

   {
     return resourceNames_;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }