Inheritance diagram for ems::EMShower3D:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

Public Member Functions
	EMShower3D (fhicl::ParameterSet const &p)

	EMShower3D (EMShower3D const &)=delete

	EMShower3D (EMShower3D &&)=delete

EMShower3D &	operator= (EMShower3D const &)=delete

EMShower3D &	operator= (EMShower3D &&)=delete

void	beginJob () override

void	produce (art::Event &e) override

void	reconfigure (fhicl::ParameterSet const &p)

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 Member Functions
recob::Track	ConvertFrom (pma::Track3D &src)

recob::Track	ConvertFrom2 (pma::Track3D &src)

recob::Cluster	ConvertFrom (const std::vector< art::Ptr< recob::Hit > > &src)

std::vector< ems::DirOfGamma * >	CollectShower2D (art::Event const &e)

void	Link (art::Event const &e, std::vector< ems::DirOfGamma * > input)

void	Reoptimize ()

void	Make3DSeg (art::Event const &e, std::vector< ems::DirOfGamma * > pair)

bool	Validate (art::Event const &e, const pma::Track3D &src, size_t plane)

bool	Validate (std::vector< ems::DirOfGamma * > input, size_t id1, size_t id2, size_t c1, size_t c2, size_t plane3)

void	FilterOutSmallParts (double r2d, const std::vector< art::Ptr< recob::Hit > > &hits_in, std::vector< art::Ptr< recob::Hit > > &hits_out)

bool	GetCloseHits (double r2d, const std::vector< art::Ptr< recob::Hit > > &hits_in, std::vector< size_t > &used, std::vector< art::Ptr< recob::Hit > > &hits_out)

bool	Has (const std::vector< size_t > &v, size_t idx)

size_t	LinkCandidates (art::Event const &e, std::vector< ems::DirOfGamma * > input, size_t id)

Private Attributes
std::vector< IniSeg >	fInisegs

std::vector< IniSeg >	fSeltracks

std::vector< IniSeg >	fPMA3D

std::vector< std::vector< art::Ptr< recob::Hit > > >	fClusters

std::vector< size_t >	fClustersNotUsed

std::vector< size_t >	fTracksNotUsed

unsigned int	fTrkIndex

unsigned int	fClIndex

unsigned int	fIniIndex

std::string	fCluModuleLabel

std::string	fTrk3DModuleLabel

pma::ProjectionMatchingAlg	fProjectionMatchingAlg

calo::CalorimetryAlg	fCalorimetryAlg

art::Handle< std::vector< recob::Cluster > >	fCluListHandle

Detailed Description

Definition at line 67 of file EMShower3D_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

ems::EMShower3D::EMShower3D ( fhicl::ParameterSet const & p )

explicit

Definition at line 137 of file EMShower3D_module.cc.

References reconfigure().

         : fProjectionMatchingAlg(p.get< fhicl::ParameterSet >("ProjectionMatchingAlg")),
                 fCalorimetryAlg(p.get< fhicl::ParameterSet >("CalorimetryAlg"))
 {
         reconfigure(p);
   
         produces< std::vector<recob::Track> >();
         produces< std::vector<recob::Vertex> >();
         produces< std::vector<recob::Cluster> >();
         produces< std::vector<recob::SpacePoint> >();
         produces< art::Assns<recob::Track, recob::Hit> >();
         produces< art::Assns<recob::Track, recob::Vertex> >();
         produces< art::Assns<recob::Cluster, recob::Hit> >();
         produces< art::Assns<recob::Track, recob::SpacePoint> >();
         produces< art::Assns<recob::SpacePoint, recob::Hit> >();
         produces< art::Assns<recob::Track, recob::Cluster> >();
 }

ems::EMShower3D::EMShower3D ( EMShower3D const & )

delete

ems::EMShower3D::EMShower3D ( EMShower3D && )

delete

Member Function Documentation

void ems::EMShower3D::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 155 of file EMShower3D_module.cc.

156 {

157 }

std::vector< ems::DirOfGamma * > ems::EMShower3D::CollectShower2D ( art::Event const & e )

private

Definition at line 594 of file EMShower3D_module.cc.

References fb(), fCluListHandle, fCluModuleLabel, fClusters, FilterOutSmallParts(), art::DataViewImpl::getByLabel(), and ems::DirOfGamma::GetHits2D().

Referenced by produce().

 {
         std::vector< ems::DirOfGamma* > input;
 
         if (e.getByLabel(fCluModuleLabel, fCluListHandle))
         {
                 art::FindManyP< recob::Hit > fb(fCluListHandle, e, fCluModuleLabel);
                 for (unsigned int c = 0; c < fCluListHandle->size(); c++)
                 {
                         std::vector< art::Ptr<recob::Hit> > hitlist;    
                         hitlist = fb.at(c);
 
                         if (hitlist.size() > 5)
                         {
                                 std::vector< art::Ptr<recob::Hit> > hits_out;
                                 FilterOutSmallParts(2.0, hitlist, hits_out);
                                 
                                 if (hits_out.size() > 5)
                                 {
                                         fClusters.push_back(hits_out);
                                         
                                         ems::DirOfGamma * sh = new ems::DirOfGamma(hits_out, 14, c); 
                                         
                                         if (sh->GetHits2D().size())
                                                 input.push_back(sh);                            
                                 }
                         }
                 }
         }
 
         return input;
 }

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};
 }

recob::Track ems::EMShower3D::ConvertFrom ( pma::Track3D & src )

private

Definition at line 174 of file EMShower3D_module.cc.

References pma::Track3D::back(), recob::tracking::convertCollToPoint(), recob::tracking::convertCollToVector(), pma::Hit3D::Cryo(), calo::CalorimetryAlg::dEdx_AREA(), fCalorimetryAlg, fIniIndex, fProjectionMatchingAlg, pma::Track3D::front(), pma::Hit3D::Point3D(), pma::ProjectionMatchingAlg::selectInitialHits(), pma::Track3D::size(), and pma::Hit3D::TPC().

Referenced by produce().

 {
         auto const* geom = lar::providerFrom<geo::Geometry>();
         auto const* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
 
         double avdrift = (src.front()->Point3D().X() + src.back()->Point3D().X()) * 0.5;
         unsigned int nplanes = geom->Nplanes(src.front()->TPC(), src.front()->Cryo());
         size_t nusedhitsmax = 0; int bestplane = -1;
         for (unsigned int p = 0; p < nplanes; ++p)
         {               
                 unsigned int nusedP = 0;
                 fProjectionMatchingAlg.selectInitialHits(src, p, &nusedP);
         
                 if (nusedP > nusedhitsmax)
                 {
                         nusedhitsmax = nusedP;
                         bestplane = int(p);
                 }
         }
 
         std::vector< std::vector< double > > vdedx;
         std::vector< double > dedx;
 
         for (unsigned int p = 0; p < nplanes; ++p)
         {
                 unsigned int nusedP = 0;
                 double dqdxplane = fProjectionMatchingAlg.selectInitialHits(src, p, &nusedP);
                 double timeP = detprop->ConvertXToTicks(avdrift, 
                                                                                 p,
                                                                                 src.front()->TPC(),
                                                                                 src.front()->Cryo());
                 double dEdxplane = fCalorimetryAlg.dEdx_AREA(dqdxplane, timeP, p);
                 dedx.push_back(dEdxplane);
                 if (int(p) == bestplane) dedx.push_back(1);
                 else dedx.push_back(0);
                 vdedx.push_back(dedx);
         }
 
         std::vector< TVector3 > xyz, dircos;
 
         for (size_t i = 0; i < src.size(); i++)
         {
                 xyz.push_back(src[i]->Point3D());
 
                 if (i < src.size() - 1)
                 {
                         TVector3 dc(src[i + 1]->Point3D());
                         dc -= src[i]->Point3D();
                         dc *= 1.0 / dc.Mag();
                         dircos.push_back(dc);
                 }
                 else dircos.push_back(dircos.back());
         }
 
         return recob::Track(recob::TrackTrajectory(recob::tracking::convertCollToPoint(xyz),
                                                    recob::tracking::convertCollToVector(dircos),
                                                    recob::Track::Flags_t(xyz.size()), false),
                             0, -1., 0, recob::tracking::SMatrixSym55(), recob::tracking::SMatrixSym55(), fIniIndex);
 
 }

recob::Cluster ems::EMShower3D::ConvertFrom ( const std::vector< art::Ptr< recob::Hit > > & src )

private

Definition at line 168 of file EMShower3D_module.cc.

References fClIndex.

 {
         
         return recob::Cluster(0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, src.size(), 0.0F, 0.0F, fClIndex,  src[0]->View(), src[0]->WireID().planeID());
 }

recob::Track ems::EMShower3D::ConvertFrom2 ( pma::Track3D & src )

private

Definition at line 235 of file EMShower3D_module.cc.

References pma::Track3D::back(), recob::tracking::convertCollToPoint(), recob::tracking::convertCollToVector(), pma::Hit3D::Cryo(), calo::CalorimetryAlg::dEdx_AREA(), fCalorimetryAlg, fIniIndex, fProjectionMatchingAlg, pma::Track3D::front(), pma::Hit3D::Point3D(), pma::ProjectionMatchingAlg::selectInitialHits(), pma::Track3D::size(), and pma::Hit3D::TPC().

Referenced by produce().

 {
 
         auto const* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
         auto const* geom = lar::providerFrom<geo::Geometry>();
 
         double avdrift = (src.front()->Point3D().X() + src.back()->Point3D().X()) * 0.5;
         unsigned int nplanes = geom->Nplanes(src.front()->TPC(), src.front()->Cryo());
         size_t nusedhitsmax = 0; int bestplane = -1;
         for (unsigned int p = 0; p < nplanes; ++p)
         {               
                 unsigned int nusedP = 0;
                 fProjectionMatchingAlg.selectInitialHits(src, p, &nusedP);
         
                 if (nusedP > nusedhitsmax)
                 {
                         nusedhitsmax = nusedP;
                         bestplane = int(p);
                 }
         }
 
         std::vector< std::vector< double > > vdedx;
         std::vector< double > dedx;
 
         for (unsigned int p = 0; p < nplanes; ++p)
         {
                 unsigned int nusedP = 0;
                 double dqdxplane = fProjectionMatchingAlg.selectInitialHits(src, p, &nusedP);
                 double timeP = detprop->ConvertXToTicks(avdrift, 
                                                                                 p,
                                                                                 src.front()->TPC(),
                                                                                 src.front()->Cryo());
                 double dEdxplane = fCalorimetryAlg.dEdx_AREA(dqdxplane, timeP, p);
                 dedx.push_back(dEdxplane);
                 if (int(p) == bestplane) dedx.push_back(1);
                 else dedx.push_back(0);
                 vdedx.push_back(dedx);
         }
 
         std::vector< TVector3 > xyz, dircos;
 
         for (size_t i = 0; i < src.size(); i++)
         {
                 xyz.push_back(src[i]->Point3D());
 
                 if (i < src.size() - 1)
                 {
                         TVector3 dc(src[i + 1]->Point3D());
                         dc -= src[i]->Point3D();
                         dc *= 1.0 / dc.Mag();
                         dircos.push_back(dc);
                 }
                 else dircos.push_back(dircos.back());
         }
 
         return recob::Track(recob::TrackTrajectory(recob::tracking::convertCollToPoint(xyz),
                                                    recob::tracking::convertCollToVector(dircos),
                                                    recob::Track::Flags_t(xyz.size()), false),
                             0, -1., 0, recob::tracking::SMatrixSym55(), recob::tracking::SMatrixSym55(), fIniIndex);
 }

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 ems::EMShower3D::FilterOutSmallParts	(	double	r2d,
		const std::vector< art::Ptr< recob::Hit > > &	hits_in,
		std::vector< art::Ptr< recob::Hit > > &	hits_out
	)

private

Definition at line 962 of file EMShower3D_module.cc.

References DEFINE_ART_MODULE, and GetCloseHits().

Referenced by CollectShower2D().

 {
         size_t min_size = hits_in.size() / 5;
         if (min_size < 3) min_size = 3;
 
         std::vector<size_t> used;
         std::vector< art::Ptr<recob::Hit> > close_hits;
         
         while (GetCloseHits(r2d, hits_in, used, close_hits))
         {
                 if (close_hits.size() > min_size)
                         for (auto h : close_hits) hits_out.push_back(h);
         }
 }

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();
 }

bool ems::EMShower3D::GetCloseHits	(	double	r2d,
		const std::vector< art::Ptr< recob::Hit > > &	hits_in,
		std::vector< size_t > &	used,
		std::vector< art::Ptr< recob::Hit > > &	hits_out
	)

private

Definition at line 896 of file EMShower3D_module.cc.

References geo::CryostatID::Cryostat, pma::Dist2(), Has(), recob::Hit::PeakTime(), geo::PlaneID::Plane, geo::TPCID::TPC, geo::WireID::Wire, pma::WireDriftToCm(), and recob::Hit::WireID().

Referenced by FilterOutSmallParts().

 {
         
         hits_out.clear();
 
         const double gapMargin = 5.0; // can be changed to f(id_tpc1, id_tpc2)
         size_t idx = 0;
 
         while ((idx < hits_in.size()) && Has(used, idx)) idx++;
 
         if (idx < hits_in.size())
         {               
                 hits_out.push_back(hits_in[idx]);
                 used.push_back(idx);
                 
 
                 double r2d2 = r2d*r2d;
                 double gapMargin2 = sqrt(2 * gapMargin*gapMargin);
                 gapMargin2 = (gapMargin2 + r2d)*(gapMargin2 + r2d);
 
                 bool collect = true;
                 while (collect)
                 {
                         collect = false;
                         for (size_t i = 0; i < hits_in.size(); i++)
                                 if (!Has(used, i))
                                 {
                                         art::Ptr<recob::Hit> hi = hits_in[i];
                                         TVector2 hi_cm = pma::WireDriftToCm(hi->WireID().Wire, hi->PeakTime(), hi->WireID().Plane, hi->WireID().TPC, hi->WireID().Cryostat);
 
                                         bool accept = false;
                                         //for (auto const& ho : hits_out)
                                         for (size_t idx_o = 0; idx_o < hits_out.size(); idx_o++)                                        
                                         {
                                                 art::Ptr<recob::Hit> ho = hits_out[idx_o];
 
                                                 double d2 = pma::Dist2(
                                                         hi_cm, pma::WireDriftToCm(ho->WireID().Wire, ho->PeakTime(), ho->WireID().Plane, ho->WireID().TPC, ho->WireID().Cryostat));
                                                 
                                                 if (hi->WireID().TPC == ho->WireID().TPC)
                                                 {
                                                         if (d2 < r2d2) { accept = true; break; }
                                                 }
                                                 else
                                                 {
                                                         if (d2 < gapMargin2) { accept = true; break; }
                                                 }
                                         }
                                         if (accept)
                                         {
                                                 collect = true;
                                                 hits_out.push_back(hi);
                                                 used.push_back(i);
                                         }
                                 }
                 }
                 return true;
         }
         else return false;
 }

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();
   }

bool ems::EMShower3D::Has	(	const std::vector< size_t > &	v,
		size_t	idx
	)

private

Definition at line 890 of file EMShower3D_module.cc.

Referenced by GetCloseHits().

 {
     for (auto c : v) if (c == idx) return true;
     return false;
 }

void ems::EMShower3D::Link	(	art::Event const &	e,
		std::vector< ems::DirOfGamma * >	input
	)

private

Definition at line 627 of file EMShower3D_module.cc.

References LinkCandidates(), Make3DSeg(), t1, and t2.

Referenced by produce().

 {
         auto const* detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
 
         std::vector< std::vector< size_t > > saveids;
         std::vector< size_t > saveidsnotusedcls;
         size_t i = 0;
         
         while (i < input.size())        
         {
                 if (!input[i]->GetCandidates().size()){i++; continue;}
 
                 double mindist = 1.0; // cm     
                 std::vector< ems::DirOfGamma* > pairs; 
 
                 size_t startview = input[i]->GetFirstHit()->WireID().Plane;
                 size_t tpc = input[i]->GetFirstHit()->WireID().TPC;
                 size_t cryo = input[i]->GetFirstHit()->WireID().Cryostat;
 
                 float t1 = detprop->ConvertTicksToX(input[i]->GetFirstHit()->PeakTime(), startview, tpc, cryo);
                 
                 unsigned int idsave = 0; 
                 for (unsigned int j = 0; j < input.size(); j++)
                 {
                         if (!input[j]->GetCandidates().size()) continue;
 
                         size_t secondview = input[j]->GetFirstHit()->WireID().Plane;
                         size_t tpc_j = input[j]->GetFirstHit()->WireID().TPC;
                         size_t cryo_j = input[j]->GetFirstHit()->WireID().Cryostat;
                 
                         if ((i != j) && (secondview != startview) && (tpc == tpc_j) && (cryo == cryo_j))
                         {                               
                                 float t2 = detprop->ConvertTicksToX(input[j]->GetFirstHit()->PeakTime(), secondview, tpc_j, cryo_j);
                                 float dist = fabs(t2 - t1);
                         
                                 if (dist < mindist)
                                 {
                                         mindist = dist;
                                         pairs.clear();
                                         pairs.push_back(input[i]); pairs.push_back(input[j]); 
                                         idsave = j;
                                 }
                         }
                 
                 }
 
                 bool exist = false;
                 for (unsigned int v = 0; v < saveids.size(); v++)
                                 if ((saveids[v][0] == i) || (saveids[v][0] == idsave))
                                         if ((saveids[v][1] == i) || (saveids[v][1] == idsave)) 
                                                 exist = true;
 
 
                 if (pairs.size())
                 {
                         if (!exist) Make3DSeg(e, pairs);
 
                         std::vector< size_t > ids;
                         ids.push_back(i); ids.push_back(idsave);
                         saveids.push_back(ids);
                 }
                 else
                 {
                         saveidsnotusedcls.push_back(i);
                 }
 
                 i++;
         }
 
         i = 0;
         while(i < saveidsnotusedcls.size())
         {
                 LinkCandidates(e, input, i);
                 i++;
         }
 }

size_t ems::EMShower3D::LinkCandidates	(	art::Event const &	e,
		std::vector< ems::DirOfGamma * >	input,
		size_t	id
	)

private

Definition at line 704 of file EMShower3D_module.cc.

References geo::GeometryCore::Cryostat(), Make3DSeg(), geo::CryostatGeo::MaxPlanes(), t1, t2, and Validate().

Referenced by Link().

 {
         art::ServiceHandle<geo::Geometry> geom;
 
         size_t index = id; bool found = false;
 
         if (input[id]->GetCandidates().size() < 2) { return index; }
 
         double mindist = 3.0; // cm     
         std::vector< ems::DirOfGamma* > pairs; 
 
         size_t idcsave = 0; size_t idcjsave = 0;
         size_t c = 0; size_t idsave = 0; 
         while (c < input[id]->GetCandidates().size())   
         {
 
                 size_t startview = input[id]->GetCandidates()[c].GetPlane();
                 size_t tpc = input[id]->GetCandidates()[c].GetTPC();   
                 size_t cryo = input[id]->GetCandidates()[c].GetCryo();
 
                 float t1 = input[id]->GetCandidates()[c].GetPosition().Y(); // y --> drift in 2D space.
  
                 // loop over 2D showers
                 for (size_t j = 0; j < input.size(); ++j)
                 {
                         if (!input[j]->GetCandidates().size()) continue;
                         if (j == id) continue;
                         
                         // loop over candidates
                         for (size_t cj = 0; cj < input[j]->GetCandidates().size(); ++cj)
                         {
                                 size_t secondview = input[j]->GetCandidates()[cj].GetPlane();
                                 size_t tpc_j = input[j]->GetCandidates()[cj].GetTPC();
                                 size_t cryo_j = input[j]->GetCandidates()[cj].GetCryo();
 
                                 size_t thirdview = startview;
                                 
                                 const geo::CryostatGeo& cryostat = geom->Cryostat(cryo);
                                 for (size_t p = 0; p < cryostat.MaxPlanes(); p++)
                                         if ((p == startview) || (p == secondview)) {continue;}
                                         else {thirdview = p; break;}
                                 
                 
                                 if ((startview != secondview) && (tpc == tpc_j) && (cryo == cryo_j))// && Validate(input, id, cj, thirdview))
                                 {       
                                         float t2 = input[j]->GetCandidates()[cj].GetPosition().Y();
                                         float dist = fabs(t2 - t1);
                                 
                                         if ((dist < mindist) && Validate(input, id, j, c, cj, thirdview))
                                         { 
                                                 mindist = dist;
                                                 pairs.clear();
                                                 pairs.push_back(input[id]); pairs.push_back(input[j]);
                                                 idsave = j; index = j;
                                                 idcsave = c; idcjsave = cj;
                                                 found = true;
                                         }
                                 }
                         }
                 }
 
                 c++;
         }
 
         if (found && pairs.size())
         {
                 input[id]->SetIdCandidate(idcsave);     
                 input[idsave]->SetIdCandidate(idcjsave);
                 Make3DSeg(e, pairs);
         }
 
         return index;
 }

void ems::EMShower3D::Make3DSeg	(	art::Event const &	e,
		std::vector< ems::DirOfGamma * >	pair
	)

private

Definition at line 778 of file EMShower3D_module.cc.

References pma::Track3D::back(), pma::ProjectionMatchingAlg::buildSegment(), fInisegs, pma::Track3D::Flip(), fProjectionMatchingAlg, pma::Hit3D::Hit2DPtr(), IniSeg::hits1, IniSeg::hits2, IniSeg::idcl1, IniSeg::idcl2, IniSeg::track, IniSeg::view1, and IniSeg::view2.

Referenced by Link(), and LinkCandidates().

 {       
         if (pair.size() < 2) return;
 
         // to build a track correctly 2d hits must belong to the same tpc       
         size_t tpc1 = pair[0]->GetFirstHit()->WireID().TPC;  
         size_t tpc2 = pair[1]->GetFirstHit()->WireID().TPC; 
 
         std::vector< art::Ptr< recob::Hit > > vec1 = pair[0]->GetIniHits();
         std::vector< art::Ptr< recob::Hit > > vec2 = pair[1]->GetIniHits();
 
         if ((vec1.size() < 3) && (vec2.size() < 3)) return;
 
         std::vector< art::Ptr<recob::Hit> > hitscl1uniquetpc;
         std::vector< art::Ptr<recob::Hit> > hitscl2uniquetpc;
 
         if (tpc1 == tpc2)
                 for (size_t i = 0; i < vec1.size(); ++i)
                         for (size_t j = 0; j < vec2.size(); ++j)
                                         if ((vec1[i]->WireID().TPC ==  vec2[j]->WireID().TPC) && (tpc1 == vec2[j]->WireID().TPC))
                                         {
                                                 hitscl1uniquetpc.push_back(vec1[i]);
                                                 hitscl2uniquetpc.push_back(vec2[j]);
                                         }
 
         if ((hitscl1uniquetpc.size() > 2) && (hitscl2uniquetpc.size() > 2))
         {
                 pma::Track3D* trk = fProjectionMatchingAlg.buildSegment(hitscl1uniquetpc, hitscl2uniquetpc);
 
                 //pma::Track3D* trk = fProjectionMatchingAlg.buildSegment(vec1, vec2);
 
                 // turn the track that front is at vertex - easier to handle associations.
                 if ((trk->back()->Hit2DPtr() == pair[0]->GetFirstHit()) 
                         || (trk->back()->Hit2DPtr() == pair[1]->GetFirstHit())) trk->Flip();    
 
         
                 IniSeg initrack;
                 initrack.idcl1 = pair[0]->GetIdCl();
                 initrack.view1 = pair[0]->GetFirstHit()->WireID().Plane;
                 initrack.hits1 = hitscl1uniquetpc;
                 initrack.idcl2 = pair[1]->GetIdCl();
                 initrack.view2 = pair[1]->GetFirstHit()->WireID().Plane;
                 initrack.hits2 = hitscl2uniquetpc;
                 initrack.track = trk;   
                 
                 fInisegs.push_back(initrack);
 
                 
         }
 }

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;
 }

EMShower3D& ems::EMShower3D::operator= ( EMShower3D const & )

delete

EMShower3D& ems::EMShower3D::operator= ( EMShower3D && )

delete

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 ems::EMShower3D::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 296 of file EMShower3D_module.cc.

References art::PtrVector< T >::clear(), CollectShower2D(), ConvertFrom(), ConvertFrom2(), util::CreateAssn(), fb(), fClIndex, fCluListHandle, fCluModuleLabel, fClusters, fClustersNotUsed, fIniIndex, fInisegs, fPMA3D, fSeltracks, fTrkIndex, art::DataViewImpl::getByLabel(), pma::Hit3D::Hit2DPtr(), Link(), pma::Hit3D::Point3D(), art::PtrVector< T >::push_back(), art::Event::put(), Reoptimize(), art::PtrVector< T >::size(), and track.

 {
         art::ServiceHandle<geo::Geometry> geom;
         fSeltracks.clear();
         fInisegs.clear();
         fClusters.clear();
         fPMA3D.clear();
         fClustersNotUsed.clear();
 
         std::unique_ptr< std::vector< recob::Track > > tracks(new std::vector< recob::Track >);
         std::unique_ptr< std::vector< recob::Vertex > > vertices(new std::vector< recob::Vertex >);
         std::unique_ptr< std::vector< recob::Cluster > > clusters(new std::vector< recob::Cluster >);
         std::unique_ptr< std::vector< recob::SpacePoint > > allsp(new std::vector< recob::SpacePoint >);
 
         std::unique_ptr< art::Assns< recob::Track, recob::Hit > > trk2hit(new art::Assns< recob::Track, recob::Hit >);
         std::unique_ptr< art::Assns< recob::Track, recob::Vertex > > trk2vtx(new art::Assns< recob::Track, recob::Vertex >);
         std::unique_ptr< art::Assns< recob::Cluster, recob::Hit > > cl2hit(new art::Assns< recob::Cluster, recob::Hit >);
         std::unique_ptr< art::Assns< recob::Track, recob::Cluster > > trk2cl(new art::Assns< recob::Track, recob::Cluster >);
         std::unique_ptr< art::Assns< recob::Track, recob::SpacePoint > > trk2sp(new art::Assns< recob::Track, recob::SpacePoint >);
         std::unique_ptr< art::Assns< recob::SpacePoint, recob::Hit > > sp2hit(new art::Assns< recob::SpacePoint, recob::Hit >);
 
 
   if (e.getByLabel(fCluModuleLabel, fCluListHandle))
         {
                 fClustersNotUsed.clear();
                 fInisegs.clear();
                 art::FindManyP< recob::Hit > fb(fCluListHandle, e, fCluModuleLabel);
         
                 for (size_t id = 0; id < fCluListHandle->size(); id++)
                 {
                                 std::vector< art::Ptr<recob::Hit> > hitlist;    
                                 hitlist = fb.at(id);
 
                                 if (hitlist.size() > 5) 
                                                 fClustersNotUsed.push_back(id);
                 }
         
                 std::vector< ems::DirOfGamma* > showernviews = CollectShower2D(e);      
                 
                 Link(e, showernviews);  
 
                 while (fInisegs.size())
                 {       
                         fSeltracks.push_back(fInisegs[0]);
                         fInisegs.erase(fInisegs.begin() + 0);
                 }
 
                 Reoptimize();
         
                 // conversion from pma track to recob::track
 
                 size_t spStart = 0, spEnd = 0;
                 double sp_pos[3], sp_err[6], vtx_pos[3];
                 for (size_t i = 0; i < 6; i++) sp_err[i] = 1.0;
 
                 fTrkIndex = 0;
                 
                 for (auto const trk : fSeltracks) 
                 {
                         tracks->push_back(ConvertFrom(*(trk.track)));
 
                         vtx_pos[0] = trk.track->front()->Point3D().X();
                         vtx_pos[1] = trk.track->front()->Point3D().Y();
                         vtx_pos[2] = trk.track->front()->Point3D().Z();
                         vertices->push_back(recob::Vertex(vtx_pos, fTrkIndex));
 
                         fTrkIndex++;
 
                         std::vector< art::Ptr< recob::Cluster > > cl2d; 
                         cl2d.push_back( art::Ptr< recob::Cluster >(fCluListHandle, trk.idcl1) );
                         cl2d.push_back( art::Ptr< recob::Cluster >(fCluListHandle, trk.idcl2) );
 
                         std::vector< art::Ptr< recob::Hit > > hits2d; 
                         art::PtrVector< recob::Hit > sp_hits;
 
                         spStart = allsp->size();
                         for (int h = trk.track->size() - 1; h >= 0; h--)
                         {
                                 pma::Hit3D* h3d = (*trk.track)[h];
                                 hits2d.push_back(h3d->Hit2DPtr());
 
                                 if ((h == 0) ||
                                       (sp_pos[0] != h3d->Point3D().X()) ||
                                       (sp_pos[1] != h3d->Point3D().Y()) ||
                                       (sp_pos[2] != h3d->Point3D().Z()))
                                 {
                                         if (sp_hits.size()) // hits assigned to the previous sp
                                         {
                                                 util::CreateAssn(*this, e, *allsp, sp_hits, *sp2hit);
                                                 sp_hits.clear();
                                         }
                                         sp_pos[0] = h3d->Point3D().X();
                                         sp_pos[1] = h3d->Point3D().Y();
                                         sp_pos[2] = h3d->Point3D().Z();
                                         allsp->push_back(recob::SpacePoint(sp_pos, sp_err, 1.0));
                                 }
                                 sp_hits.push_back(h3d->Hit2DPtr());
                         }
                         if (sp_hits.size()) // hits assigned to the last sp
                         {
                                 util::CreateAssn(*this, e, *allsp, sp_hits, *sp2hit);
                         }
                         spEnd = allsp->size();
 
                         if (vertices->size())
                         {
                                 size_t vtx_idx = (size_t)(vertices->size() - 1);
                                 util::CreateAssn(*this, e, *tracks, *vertices, *trk2vtx, vtx_idx, vtx_idx + 1);
                         }
 
                         if (cl2d.size())
                         {
                                 util::CreateAssn(*this, e, *tracks, cl2d, *trk2cl); 
                         }
 
                         if (hits2d.size())
                         {
                                 util::CreateAssn(*this, e, *tracks, *allsp, *trk2sp, spStart, spEnd);
                                 util::CreateAssn(*this, e, *tracks, hits2d, *trk2hit); 
                         }
                 }
 
                 fIniIndex = fTrkIndex + 1;
                 for (auto const trk : fPMA3D) 
                 {
                         tracks->push_back(ConvertFrom2(*(trk.track)));
 
                         fIniIndex++;
 
                         std::vector< art::Ptr< recob::Cluster > > cl2d; 
                         cl2d.push_back( art::Ptr< recob::Cluster >(fCluListHandle, trk.idcl1) );
                         cl2d.push_back( art::Ptr< recob::Cluster >(fCluListHandle, trk.idcl2) );
 
                         std::vector< art::Ptr< recob::Hit > > hits2d; 
                         art::PtrVector< recob::Hit > sp_hits;
 
                         spStart = allsp->size();
                         for (int h = trk.track->size() - 1; h >= 0; h--)
                         {
                                 pma::Hit3D* h3d = (*trk.track)[h];
                                 hits2d.push_back(h3d->Hit2DPtr());
 
                                 if ((h == 0) ||
                                       (sp_pos[0] != h3d->Point3D().X()) ||
                                       (sp_pos[1] != h3d->Point3D().Y()) ||
                                       (sp_pos[2] != h3d->Point3D().Z()))
                                 {
                                         if (sp_hits.size()) // hits assigned to the previous sp
                                         {
                                                 util::CreateAssn(*this, e, *allsp, sp_hits, *sp2hit);
                                                 sp_hits.clear();
                                         }
                                         sp_pos[0] = h3d->Point3D().X();
                                         sp_pos[1] = h3d->Point3D().Y();
                                         sp_pos[2] = h3d->Point3D().Z();
                                         allsp->push_back(recob::SpacePoint(sp_pos, sp_err, 1.0));
                                 }
                                 sp_hits.push_back(h3d->Hit2DPtr());
                         }
                         if (sp_hits.size()) // hits assigned to the last sp
                         {
                                 util::CreateAssn(*this, e, *allsp, sp_hits, *sp2hit);
                         }
                         spEnd = allsp->size();
 
 
                         if (cl2d.size())
                         {
                                 util::CreateAssn(*this, e, *tracks, cl2d, *trk2cl); 
                         }
 
                         if (hits2d.size())
                         {
                                 util::CreateAssn(*this, e, *tracks, *allsp, *trk2sp, spStart, spEnd);
                                 util::CreateAssn(*this, e, *tracks, hits2d, *trk2hit); 
                         }
                 }
 
                 // create cluster from hits, which were an input to find initial part of the cascade.
                 fClIndex = 0;
                 for (auto const& cl : fClusters) 
                         if (cl.size())
                         {
                                 clusters->push_back(ConvertFrom(cl)); 
                                 fClIndex++;
 
                                 util::CreateAssn(*this, e, *clusters, cl, *cl2hit); 
                         }
 
 
                 for (unsigned int i = 0; i < showernviews.size(); i++) 
                                 delete showernviews[i];
                 
                 for (unsigned int i = 0; i < fSeltracks.size(); i++)
                                 delete fSeltracks[i].track; 
 
                 for (unsigned int i = 0; i < fInisegs.size(); i++)
                                 delete fInisegs[i].track; 
 
                 for (unsigned int i = 0; i < fPMA3D.size(); i++)
                                 delete fPMA3D[i].track;  
 
 }
 
                 e.put(std::move(tracks));
                 e.put(std::move(vertices));
                 e.put(std::move(clusters));
                 e.put(std::move(allsp));
 
                 e.put(std::move(trk2hit));
                 e.put(std::move(trk2vtx));
                 e.put(std::move(cl2hit));
                 e.put(std::move(trk2cl));
                 e.put(std::move(trk2sp));
                 e.put(std::move(sp2hit));
         
 }

void ems::EMShower3D::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 159 of file EMShower3D_module.cc.

References fCluModuleLabel, fTrk3DModuleLabel, and fhicl::ParameterSet::get().

Referenced by EMShower3D().

 {
         fCluModuleLabel = p.get< std::string >("ClustersModuleLabel");
         //fProjectionMatchingAlg.reconfigure(p.get< fhicl::ParameterSet >("ProjectionMatchingAlg")); // use constructor-time config only
         fTrk3DModuleLabel = p.get< std::string >("Trk3DModuleLabel");
         
   return;
 }

void ems::EMShower3D::Reoptimize ( )

private

Definition at line 514 of file EMShower3D_module.cc.

References pma::Track3D::back(), pma::ProjectionMatchingAlg::buildSegment(), pma::Dist2(), pma::Track3D::Flip(), fProjectionMatchingAlg, pma::Track3D::front(), fSeltracks, hits(), IniSeg::hits1, IniSeg::hits2, IniSeg::hits3, IniSeg::idcl1, IniSeg::idcl2, IniSeg::idcl3, pma::Hit3D::Point3D(), track, IniSeg::track, IniSeg::view1, IniSeg::view2, and IniSeg::view3.

Referenced by produce().

 {
         if (!fSeltracks.size()) return;
         const float min_dist = 3.0F;
         size_t ta = 0; 
         while (ta < (fSeltracks.size() - 1))
         {       
                 size_t tb = ta + 1;
                 bool found = false;
                 while (tb < fSeltracks.size())
                 {
                         if (ta == tb) {tb++; continue;}
         
                         TVector3 p1 = fSeltracks[ta].track->front()->Point3D();
                         TVector3 p2 = fSeltracks[tb].track->front()->Point3D();
                         float dist = std::sqrt(pma::Dist2(p1, p2));
 
                         if (dist < min_dist)
                                 if ((fSeltracks[ta].idcl1 == fSeltracks[tb].idcl1) || (fSeltracks[ta].idcl1 == fSeltracks[tb].idcl2) ||
                                     (fSeltracks[ta].idcl2 == fSeltracks[tb].idcl1) || (fSeltracks[ta].idcl2 == fSeltracks[tb].idcl2))
                                         {
                                                 found = true;
                                                 size_t view3 = fSeltracks[ta].view1; size_t idcl3 = fSeltracks[ta].idcl1;
                                                 std::vector< art::Ptr< recob::Hit > > hits3 = fSeltracks[ta].hits1;
                                                 std::vector< art::Ptr< recob::Hit > > hits = fSeltracks[ta].hits1;
                                                 for (size_t h = 0; h < fSeltracks[ta].hits2.size(); ++h)
                                                         hits.push_back(fSeltracks[ta].hits2[h]);
 
                                                 if ((fSeltracks[tb].view1 != fSeltracks[ta].view1) && (fSeltracks[tb].view1 != fSeltracks[ta].view2))
                                                 {
                                                         view3 = fSeltracks[tb].view1;
                                                         for (size_t h = 0; h < fSeltracks[tb].hits1.size(); ++h)        
                                                                 hits.push_back(fSeltracks[tb].hits1[h]); 
                                                 }       
                                                 if ((fSeltracks[tb].view2 != fSeltracks[ta].view1) && (fSeltracks[tb].view2 != fSeltracks[ta].view2))
                                                 {
                                                         view3 = fSeltracks[tb].view2;
                                                         for (size_t h = 0; h < fSeltracks[tb].hits2.size(); ++h)
                                                                 hits.push_back(fSeltracks[tb].hits2[h]);
                                                 }
 
                                                 
                                                 if ((view3 == fSeltracks[ta].view1) || (view3 == fSeltracks[ta].view2))
                                                 {
                                                         delete fSeltracks[ta].track;
                                                         fSeltracks.erase(fSeltracks.begin() + ta);
                                                 }
                                                 else
                                                 {
                                                         pma::Track3D* track = fProjectionMatchingAlg.buildSegment(hits);
 
                                                         if (pma::Dist2(track->back()->Point3D(), fSeltracks[ta].track->front()->Point3D()) < 
                                                             pma::Dist2(track->front()->Point3D(), fSeltracks[ta].track->front()->Point3D()))
                                                                         track->Flip();
 
                                                         IniSeg initrack;
                                                         initrack.idcl1 = fSeltracks[ta].idcl1; initrack.idcl3 = idcl3;
                                                         initrack.view1 = fSeltracks[ta].view1; initrack.view3 = view3;
                                                         initrack.hits1 = fSeltracks[ta].hits1; initrack.hits3 = hits3; 
                                                         initrack.idcl2 = fSeltracks[ta].idcl2;
                                                         initrack.view2 = fSeltracks[ta].view2;
                                                         initrack.hits2 = fSeltracks[ta].hits2;
                                                         initrack.track = track; 
                 
                                                         
                                                         delete fSeltracks[tb].track; delete fSeltracks[ta].track;
                                                         fSeltracks.erase(fSeltracks.begin() + tb); fSeltracks.erase(fSeltracks.begin() + ta);
                                                         fSeltracks.push_back(initrack);
                                                         
                                                 }
                                         } 
 
                         if (found) break;
                         tb++;
                 }
 
                 if (!found) ta++;
         }
 }

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('=');
 }

bool ems::EMShower3D::Validate	(	art::Event const &	e,
		const pma::Track3D &	src,
		size_t	plane
	)

private

Definition at line 872 of file EMShower3D_module.cc.

References fCluListHandle, fCluModuleLabel, fClustersNotUsed, fProjectionMatchingAlg, hits(), and pma::ProjectionMatchingAlg::validate().

Referenced by LinkCandidates().

 {
         bool result = false;
 
         art::FindManyP< recob::Hit > fbc(fCluListHandle, e, fCluModuleLabel);           
         std::vector< art::Ptr<recob::Hit> > hitscl;
         for (size_t id = 0; id < fClustersNotUsed.size(); id++)
         {
                 std::vector< art::Ptr<recob::Hit> > hits = fbc.at(fClustersNotUsed[id]);
                 for (size_t i = 0; i < hits.size(); i++) hitscl.push_back(hits[i]);
         }
         
 
         if (fProjectionMatchingAlg.validate(src, hitscl) > 0.2) result = true;
                 
         return result;
 }

bool ems::EMShower3D::Validate	(	std::vector< ems::DirOfGamma * >	input,
		size_t	id1,
		size_t	id2,
		size_t	c1,
		size_t	c2,
		size_t	plane3
	)

private

Definition at line 829 of file EMShower3D_module.cc.

References pma::Track3D::back(), pma::Track3D::BackCryo(), pma::Track3D::BackTPC(), pma::ProjectionMatchingAlg::buildSegment(), c1, c2, pma::Dist2(), fProjectionMatchingAlg, pma::Track3D::front(), pma::Track3D::FrontCryo(), pma::Track3D::FrontTPC(), pma::GetProjectionToPlane(), pma::Hit3D::Point3D(), and track.

 {
         bool result = false;
         if (id1 == id2) return false;
 
         std::vector< art::Ptr< recob::Hit > > vec1 = input[id1]->GetCandidates()[c1].GetIniHits();
         std::vector< art::Ptr< recob::Hit > > vec2 = input[id2]->GetCandidates()[c2].GetIniHits();
 
         if ((vec1.size() < 3) || (vec2.size() < 3)) return false;
 
         std::vector< art::Ptr<recob::Hit> > hitscl1uniquetpc;
         std::vector< art::Ptr<recob::Hit> > hitscl2uniquetpc;
 
         size_t tpc = vec1[0]->WireID().TPC;
         for (size_t i = 0; i < vec1.size(); ++i)
                 for (size_t j = 0; j < vec2.size(); ++j)
                         if ((vec1[i]->WireID().TPC ==  tpc) && (vec2[j]->WireID().TPC == tpc))
                         {
                                 hitscl1uniquetpc.push_back(vec1[i]);
                                 hitscl2uniquetpc.push_back(vec2[j]);
                         }
         
         if ((hitscl1uniquetpc.size() < 3) || (hitscl2uniquetpc.size() < 3)) return false;
 
         pma::Track3D* track = fProjectionMatchingAlg.buildSegment(hitscl1uniquetpc, hitscl2uniquetpc);
         for (size_t i = 0; i < input.size(); ++i)
         {       
                 std::vector< Hit2D* > hits2dcl = input[i]->GetHits2D();
                 for (size_t h = 0; h < hits2dcl.size(); ++h)
                 {
                         TVector2 pfront = pma::GetProjectionToPlane(track->front()->Point3D(), plane3, track->FrontTPC(), track->FrontCryo());
                         TVector2 pback  = pma::GetProjectionToPlane(track->back()->Point3D(), plane3, track->BackTPC(), track->BackCryo());
                         if ( (pma::Dist2(hits2dcl[h]->GetPointCm(), pfront) < 1.0F) && 
                                 (pma::Dist2(hits2dcl[h]->GetPointCm(), pback) < 1.0F) )
                         {result = true; break;}
                 }                       
         }
         delete track;
         return result;
 }

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);
 }

Member Data Documentation

calo::CalorimetryAlg ems::EMShower3D::fCalorimetryAlg

private

Definition at line 131 of file EMShower3D_module.cc.

Referenced by ConvertFrom(), and ConvertFrom2().

unsigned int ems::EMShower3D::fClIndex

private

Definition at line 124 of file EMShower3D_module.cc.

Referenced by ConvertFrom(), and produce().

art::Handle< std::vector< recob::Cluster > > ems::EMShower3D::fCluListHandle

private

Definition at line 133 of file EMShower3D_module.cc.

Referenced by CollectShower2D(), produce(), and Validate().

std::string ems::EMShower3D::fCluModuleLabel

private

Definition at line 127 of file EMShower3D_module.cc.

Referenced by CollectShower2D(), produce(), reconfigure(), and Validate().

std::vector< std::vector< art::Ptr<recob::Hit> > > ems::EMShower3D::fClusters

private

Definition at line 119 of file EMShower3D_module.cc.

Referenced by CollectShower2D(), and produce().

std::vector< size_t > ems::EMShower3D::fClustersNotUsed

private

Definition at line 121 of file EMShower3D_module.cc.

Referenced by produce(), and Validate().

unsigned int ems::EMShower3D::fIniIndex

private

Definition at line 125 of file EMShower3D_module.cc.

Referenced by ConvertFrom(), ConvertFrom2(), and produce().

std::vector< IniSeg > ems::EMShower3D::fInisegs

private

Definition at line 115 of file EMShower3D_module.cc.

Referenced by Make3DSeg(), and produce().

std::vector< IniSeg > ems::EMShower3D::fPMA3D

private

Definition at line 117 of file EMShower3D_module.cc.

Referenced by produce().

pma::ProjectionMatchingAlg ems::EMShower3D::fProjectionMatchingAlg

private

Definition at line 130 of file EMShower3D_module.cc.

Referenced by ConvertFrom(), ConvertFrom2(), Make3DSeg(), Reoptimize(), and Validate().

std::vector< IniSeg > ems::EMShower3D::fSeltracks

private

Definition at line 116 of file EMShower3D_module.cc.

Referenced by produce(), and Reoptimize().

std::vector< size_t > ems::EMShower3D::fTracksNotUsed

private

Definition at line 122 of file EMShower3D_module.cc.

std::string ems::EMShower3D::fTrk3DModuleLabel

private

Definition at line 128 of file EMShower3D_module.cc.

Referenced by reconfigure().

unsigned int ems::EMShower3D::fTrkIndex

private

Definition at line 124 of file EMShower3D_module.cc.

Referenced by produce().

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

/cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/DirOfGamma/EMShower3D_module.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation