Produces clusters by the TrajCluster algorithm. More...

Inheritance diagram for cluster::TrajCluster:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

void	reconfigure (fhicl::ParameterSet const &pset)

void	produce (art::Event &evt) override

void	beginJob () override

void	endJob () override

template<typename PROD , BranchType B = InEvent>
ProductID	getProductID (std::string const &instanceName={}) const

template<typename PROD , BranchType B>
ProductID	getProductID (ModuleDescription const &moduleDescription, std::string const &instanceName) const

bool	modifiesEvent () const

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Private Attributes
std::unique_ptr< tca::TrajClusterAlg >	fTCAlg

TTree *	showertree

art::InputTag	fHitModuleLabel

art::InputTag	fSliceModuleLabel

art::InputTag	fHitTruthModuleLabel

art::InputTag	fSpacePointModuleLabel

bool	fDoWireAssns

bool	fDoRawDigitAssns

Detailed Description

Produces clusters by the TrajCluster algorithm.

Configuration parameters

HitFinderModuleLabel (InputTag, mandatory): label of the hits to be used as input (usually the label of the producing module is enough)
TrajClusterAlg (parameter set, mandatory): full configuration for TrajClusterAlg algorithm

Definition at line 49 of file TrajCluster_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 34 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::EDProducer::Table = ProducerBase::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 43 of file EDProducer.h.

using art::EDProducer::WorkerType = WorkerT<EDProducer>

inherited

Definition at line 35 of file EDProducer.h.

Constructor & Destructor Documentation

cluster::TrajCluster::TrajCluster ( fhicl::ParameterSet const & pset )

explicit

Definition at line 149 of file TrajCluster_module.cc.

References recob::HitAndAssociationsWriterBase::declare_products(), fDoRawDigitAssns, fDoWireAssns, and reconfigure().

                                                         {
     
     reconfigure(pset);
     
     // let HitCollectionAssociator declare that we are going to produce
     // hits and associations with wires and raw digits
     // (with no particular product label)
     recob::HitCollectionAssociator::declare_products(*this,"",fDoWireAssns,fDoRawDigitAssns);
     
     produces< std::vector<recob::Cluster> >();
     produces< std::vector<recob::Vertex> >();
     produces< std::vector<recob::EndPoint2D> >();
     produces< std::vector<recob::Seed> >();
     produces< std::vector<recob::Shower> >();
     produces< art::Assns<recob::Cluster, recob::Hit> >();
     produces< art::Assns<recob::Cluster, recob::EndPoint2D, unsigned short> >();
     produces< art::Assns<recob::Cluster, recob::Vertex, unsigned short> >();
     produces< art::Assns<recob::Shower, recob::Hit> >();
     
     produces< std::vector<recob::PFParticle> >();
     produces< art::Assns<recob::PFParticle, recob::Cluster> >();
     produces< art::Assns<recob::PFParticle, recob::Shower> >();
     produces< art::Assns<recob::PFParticle, recob::Vertex> >();
     produces< art::Assns<recob::PFParticle, recob::Seed> >();
     
     produces< art::Assns<recob::Slice, recob::Cluster> >();
     produces< art::Assns<recob::Slice, recob::PFParticle> >();
     produces< art::Assns<recob::Slice, recob::Hit> >();
 
     produces< std::vector<anab::CosmicTag>>();
     produces< art::Assns<recob::PFParticle, anab::CosmicTag>>();
     
     // www: declear/create SpacePoint and association between SpacePoint and Hits from TrajCluster (Hit->SpacePoint)
     produces< art::Assns<recob::SpacePoint, recob::Hit> >();
   } // TrajCluster::TrajCluster()

Member Function Documentation

void cluster::TrajCluster::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 186 of file TrajCluster_module.cc.

References fTCAlg, art::TFileDirectory::make(), and showertree.

   {
     art::ServiceHandle<art::TFileService> tfs;
 
     showertree = tfs->make<TTree>("showervarstree", "showerVarsTree");
     fTCAlg->DefineShTree(showertree);
 //    crtree = tfs->make<TTree>("crtree", "Cosmic removal variables");
 //    fTCAlg->DefineCRTree(crtree);
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDProducer::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

   {
     return current_context_.get();
   }

void cluster::TrajCluster::endJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 197 of file TrajCluster_module.cc.

References fTCAlg, tca::kKilled, art::left(), and art::right().

   {
     std::vector<unsigned int> const& fAlgModCount = fTCAlg->GetAlgModCount();
     std::vector<std::string> const& fAlgBitNames = fTCAlg->GetAlgBitNames();
     if(fAlgBitNames.size() != fAlgModCount.size()) return;
     mf::LogVerbatim myprt("TC");
     myprt<<"TrajCluster algorithm counts\n";
     unsigned short icol = 0;
     for(unsigned short ib = 0; ib < fAlgModCount.size(); ++ib) {
       if(ib == tca::kKilled) continue;
       myprt<<std::left<<std::setw(18)<<fAlgBitNames[ib]<<std::right<<std::setw(10)<<fAlgModCount[ib]<<" ";
       ++icol;
       if(icol == 4) { myprt<<"\n"; icol = 0; }
     } // ib
   } // endJob

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

template<typename PROD , BranchType B>

ProductID art::EDProducer::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

   {
     return ProducerBase::getProductID<PROD, B>(moduleDescription_,
                                                instanceName);
   }

template<typename PROD , BranchType B>

ProductID art::ProducerBase::getProductID	(	ModuleDescription const &	moduleDescription,
		std::string const &	instanceName
	)		const

inherited

Definition at line 56 of file ProducerBase.h.

References B, and art::ModuleDescription::moduleLabel().

Referenced by art::ProducerBase::modifiesEvent().

   {
     auto const& pd =
       get_ProductDescription<PROD>(B, md.moduleLabel(), instanceName);
     return pd.productID();
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::ProducerBase::modifiesEvent ( ) const

inlineinherited

Definition at line 40 of file ProducerBase.h.

References art::ProducerBase::getProductID().

     {
       return true;
     }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

void cluster::TrajCluster::produce ( art::Event & evt )

overridevirtual

Implements art::EDProducer.

Definition at line 214 of file TrajCluster_module.cc.

   {
     // Get a single hit collection from a HitsModuleLabel or multiple sets of "sliced" hits
     // (aka clusters of hits that are close to each other in 3D) from a SliceModuleLabel. 
     // A pointer to the full hit collection is passed to TrajClusterAlg. The hits that are 
     // in each slice are tracked to find 2D trajectories (that become clusters), 
     // 2D vertices (EndPoint2D), 3D vertices, PFParticles and Showers. These data products
     // are then collected and written to the event. Each slice is considered as an independent
     // collection of hits with the additional requirement that all hits in a slice reside in
     // one TPC
     
     // Define a vector of indices into inputHits (= evt.allHits in TrajClusterAlg) 
     // for each slice for hits associated with 3D-clustered SpacePoints
     std::vector<std::vector<unsigned int>> slHitsVec;
     // Slice IDs that will be correlated with sub-slices
     std::vector<int> slcIDs;
     // pointers to the slices in the event
     std::vector<art::Ptr<recob::Slice>> slices;
     unsigned int nInputHits = 0;
     // get a handle for the hit collection
     auto inputHits = art::Handle<std::vector<recob::Hit>>();
     if(!evt.getByLabel(fHitModuleLabel, inputHits)) throw cet::exception("TrajClusterModule")<<"Failed to get a handle to hit collection '"<<fHitModuleLabel.label()<<"'\n";
     nInputHits = (*inputHits).size();
     if(nInputHits > 0) {
       // This is a pointer to a vector of recob::Hits that exist in the event. The hits
       // are not copied.
       if(!fTCAlg->SetInputHits(*inputHits)) throw cet::exception("TrajClusterModule")<<"Failed to process hits from '"<<fHitModuleLabel.label()<<"'\n";
       if(tca::tcc.dbgStp) std::cout<<"DebugMode: Looking for hit near "<<tca::debug.Cryostat<<":"<<tca::debug.TPC<<":"<<tca::debug.Plane<<":"<<tca::debug.Wire<<":"<<tca::debug.Tick<<"\n";
       if(fSliceModuleLabel != "NA") {
         // Expecting to find sliced hits from Slice -> Hits assns
         auto slcHandle = evt.getValidHandle<std::vector<recob::Slice>>(fSliceModuleLabel);
         art::fill_ptr_vector(slices, slcHandle);
         art::FindManyP<recob::Hit> hitFromSlc(slcHandle, evt, fSliceModuleLabel);
         for(size_t isl = 0; isl < slices.size(); ++isl) {
           // select slices with user-defined cuts in test beam mode
           if(tca::tcc.modes[tca::kTestBeam] && tca::tcc.testBeamCuts.size() > 1) {
             float zlo = slices[isl]->End0Pos().Z();
             if(slices[isl]->End1Pos().Z() < zlo) zlo = slices[isl]->End1Pos().Z();
             auto sepVec = slices[isl]->End0Pos() - slices[isl]->End1Pos();
             float len = sqrt(sepVec.Mag2());
             bool isBeam = (zlo < tca::tcc.testBeamCuts[0] && len > tca::tcc.testBeamCuts[1]);
             if(isBeam && tca::tcc.modes[tca::kDebug]) {
               std::cout<<"Beam slice "<<slices[isl]->ID();
               std::cout<<" Direction "<<slices[isl]->Direction().X()<<" "<<slices[isl]->Direction().Y()<<" "<<slices[isl]->Direction().Z();
               std::cout<<" AspectRatio "<<std::setprecision(2)<<slices[isl]->AspectRatio();
               std::cout<<" Length "<<(int)len;
               std::cout<<"\n";
             } // zlo < 10
             if(!isBeam) continue;
           } // TestBeam mode
           auto& hit_in_slc = hitFromSlc.at(isl);
           if(hit_in_slc.size() < 3) continue;
           std::vector<unsigned int> slhits(hit_in_slc.size());
           unsigned int indx = 0;
           if(hit_in_slc[0].id() != inputHits.id()) throw cet::exception("TrajClusterModule")<<"Input hits from '"<<fHitModuleLabel.label()<<"' have a different product id than hits referenced in '"<<fSliceModuleLabel.label()<<"'\n";
           for(auto& hit : hit_in_slc) {
             if(hit.key() > nInputHits - 1) throw cet::exception("TrajClusterModule")<<"Found an invalid slice index "<<hit.key()<<" to the input hit collection of size "<<nInputHits<<"\n";
             slhits[indx] = hit.key();
             ++indx;
           } // hit
           if(slhits.size() < 3) continue;
           slHitsVec.push_back(slhits);
           slcIDs.push_back(slices[isl]->ID());
         } // isl
       } else {
         // There was no pre-processing of the hits to define slices
         // so put all hits into one slice
         slHitsVec.resize(1);
         slHitsVec[0].resize(nInputHits);
         for(unsigned int iht = 0; iht < nInputHits; ++iht) slHitsVec[0][iht] = iht;
         slcIDs.resize(1, 1);
       } // no input slices
 
       // split slHitsVec so that all hits in a sub-slice are in the same TPC
       const geo::GeometryCore* geom = lar::providerFrom<geo::Geometry>();
       if(geom->NTPC() > 1) {
         std::vector<std::vector<unsigned int>> tpcSlcHitsVec;
         std::vector<int> tpcSlcIDs;
         for(unsigned short isl = 0; isl < slHitsVec.size(); ++isl) {
           auto& slhits = slHitsVec[isl];
           if(slhits.size() < 2) continue;
           // list of hits in this slice in each TPC
           std::vector<std::vector<unsigned int>> tpcHits;
           // list of TPCs in this slice
           std::vector<unsigned short> tpcNum;
           for(auto iht : slhits) {
             auto& hit = (*inputHits)[iht];
             unsigned short tpc = hit.WireID().TPC;
             unsigned short tpcIndex = 0;
             for(tpcIndex = 0; tpcIndex < tpcNum.size(); ++tpcIndex) if(tpcNum[tpcIndex] == tpc) break;
             if(tpcIndex == tpcNum.size()) {
               // not in tpcNum so make a new entry
               tpcHits.resize(tpcIndex + 1);
               tpcNum.push_back(tpc);
             }
             tpcHits[tpcIndex].push_back(iht);
           } // iht
           for(auto& tHits : tpcHits) {
             tpcSlcHitsVec.push_back(tHits);
             tpcSlcIDs.push_back(slcIDs[isl]);
           }
         } // slhits
         // over-write slHitsVec
         slHitsVec = tpcSlcHitsVec;
         slcIDs = tpcSlcIDs;
       } // > 1 TPC
       
       // Get truth info before reconstructing
       // list of selected MCParticles
       std::vector<simb::MCParticle*> mcpList;
       // and a vector of MC-matched hits
       std::vector<unsigned int> mcpListIndex((*inputHits).size(), UINT_MAX);
       if(!evt.isRealData() && tca::tcc.matchTruth[0] >= 0 && fHitTruthModuleLabel != "NA") {
         // TODO: Add a check here to ensure that a neutrino vertex exists inside any TPC
         // when checking neutrino reconstruction performance.
         // create a list of MCParticles of interest
         // save MCParticles that have the desired MCTruth origin using
         // the Origin_t typedef enum: kUnknown, kBeamNeutrino, kCosmicRay, kSuperNovaNeutrino, kSingleParticle
         simb::Origin_t origin = (simb::Origin_t)tca::tcc.matchTruth[0];
         // or save them all
         bool anySource = (origin == simb::kUnknown);
         // get the assns
         art::FindManyP<simb::MCParticle,anab::BackTrackerHitMatchingData> particles_per_hit(inputHits, evt, fHitTruthModuleLabel);
         art::ServiceHandle<cheat::ParticleInventoryService> pi_serv;
         sim::ParticleList const& plist = pi_serv->ParticleList();
         for(sim::ParticleList::const_iterator ipart = plist.begin(); ipart != plist.end(); ++ipart) {
           auto& p = (*ipart).second;
           int trackID = p->TrackId();
           art::Ptr<simb::MCTruth> theTruth = pi_serv->TrackIdToMCTruth_P(trackID);
           int KE = 1000 * (p->E() - p->Mass());
           if(!anySource && theTruth->Origin() != origin) continue;
           if(tca::tcc.matchTruth[1] > 1 && KE > 10 && p->Process() == "primary") {
             std::cout<<"TCM: mcp Origin "<<theTruth->Origin()
             <<std::setw(8)<<p->TrackId()
             <<" pdg "<<p->PdgCode()
             <<std::setw(7)<<KE<<" mom "<<p->Mother()
             <<" "<<p->Process()
             <<"\n";
           }
           mcpList.push_back(p);
         } // ipart
         std::vector<art::Ptr<simb::MCParticle>> particle_vec;
         std::vector<anab::BackTrackerHitMatchingData const*> match_vec;
         unsigned int nMatHits = 0;
         for(unsigned int iht = 0; iht < (*inputHits).size(); ++iht) {
           particle_vec.clear(); match_vec.clear();
           try{ particles_per_hit.get(iht, particle_vec, match_vec); }
           catch(...) {
             std::cout<<"BackTrackerHitMatchingData not found\n";
             break;
           }
           if(particle_vec.empty()) continue;
           int trackID = 0;
           for(unsigned short im = 0; im < match_vec.size(); ++im) {
             if(match_vec[im]->ideFraction < 0.5) continue;
             trackID = particle_vec[im]->TrackId();
             break;
           } // im
           if(trackID == 0) continue;
           // look for this in MCPartList
           for(unsigned int ipart = 0; ipart < mcpList.size(); ++ipart) {
             auto& mcp = mcpList[ipart];
             if(mcp->TrackId() != trackID) continue;
             mcpListIndex[iht] = ipart;
             ++nMatHits;
             break;
           } // ipart
         } // iht
         if(tca::tcc.matchTruth[1] > 1) std::cout<<"Loaded "<<mcpList.size()<<" MCParticles. "<<nMatHits<<"/"<<(*inputHits).size()<<" hits are matched to MCParticles\n";
       } // fill mcpList
       
       // First sort the hits in each sub-slice and then reconstruct
       for(unsigned short isl = 0; isl < slHitsVec.size(); ++isl) {
         auto& slhits = slHitsVec[isl];
         // sort the slice hits by Cryostat, TPC, Wire, Plane, Start Tick and LocalIndex.
         // This assumes that hits with larger LocalIndex are at larger Tick.
         std::vector<HitLoc> sortVec(slhits.size());
         bool badHit = false;
         for(unsigned short indx = 0; indx < slhits.size(); ++indx) {
           if(slhits[indx] > nInputHits - 1) {
             badHit = true;
             break;
           }
           auto& hit = (*inputHits)[slhits[indx]];
           sortVec[indx].index = indx;
           sortVec[indx].ctp = tca::EncodeCTP(hit.WireID());
           sortVec[indx].wire = hit.WireID().Wire;
           sortVec[indx].tick = hit.StartTick();
           sortVec[indx].localIndex = hit.LocalIndex();
         } // iht
         if(badHit) {
           std::cout<<"TrajCluster found an invalid slice reference to the input hit collection. Ignoring this slice.\n";
           continue;
         }
         std::sort(sortVec.begin(), sortVec.end(), SortHits);
         // make a temporary copy of slhits
         auto tmp = slhits;
         // put slhits into proper order
         for(unsigned short ii = 0; ii < slhits.size(); ++ii) slhits[ii] = tmp[sortVec[ii].index];
         // clear the temp vector
         tmp.resize(0);
         // try to find a hit in debug step mode
         if(tca::tcc.modes[tca::kDebug]) {
           for(unsigned short indx = 0; indx < slhits.size(); ++indx) {
             auto& hit = (*inputHits)[slhits[indx]];
             if((int)hit.WireID().TPC == tca::debug.TPC && 
                (int)hit.WireID().Plane == tca::debug.Plane &&
                (int)hit.WireID().Wire == tca::debug.Wire &&
                hit.PeakTime() > tca::debug.Tick - 10  && hit.PeakTime() < tca::debug.Tick + 10) {
               std::cout<<"Debug hit "<<slhits[indx]<<" found in sub-slice index "<<isl;
               std::cout<<"\n";
               tca::debug.Hit = slhits[indx];
               tca::tcc.dbgStp = true;
               break;
             } // Look for debug hit
           } // iht
         } // Debug mode
         // reconstruct using the hits in this sub-slice. The data products are stored internally in
         // TrajCluster data structs.
         fTCAlg->RunTrajClusterAlg(slhits, slcIDs[isl]);
       } // isl
       
       // stitch PFParticles between TPCs, create PFP start vertices, etc
       fTCAlg->FinishEvent();
       
       if(!mcpListIndex.empty()) {
         fTCAlg->fTM.MatchTruth(mcpList, mcpListIndex);
         if(tca::tcc.matchTruth[0] >= 0) fTCAlg->fTM.PrintResults(evt.event());
       } // mcpList not empty
       if(tca::tcc.dbgSummary) tca::PrintAll("TCM", mcpList);
     } // input hits exist
 
     // Vectors to hold all data products that will go into the event
     std::vector<recob::Hit> hitCol;       // output hit collection
     std::vector<recob::Cluster> clsCol;
     std::vector<recob::PFParticle> pfpCol;
     std::vector<recob::Vertex> vx3Col;
     std::vector<recob::EndPoint2D> vx2Col;
     std::vector<recob::Seed> sedCol;
     std::vector<recob::Shower> shwCol;
     std::vector<anab::CosmicTag> ctCol;
     // a vector to correlate inputHits with output hits
     std::vector<unsigned int> newIndex(nInputHits, UINT_MAX);
     
     // assns for those data products
     // Cluster -> ...
     std::unique_ptr<art::Assns<recob::Cluster, recob::Hit>> 
       cls_hit_assn(new art::Assns<recob::Cluster, recob::Hit>);
     // unsigned short is the end to which a vertex is attached
     std::unique_ptr<art::Assns<recob::Cluster, recob::EndPoint2D, unsigned short>>  
       cls_vx2_assn(new art::Assns<recob::Cluster, recob::EndPoint2D, unsigned short>);
     std::unique_ptr<art::Assns<recob::Cluster, recob::Vertex, unsigned short>>  
       cls_vx3_assn(new art::Assns<recob::Cluster, recob::Vertex, unsigned short>);
     // Shower -> ...
     std::unique_ptr<art::Assns<recob::Shower, recob::Hit>>
       shwr_hit_assn(new art::Assns<recob::Shower, recob::Hit>);
     // PFParticle -> ...
     std::unique_ptr<art::Assns<recob::PFParticle, recob::Cluster>>
       pfp_cls_assn(new art::Assns<recob::PFParticle, recob::Cluster>);
     std::unique_ptr<art::Assns<recob::PFParticle, recob::Shower>>
       pfp_shwr_assn(new art::Assns<recob::PFParticle, recob::Shower>);
     std::unique_ptr<art::Assns<recob::PFParticle, recob::Vertex>> 
       pfp_vx3_assn(new art::Assns<recob::PFParticle, recob::Vertex>);
     std::unique_ptr<art::Assns<recob::PFParticle, anab::CosmicTag>>
       pfp_cos_assn(new art::Assns<recob::PFParticle, anab::CosmicTag>);
     std::unique_ptr<art::Assns<recob::PFParticle, recob::Seed>>
       pfp_sed_assn(new art::Assns<recob::PFParticle, recob::Seed>);
     // Slice -> ...
     std::unique_ptr<art::Assns<recob::Slice, recob::Cluster>>
       slc_cls_assn(new art::Assns<recob::Slice, recob::Cluster>);
     std::unique_ptr<art::Assns<recob::Slice, recob::PFParticle>>
       slc_pfp_assn(new art::Assns<recob::Slice, recob::PFParticle>);
     std::unique_ptr<art::Assns<recob::Slice, recob::Hit>>
       slc_hit_assn(new art::Assns<recob::Slice, recob::Hit>);
     // www: Hit -> SpacePoint
     std::unique_ptr<art::Assns<recob::SpacePoint, recob::Hit>>
       sp_hit_assn(new art::Assns<recob::SpacePoint, recob::Hit>);     
 
     // temp struct to get the index of a 2D (or 3D vertex) into vx2Col (or vx3Col)
     // given a slice index and a vertex ID (not UID)
     struct slcVxStruct {
       unsigned short slIndx;
       int ID;
       unsigned short vxColIndx;
     };
     std::vector<slcVxStruct> vx2StrList;
     // vector to map 3V UID -> ID in each sub-slice
     std::vector<slcVxStruct> vx3StrList;
 
 
     if(nInputHits > 0) {
       unsigned short nSlices = fTCAlg->GetSlicesSize();
       // define a hit collection begin index to pass to CreateAssn for each cluster
       unsigned int hitColBeginIndex = 0;
       for(unsigned short isl = 0; isl < nSlices; ++isl) {
         unsigned short slcIndex = 0;
         if(!slices.empty()) {
           for(slcIndex = 0; slcIndex < slices.size(); ++slcIndex) if(slices[slcIndex]->ID() == slcIDs[isl]) break;
           if(slcIndex == slices.size()) continue;
         }
         auto& slc = fTCAlg->GetSlice(isl);
         // See if there was a serious reconstruction failure that made the sub-slice invalid
         if(!slc.isValid) continue;
         // make EndPoint2Ds
         for(auto& vx2 : slc.vtxs) {
           if(vx2.ID <= 0) continue;
           unsigned int vtxID = vx2.UID;
           unsigned int wire = std::nearbyint(vx2.Pos[0]);
           geo::PlaneID plID = tca::DecodeCTP(vx2.CTP);
           geo::WireID wID = geo::WireID(plID.Cryostat, plID.TPC, plID.Plane, wire);
           geo::View_t view = tca::tcc.geom->View(wID);
           vx2Col.emplace_back((double)vx2.Pos[1]/tca::tcc.unitsPerTick,  // Time
                               wID,                  // WireID
                               vx2.Score,            // strength = score
                               vtxID,                // ID
                               view,                 // View
                               0);                   // total charge - not relevant
 
           // fill the mapping struct
           slcVxStruct tmp;
           tmp.slIndx = isl;
           tmp.ID = vx2.ID;
           tmp.vxColIndx = vx2Col.size() - 1;
           vx2StrList.push_back(tmp);
 
         } // vx2
         // make Vertices
         for(auto& vx3 : slc.vtx3s) {
           if(vx3.ID <= 0) continue;
           // ignore incomplete vertices
           if(vx3.Wire >= 0) continue;
           unsigned int vtxID = vx3.UID;
           double xyz[3];
           xyz[0] = vx3.X;
           xyz[1] = vx3.Y;
           xyz[2] = vx3.Z;
           vx3Col.emplace_back(xyz, vtxID);
 
           // fill the mapping struct
           slcVxStruct tmp;
           tmp.slIndx = isl;
           tmp.ID = vx3.ID;
           tmp.vxColIndx = vx3Col.size() - 1;
           vx3StrList.push_back(tmp);
 
         } // vx3
         // Convert the tjs to clusters
         for(auto& tj : slc.tjs) {
           if(tj.AlgMod[tca::kKilled]) continue;
           hitColBeginIndex = hitCol.size();
           for(unsigned short ipt = tj.EndPt[0]; ipt <= tj.EndPt[1]; ++ipt) {
             auto& tp = tj.Pts[ipt];
             if(tp.Chg <= 0) continue;
             // index of inputHits indices  of hits used in one TP
             std::vector<unsigned int> tpHits;
             for(unsigned short ii = 0; ii < tp.Hits.size(); ++ii) {
               if(!tp.UseHit[ii]) continue;
               if(tp.Hits[ii] > slc.slHits.size() - 1) {
                 break;
               } // bad slHits index
               unsigned int allHitsIndex = slc.slHits[tp.Hits[ii]].allHitsIndex;
               if(allHitsIndex > nInputHits - 1) {
                 break;
               } // bad allHitsIndex
               tpHits.push_back(allHitsIndex);
               if(newIndex[allHitsIndex] != UINT_MAX) {
                 std::cout<<"Bad Slice "<<isl<<" tp.Hits "<<tp.Hits[ii]<<" allHitsIndex "<<allHitsIndex;
                 std::cout<<" old newIndex "<<newIndex[allHitsIndex];
                 auto& oldhit = (*inputHits)[allHitsIndex];
                 std::cout<<" old "<<oldhit.WireID().Plane<<":"<<oldhit.WireID().Wire<<":"<<(int)oldhit.PeakTime();
                 auto& newhit = hitCol[newIndex[allHitsIndex]];
                 std::cout<<" new "<<newhit.WireID().Plane<<":"<<newhit.WireID().Wire<<":"<<(int)newhit.PeakTime();
                 std::cout<<" hitCol size "<<hitCol.size();
                 std::cout<<"\n";
                 break;
               }
 //              newIndex[allHitsIndex] = hitCol.size();
             } // ii
             // Let the alg define the hit either by merging multiple hits or by a simple copy
             // of a single hit from inputHits
             // Merge hits in the TP that are on the same wire or create hits on multiple wires
             // and update the old hits -> new hits assn (newIndex)
             if(tj.AlgMod[tca::kHaloTj]) {
               // dressed muon - don't merge hits
               for(auto iht : tpHits) {
                 hitCol.push_back((*inputHits)[iht]);
                 newIndex[iht] = hitCol.size() - 1;
               } // iht
             } else {
               fTCAlg->MergeTPHits(tpHits, hitCol, newIndex);
             }
           } // tp
           if(hitCol.empty()) continue;
           // Sum the charge and make the associations
           float sumChg = 0;
           float sumADC = 0;
           for(unsigned short indx =  hitColBeginIndex; indx < hitCol.size(); ++indx) {
             auto& hit = hitCol[indx];
             sumChg += hit.Integral();
             sumADC += hit.SummedADC();
             if(!slices.empty() && !util::CreateAssn(*this, evt, hitCol, slices[slcIndex], *slc_hit_assn, indx)) {
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate hits with Slice";
             }
           } // indx
           geo::View_t view = hitCol[hitColBeginIndex].View();
           auto& firstTP = tj.Pts[tj.EndPt[0]];
           auto& lastTP = tj.Pts[tj.EndPt[1]];
           int clsID = tj.UID;
           if(tj.AlgMod[tca::kShowerLike]) clsID = -clsID;
           // dressed muon - give the halo cluster the same ID as the parent
           if(tj.AlgMod[tca::kHaloTj]) clsID = -tj.ParentID;
           unsigned short nclhits = hitCol.size() - hitColBeginIndex + 1;
           clsCol.emplace_back(
                               firstTP.Pos[0],         // Start wire
                               0,                      // sigma start wire
                               firstTP.Pos[1]/tca::tcc.unitsPerTick,         // start tick
                               0,                      // sigma start tick
                               firstTP.AveChg,         // start charge
                               firstTP.Ang,            // start angle
                               0,                      // start opening angle (0 for line-like clusters)
                               lastTP.Pos[0],          // end wire
                               0,                      // sigma end wire
                               lastTP.Pos[1]/tca::tcc.unitsPerTick,           // end tick
                               0,                      // sigma end tick
                               lastTP.AveChg,          // end charge
                               lastTP.Ang,             // end angle
                               0,                      // end opening angle (0 for line-like clusters)
                               sumChg,                 // integral
                               0,                      // sigma integral
                               sumADC,                 // summed ADC
                               0,                      // sigma summed ADC
                               nclhits,                // n hits
                               0,                      // wires over hits
                               0,                      // width (0 for line-like clusters)
                               clsID,                  // ID from TrajClusterAlg
                               view,                   // view
                               tca::DecodeCTP(tj.CTP), // planeID
                               recob::Cluster::Sentry  // sentry
                               );
           if(!util::CreateAssn(*this, evt, clsCol, hitCol, *cls_hit_assn, hitColBeginIndex, hitCol.size()))
           {
             throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate hits with cluster ID "<<tj.UID;
           } // exception
           // make Slice -> cluster assn
           if(!slices.empty()) {
             if(!util::CreateAssn(*this, evt, clsCol, slices[slcIndex], *slc_cls_assn))
             {
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate slice with PFParticle";
             } // exception
           } // slices exist
           // Make cluster -> 2V and cluster -> 3V assns
           for(unsigned short end = 0; end < 2; ++end) {
             if(tj.VtxID[end] <= 0) continue;
             for(auto& vx2str : vx2StrList) {
               if(vx2str.slIndx != isl) continue;
               if(vx2str.ID != tj.VtxID[end]) continue;
               if(!util::CreateAssnD(*this, evt, *cls_vx2_assn, clsCol.size() - 1, vx2str.vxColIndx, end)) {
                 throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate cluster "<<tj.UID<<" with EndPoint2D";
               } // exception
               auto& vx2 = slc.vtxs[tj.VtxID[end] - 1];
               if(vx2.Vx3ID > 0) {
                 for(auto vx3str : vx3StrList) {
                   if(vx3str.slIndx != isl) continue;
                   if(vx3str.ID != vx2.Vx3ID) continue;
                   if(!util::CreateAssnD(*this, evt, *cls_vx3_assn, clsCol.size() - 1, vx3str.vxColIndx, end))
                   {
                     throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate cluster "<<tj.UID<<" with Vertex";
                   } // exception
                   break;
                 } // vx3str
               } // vx2.Vx3ID > 0
               break;
             } // vx2str
           } // end
         } // tj (aka cluster)
         // make Showers
         for(auto& ss3 : slc.showers) {
           if(ss3.ID <= 0) continue;
           recob::Shower shower;
           shower.set_id(ss3.UID);
           shower.set_total_energy(ss3.Energy);
           shower.set_total_energy_err(ss3.EnergyErr);
           shower.set_total_MIPenergy(ss3.MIPEnergy);
           shower.set_total_MIPenergy_err(ss3.MIPEnergyErr);
           shower.set_total_best_plane(ss3.BestPlane);
           TVector3 dir = {ss3.Dir[0], ss3.Dir[1], ss3.Dir[2]};
           shower.set_direction(dir);
           TVector3 dirErr = {ss3.DirErr[0], ss3.DirErr[1], ss3.DirErr[2]};
           shower.set_direction_err(dirErr);
           TVector3 pos = {ss3.Start[0], ss3.Start[1], ss3.Start[2]};
           shower.set_start_point(pos);
           TVector3 posErr = {ss3.StartErr[0], ss3.StartErr[1], ss3.StartErr[2]};
           shower.set_start_point_err(posErr);
           shower.set_dedx(ss3.dEdx);
           shower.set_dedx_err(ss3.dEdxErr);
           shower.set_length(ss3.Len);
           shower.set_open_angle(ss3.OpenAngle);
           shwCol.push_back(shower);
           // make the shower - hit association
           std::vector<unsigned int> shwHits(ss3.Hits.size());
           for(unsigned int iht = 0; iht < ss3.Hits.size(); ++iht) shwHits[iht] = newIndex[ss3.Hits[iht]];
           if(!util::CreateAssn(*this, evt, *shwr_hit_assn, shwCol.size()-1, shwHits.begin(), shwHits.end()))
           {
             throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate hits with Shower";
           } // exception
         } // ss3
       } // slice isl
      
 
       // Add PFParticles now that clsCol is filled
       for(unsigned short isl = 0; isl < nSlices; ++isl) {
         unsigned short slcIndex = 0;
         if(!slices.empty()) {
           for(slcIndex = 0; slcIndex < slices.size(); ++slcIndex) if(slices[slcIndex]->ID() == slcIDs[isl]) break;
           if(slcIndex == slices.size()) continue;
         }
         auto& slc = fTCAlg->GetSlice(isl);
         // See if there was a serious reconstruction failure that made the slice invalid
         if(!slc.isValid) continue;
         // make PFParticles
         for(size_t ipfp = 0; ipfp < slc.pfps.size(); ++ipfp) {
           auto& pfp = slc.pfps[ipfp];
           if(pfp.ID <= 0) continue;
           // parents and daughters are indexed within a slice so find the index offset in pfpCol
           size_t self = pfpCol.size();
           size_t offset = self - ipfp;
           size_t parentIndex = UINT_MAX;
           if(pfp.ParentUID > 0) parentIndex = pfp.ParentUID + offset - 1;
           std::vector<size_t> dtrIndices(pfp.DtrUIDs.size());
           for(unsigned short idtr = 0; idtr < pfp.DtrUIDs.size(); ++idtr) dtrIndices[idtr] = pfp.DtrUIDs[idtr] + offset - 1;
           pfpCol.emplace_back(pfp.PDGCode, self, parentIndex, dtrIndices);
           double sp[] = {pfp.XYZ[0][0],pfp.XYZ[0][1],pfp.XYZ[0][2]};
           double sd[] = {pfp.Dir[0][0],pfp.Dir[0][1],pfp.Dir[0][2]};
           double spe[] = {0.,0.,0.};
           double sde[] = {0.,0.,0.};
           sedCol.emplace_back(sp,sd,spe,sde);
           // PFParticle -> clusters
           std::vector<unsigned int> clsIndices;
           for(auto tuid : pfp.TjUIDs) {
             unsigned int clsIndex = 0;
             for(clsIndex = 0; clsIndex < clsCol.size(); ++clsIndex) if(abs(clsCol[clsIndex].ID()) == tuid) break;
             if(clsIndex == clsCol.size()) {
               std::cout<<"TrajCluster module invalid P"<<pfp.UID<<" -> T"<<tuid<<" -> cluster index \n";
               continue;
             }
             clsIndices.push_back(clsIndex);
           } // tjid
           if(!util::CreateAssn(*this, evt, *pfp_cls_assn, pfpCol.size()-1, clsIndices.begin(), clsIndices.end()))
           {
             throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate clusters with PFParticle";
           } // exception
           // PFParticle -> Vertex
           if(pfp.Vx3ID[0] > 0) {
             for(auto vx3str : vx3StrList) {
               if(vx3str.slIndx != isl) continue;
               if(vx3str.ID != pfp.Vx3ID[0]) continue;
               std::vector<unsigned short> indx(1, vx3str.vxColIndx);
               if(!util::CreateAssn(*this, evt, *pfp_vx3_assn, pfpCol.size() - 1, indx.begin(), indx.end()))
               {
                 throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate PFParticle "<<pfp.UID<<" with Vertex";
               } // exception
               break;
             } // vx3Index
           } // start vertex exists
           // PFParticle -> Seed
           if(!sedCol.empty()) {
             if(!util::CreateAssn(*this, evt, pfpCol, sedCol, *pfp_sed_assn, sedCol.size()-1, sedCol.size(), pfpCol.size()-1))
             {
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate seed with PFParticle";
             } // exception
           } // seeds exist
           // PFParticle -> Slice
           if(!slices.empty()) {
             if(!util::CreateAssn(*this, evt, pfpCol, slices[slcIndex], *slc_pfp_assn))
             {
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate slice with PFParticle";
             } // exception
           } // slices exist
           // PFParticle -> Shower
           if(pfp.PDGCode == 1111) {
             std::vector<unsigned short> shwIndex(1, 0);
             for(auto& ss3 : slc.showers) {
               if(ss3.ID <= 0) continue;
               if(ss3.PFPIndex == ipfp) break;
               ++shwIndex[0];
             } // ss3
             if(shwIndex[0] < shwCol.size()) {
               if(!util::CreateAssn(*this, evt, *pfp_shwr_assn, pfpCol.size()-1, shwIndex.begin(), shwIndex.end()))
               {
                 throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate shower with PFParticle";
               } // exception
             } // valid shwIndex
           } // pfp -> Shower
           // PFParticle cosmic tag
           if(tca::tcc.modes[tca::kTagCosmics]) {
             std::vector<float> tempPt1, tempPt2;
             tempPt1.push_back(-999);
             tempPt1.push_back(-999);
             tempPt1.push_back(-999);
             tempPt2.push_back(-999);
             tempPt2.push_back(-999);
             tempPt2.push_back(-999);
             ctCol.emplace_back(tempPt1, tempPt2, pfp.CosmicScore, anab::CosmicTagID_t::kNotTagged);
             if (!util::CreateAssn(*this, evt, pfpCol, ctCol, *pfp_cos_assn, ctCol.size()-1, ctCol.size())){
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate CosmicTag with PFParticle";
             }
           } // cosmic tag
         } // ipfp
       } // isl
       
       // add the hits that weren't used in any slice to hitCol unless this is a 
       // special debugging mode and would be a waste of time
       if(!slices.empty() && tca::tcc.recoSlice == 0) {
         auto slcHandle = evt.getValidHandle<std::vector<recob::Slice>>(fSliceModuleLabel);
         art::FindManyP<recob::Hit> hitFromSlc(slcHandle, evt, fSliceModuleLabel);
         for(unsigned int allHitsIndex = 0; allHitsIndex < nInputHits; ++allHitsIndex) {
           if(newIndex[allHitsIndex] != UINT_MAX) continue;
           std::vector<unsigned int> oneHit(1, allHitsIndex);
           fTCAlg->MergeTPHits(oneHit, hitCol, newIndex);
           // find out which slice it is in
           bool gotit = false;
           for(size_t isl = 0; isl < slices.size(); ++isl) {
             auto& hit_in_slc = hitFromSlc.at(isl);
             for(auto& hit : hit_in_slc) {
               if(hit.key() != allHitsIndex) continue;
               gotit = true;
               // Slice -> Hit assn
               if(!util::CreateAssn(*this, evt, hitCol, slices[isl], *slc_hit_assn))
               {
                 throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate old Hit with Slice";
               } // exception
               break;
             } // hit
             if(gotit) break;
           } // isl
         } // allHitsIndex
       } // slices exist
       else {
         // no recob::Slices. Just copy the unused hits
         for(unsigned int allHitsIndex = 0; allHitsIndex < nInputHits; ++allHitsIndex) {
           if(newIndex[allHitsIndex] != UINT_MAX) continue;
           std::vector<unsigned int> oneHit(1, allHitsIndex);
           fTCAlg->MergeTPHits(oneHit, hitCol, newIndex);
         } // allHitsIndex
       } // recob::Slices
     } // input hits exist
 
     // www: find spacepoint from hits (inputHits) through SpacePoint->Hit assns, then create association between spacepoint and trajcluster hits (here, hits in hitCol)
     if (nInputHits > 0) {   
       // www: expecting to find spacepoint from hits (inputHits): SpacePoint->Hit assns
       if (fSpacePointModuleLabel != "NA") {
         art::FindManyP<recob::SpacePoint> spFromHit (inputHits, evt, fSpacePointModuleLabel); 
         // www: using sp from hit 
         for (unsigned int allHitsIndex = 0; allHitsIndex < nInputHits; ++allHitsIndex) {
           if (newIndex[allHitsIndex] == UINT_MAX) continue; // skip hits not used in slice (not TrajCluster hits)
           auto & sp_from_hit = spFromHit.at(allHitsIndex);
           for (auto& sp : sp_from_hit) {
             // SpacePoint -> Hit assn
             if(!util::CreateAssn(*this, evt, hitCol, sp, *sp_hit_assn, newIndex[allHitsIndex])) {
               throw art::Exception(art::errors::ProductRegistrationFailure)<<"Failed to associate new Hit with SpacePoint";
             } // exception
           } // sp
         } // allHitsIndex
       } // fSpacePointModuleLabel != "NA"
     } // nInputHits > 0
 
     // clear the alg data structures
     fTCAlg->ClearResults();
 
     // convert vectors to unique_ptrs
     std::unique_ptr<std::vector<recob::Hit> > hcol(new std::vector<recob::Hit>(std::move(hitCol)));
     std::unique_ptr<std::vector<recob::Cluster> > ccol(new std::vector<recob::Cluster>(std::move(clsCol)));
     std::unique_ptr<std::vector<recob::EndPoint2D> > v2col(new std::vector<recob::EndPoint2D>(std::move(vx2Col)));
     std::unique_ptr<std::vector<recob::Vertex> > v3col(new std::vector<recob::Vertex>(std::move(vx3Col)));
     std::unique_ptr<std::vector<recob::PFParticle> > pcol(new std::vector<recob::PFParticle>(std::move(pfpCol)));
     std::unique_ptr<std::vector<recob::Seed> > sdcol(new std::vector<recob::Seed>(std::move(sedCol)));
     std::unique_ptr<std::vector<recob::Shower> > scol(new std::vector<recob::Shower>(std::move(shwCol)));
     std::unique_ptr<std::vector<anab::CosmicTag>> ctgcol(new std::vector<anab::CosmicTag>(std::move(ctCol)));
 
     // move the cluster collection and the associations into the event:
     if(fHitModuleLabel != "NA") {
       recob::HitRefinerAssociator shcol(*this, evt, fHitModuleLabel, fDoWireAssns, fDoRawDigitAssns);
       shcol.use_hits(std::move(hcol));
       shcol.put_into(evt);
     } else {
       recob::HitRefinerAssociator shcol(*this, evt, fSliceModuleLabel, fDoWireAssns, fDoRawDigitAssns);
       shcol.use_hits(std::move(hcol));
       shcol.put_into(evt);
     }
     evt.put(std::move(ccol));
     evt.put(std::move(cls_hit_assn));
     evt.put(std::move(v2col));
     evt.put(std::move(v3col));
     evt.put(std::move(scol));
     evt.put(std::move(sdcol));
     evt.put(std::move(shwr_hit_assn));
     evt.put(std::move(cls_vx2_assn));
     evt.put(std::move(cls_vx3_assn));
     evt.put(std::move(pcol));
     evt.put(std::move(pfp_cls_assn));
     evt.put(std::move(pfp_shwr_assn));
     evt.put(std::move(pfp_vx3_assn));
     evt.put(std::move(pfp_sed_assn));
     evt.put(std::move(slc_cls_assn));
     evt.put(std::move(slc_pfp_assn));
     evt.put(std::move(slc_hit_assn));
     evt.put(std::move(ctgcol));
     evt.put(std::move(pfp_cos_assn));
     evt.put(std::move(sp_hit_assn)); // www: association between sp and hit (trjaclust)
   } // TrajCluster::produce()

void cluster::TrajCluster::reconfigure ( fhicl::ParameterSet const & pset )

Definition at line 125 of file TrajCluster_module.cc.

References fDoRawDigitAssns, fDoWireAssns, fHitModuleLabel, fHitTruthModuleLabel, fSliceModuleLabel, fSpacePointModuleLabel, fTCAlg, fhicl::ParameterSet::get(), and fhicl::ParameterSet::has_key().

Referenced by TrajCluster().

   {
     // this trick avoids double configuration on construction
     if (fTCAlg)
       fTCAlg->reconfigure(pset.get< fhicl::ParameterSet >("TrajClusterAlg"));
     else {
       fTCAlg.reset(new tca::TrajClusterAlg(pset.get< fhicl::ParameterSet >("TrajClusterAlg")));
     }
 
 
     fHitModuleLabel = "NA";
     if(pset.has_key("HitModuleLabel")) fHitModuleLabel = pset.get<art::InputTag>("HitModuleLabel");
     fSliceModuleLabel = "NA";
     if(pset.has_key("SliceModuleLabel")) fSliceModuleLabel = pset.get<art::InputTag>("SliceModuleLabel");
     fHitTruthModuleLabel = "NA";
     if(pset.has_key("HitTruthModuleLabel")) fHitTruthModuleLabel = pset.get<art::InputTag>("HitTruthModuleLabel");
     fSpacePointModuleLabel = "NA";
     if(pset.has_key("SpacePointModuleLabel")) fSpacePointModuleLabel = pset.get<art::InputTag>("SpacePointModuleLabel");
     fDoWireAssns = pset.get<bool>("DoWireAssns",true);
     fDoRawDigitAssns = pset.get<bool>("DoRawDigitAssns",true);
 
   } // TrajCluster::reconfigure()

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }