Inheritance diagram for slicer::Slicer4D:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

virtual	~Slicer4D ()

void	beginRun (art::Run &run)

void	produce (art::Event &evt)

void	endJob ()

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
bool	GenerateCluster (unsigned int point, int ClID)

CurrentProcessingContext const *	currentContext () const

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

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Protected Attributes
std::string	fCellHitInput
	Read CellHits from this input. More...

bool	fDoNotSliceAnything
	If true, one big slice is written out. More...

bool	fApplyNeighborhoodCleanUp
	scrub loner hits from the slice? More...

double	fEpsilon
	Minimum causal separation value for neighbors. More...

unsigned int	fMinPts
	minimum number of casual neighbors for a hit to be in a cluster More...

bool	fUseLowPEPen
	Add a causal distance penalty for PE (low PE is INCREASES the distance) More...

double	fPEPen
	PE value for which the low PE penalty will be 1. More...

double	fDistPen
	Distance (in cm) for which the distance penalty will be 1 (roughly one strong interaction length.) More...

double	fOpVPlPen
	Allowed plane gap for hits in opposite views for which the distance penalty will be 1. More...

unsigned int	fMinHitsPerView
	Minimum number of hits per view to make a cluster. More...

int	fMaxEventHits

fhicl::ParameterSet	fPSetNDOS

fhicl::ParameterSet	fPSetND

fhicl::ParameterSet	fPSetFD

fhicl::ParameterSet	fPSetTB

PointManager	fPtMan
	Helper class for the 4D clustering. More...

Detailed Description

Definition at line 31 of file Slicer4D_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

slicer::Slicer4D::Slicer4D ( fhicl::ParameterSet const & pset )

explicit

Definition at line 74 of file Slicer4D_module.cc.

                                                   :
     fCellHitInput      (pset.get< std::string  >("CellHitInput")      ),
     fDoNotSliceAnything(pset.get< bool         >("DoNotSliceAnything")),
     fApplyNeighborhoodCleanUp(pset.get< bool   >("ApplyNeighborhoodCleanUp")),
     fEpsilon           (0),
     fMinPts            (0),
     fUseLowPEPen       (0),
     fPEPen             (0),
     fDistPen           (0),
     fOpVPlPen          (0),
     fMinHitsPerView    (0),
     fMaxEventHits      (pset.get< int          >("MaxEventHits")),
     fPSetNDOS          (pset.get<fhicl::ParameterSet>("ndos")),
     fPSetND            (pset.get<fhicl::ParameterSet>("nd")),
     fPSetFD            (pset.get<fhicl::ParameterSet>("fd")),
     fPSetTB            (pset.get<fhicl::ParameterSet>("tb"))
   {
     produces< std::vector<rb::Cluster> >();
   }

slicer::Slicer4D::~Slicer4D ( )

virtual

Definition at line 95 of file Slicer4D_module.cc.

96 { }

Member Function Documentation

void slicer::Slicer4D::beginRun ( art::Run & run )

virtual

Reimplemented from art::EDProducer.

Definition at line 99 of file Slicer4D_module.cc.

References ana::assert(), geo::GeometryBase::DetId(), fDistPen, fEpsilon, fMinHitsPerView, fMinPts, fOpVPlPen, fPEPen, fPSetFD, fPSetND, fPSetNDOS, fPSetTB, fUseLowPEPen, geom(), fhicl::ParameterSet::get(), novadaq::cnv::kFARDET, novadaq::cnv::kNDOS, novadaq::cnv::kNEARDET, and novadaq::cnv::kTESTBEAM.

   {
     art::ServiceHandle<geo::Geometry> geom;
 
     fhicl::ParameterSet pset;
     switch(geom->DetId()){
     case novadaq::cnv::kNDOS:
       pset = fPSetNDOS;
       break;
     case novadaq::cnv::kNEARDET:
       pset = fPSetND;
       break;
     case novadaq::cnv::kFARDET:
       pset = fPSetFD;
       break;
     case novadaq::cnv::kTESTBEAM:
       pset = fPSetTB;
       break;
     default:
       assert(0 && "Unknown detector");
     }
 
     fEpsilon        = pset.get<double      >("Epsilon");
     fMinPts         = pset.get<unsigned int>("MinPts");
     fUseLowPEPen    = pset.get<bool        >("UseLowPEPen");
     fPEPen          = pset.get<double      >("PEPen");
     fDistPen        = pset.get<double      >("DistPen");
     fOpVPlPen       = pset.get<double      >("OppViewPlanePen");
     fMinHitsPerView = pset.get<unsigned int>("MinHitsPerView");
   }

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 146 of file Consumer.h.

References art::InputTag::instance(), PandAna.reco_validation.prod5_pid_validation::invalid, art::InputTag::label(), art::InputTag::process(), and T.

 {
   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 161 of file Consumer.h.

References T.

 {
   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 171 of file Consumer.h.

References art::InputTag::instance(), PandAna.reco_validation.prod5_pid_validation::invalid, art::InputTag::label(), art::InputTag::process(), and T.

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

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

inherited

Referenced by evgen::CosmicPionGen::CosmicPionGen(), evgen::CosmicsGen::CosmicsGen(), fuzz::FuzzyKVertex::FuzzyKVertex(), g4n::G4Gen::G4Gen(), photrans::ImprovedTransport::ImprovedTransport(), art::MixFilter< T >::initEngine_(), evgen::IsoGen::IsoGen(), rsim::MakeNoiseSpectrumFile::MakeNoiseSpectrumFile(), photrans::PhotonSystRewriter::PhotonSystRewriter(), photrans::PhotonTransport::PhotonTransport(), rsim::ReadoutSim::ReadoutSim(), evgen::SingleGen::SingleGen(), and evgen::SupernovaGen::SupernovaGen().

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

inherited

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

inherited

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

protectedinherited

void slicer::Slicer4D::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 131 of file Slicer4D_module.cc.

   {
     // Print statements used when tuning the slicer parameters.
     /*
     std::cout << "\n\n========== End Job ==========\n"
               << "End Job: (eps, minpts, PEPen, DistPen, OpVPlPen, MinHitsPerView) "
               << fEpsilon        << " "
               << fMinPts         << " "
               << fPEPen          << " "
               << fDistPen        << " "
               << fOpVPlPen       << " "
               << fMinHitsPerView << "\n";
     */
   }

bool slicer::Slicer4D::GenerateCluster	(	unsigned int	point,
		int	ClID
	)

protected

Definition at line 305 of file Slicer4D_module.cc.

References slicer::PointManager::changeClustID(), DEFINE_ART_MODULE(), slicer::PointManager::fClustIDs, fMinPts, fPtMan, slicer::PointManager::regionQuery(), and fillBadChanDBTables::result.

Referenced by produce().

   {
     // In the original DBSCAN paper, this is the function they called
     // "ExpandCluster."  How this function works is most easily understood
     // by reading that paper (don't worry, it is pretty short...)
 
     // Get the list of neighbors for 'point.'
     std::vector<unsigned int> seeds = fPtMan.regionQuery(point);
 
     // If 'point' is not a core point, label it as noise and return.
     if(seeds.size() < fMinPts) {
       fPtMan.changeClustID(point, 0);
       return false;
     }
     else {
       // Assign 'point' and the neighbors of 'point' to the cluster ClID.
       for(unsigned int seedi = 0; seedi < seeds.size(); ++seedi)
         fPtMan.changeClustID(seeds[seedi],ClID);
       seeds.erase(seeds.begin());
     
       // Loop over the neighbors of 'point' to see if they are also core
       // points.
       while(seeds.size() > 0) {
         // Get the list of neighbors for the first seed point.
         std::vector<unsigned int> result = fPtMan.regionQuery(seeds[0]);
         
         // If the first seed point is also a core point, add its neighbors
         // to the list of seeds and assigne them to the cluster ClID.
         if(result.size() >= fMinPts) {
           for(unsigned int resulti = 0; resulti < result.size(); ++resulti) {
             // If the point is unassigned (-1) or previously labeled as
             // noise (0), asign it ClID.
             if(fPtMan.fClustIDs[result[resulti]] == -1 ||
                fPtMan.fClustIDs[result[resulti]] == 0) {
               // Only add this point to the list of seeds if it was
               // previously unassigned.
               if(fPtMan.fClustIDs[result[resulti]] == -1)
                 seeds.push_back(result[resulti]);
               fPtMan.changeClustID(result[resulti], ClID);
             } // end if(resulti is -1 or 0)
 
           } // end for resulti
 
         } // end if result.size() >= fMinPts
         seeds.erase(seeds.begin());
 
       } // end while
       return true;
     } // end else
 
   } // end GenerateCluster function

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

inherited

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

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_.

Referenced by skim::NueSkimmer::CopyMichelSlice(), and skim::NueSkimmer::CopyMichelTrack().

   {
     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 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 189 of file Consumer.h.

References art::InputTag::instance(), PandAna.reco_validation.prod5_pid_validation::invalid, art::InputTag::label(), art::InputTag::process(), and T.

 {
   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 204 of file Consumer.h.

References T.

 {
   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 214 of file Consumer.h.

References art::InputTag::instance(), PandAna.reco_validation.prod5_pid_validation::invalid, art::InputTag::label(), art::InputTag::process(), and T.

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

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

staticinherited

Referenced by art::RootOutput::beginSubRun(), art::ProcessPackage< L >::postScheduleSignal(), art::BeginEndPackage< Level::Run >::Begin::postScheduleSignal(), art::BeginEndPackage< Level::Run >::End::postScheduleSignal(), art::BeginEndPackage< Level::SubRun >::Begin::postScheduleSignal(), art::BeginEndPackage< Level::SubRun >::End::postScheduleSignal(), art::ProcessPackage< L >::preScheduleSignal(), art::BeginEndPackage< Level::Run >::Begin::preScheduleSignal(), art::BeginEndPackage< Level::SubRun >::Begin::preScheduleSignal(), art::EmptyEvent::readRun_(), and art::EmptyEvent::readSubRun_().

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

protectedinherited

void slicer::Slicer4D::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 147 of file Slicer4D_module.cc.

References rb::Cluster::Add(), slicer::PointManager::AddHit(), make_syst_table_plots::c, slicer::PointManager::CleanUpNeighborhood(), fApplyNeighborhoodCleanUp, fCellHitInput, slicer::PointManager::fClustIDs, fDistPen, fDoNotSliceAnything, fEpsilon, slicer::PointManager::FindNeighbors(), fMaxEventHits, fMinHitsPerView, fOpVPlPen, fPEPen, fPtMan, fUseLowPEPen, GenerateCluster(), art::DataViewImpl::getByLabel(), calib::Calibrator::GetTimeRes(), MECModelEnuComparisons::i, slicer::PointManager::Initalize(), calib::j, geo::kX, geo::kXorY, geo::kY, art::Event::put(), slicer::PointManager::Reset(), rb::Cluster::SetNoise(), and rb::SortByTime().

   {
     // NOTE:  There is currently no requirement that a slice have hits in
     //        both views.
 
     art::ServiceHandle<calib::Calibrator> cal;
 
     // Get the cell hits
     art::Handle< std::vector<rb::CellHit> > hitcol;
     evt.getByLabel(fCellHitInput, hitcol);
 
     // Load the cell hits into a vector for easy use
     std::vector<art::Ptr<rb::CellHit > > hitlist;
     hitlist.reserve(hitcol->size());
     for(unsigned int i = 0; i < hitcol->size(); ++i){
       art::Ptr<rb::CellHit> hit(hitcol, i);
       hitlist.push_back(hit);  
     }
 
     // Safety in case of a very large number of hits in the event, which can
     // take a long time to slice, and the results probably won't be useful for
     // downstream modules anyway.
     if(fMaxEventHits > 0 && int(hitlist.size()) > fMaxEventHits){
       mf::LogWarning("Slicer4D") << "Very large number of hits ("
                                  << hitlist.size()
                                  << ") in event. Higher than configured limit ("
                                  << fMaxEventHits
                                  << "). Will put all hits in the noise slice.";
       rb::Cluster noise;
       for(art::Ptr<rb::CellHit> c: hitlist) noise.Add(c);
       noise.SetNoise(true);
       evt.put(std::make_unique<std::vector<rb::Cluster>>(1, noise));
       return;
     }
 
     // Sort the hits by time to improve the speed.
     // WARNING:  The rest of the code assumes that the hits are
     //           time sorted!
     rb::SortByTime(hitlist);
 
 
 
     // Initalize PointManager to help with the 4D clustering,
     // add the hit info to the point manager, and generate the
     // initial neighbor map.
     fPtMan.Initalize(fEpsilon, fPEPen, fDistPen, fOpVPlPen, fUseLowPEPen);
     
     fPtMan.Reset(hitlist.size());
     
     for(unsigned int i = 0; i < hitlist.size(); ++i) {
       fPtMan.AddHit(hitlist[i]->TNS(), cal->GetTimeRes(*hitlist[i]),
                     hitlist[i]->Plane(), hitlist[i]->Cell(), hitlist[i]->PE(),
                     hitlist[i]->View());
     }
 
     fPtMan.FindNeighbors();
 
     // OPTIONAL: Clean up the neighborhood (Get off my lawn you damn kids!)
     if(fApplyNeighborhoodCleanUp) fPtMan.CleanUpNeighborhood();
 
     std::unique_ptr< std::vector<rb::Cluster> >
       clustercol(new std::vector<rb::Cluster>);
 
 
 
     
     //
     // Use alternate slicing methods if requested
     //
     int CurrentClusterID = 1;
 
     if(fDoNotSliceAnything) {
 
       // We will only put one BIG cluster into the event.  I don't know
       // if anyone uses this feature, but I grandfathered it in from
       // the old slicer.
 
       rb::Cluster cluster;
 
       for(unsigned int i = 0; i < hitlist.size(); ++i)
         cluster.Add(hitlist[i]);
       
       // Add the cluster to clustercol
       clustercol->push_back(cluster);
 
     }
     // otherwise do the standard DBSCAN slicing
     else {
       for(unsigned int i = 0; i < hitlist.size(); ++i) {
         // If the point is unclassified, attempt to expand the cluster
         if(fPtMan.fClustIDs[i] == -1) {
           if(this->GenerateCluster(i,CurrentClusterID))
             CurrentClusterID++;
         } // end if point is unclassified
       } // end loop over all hits, i
 
 
 
       //
       // Construct the actual slices to be put into the event.
       //
       std::vector<rb::Cluster> clusters(CurrentClusterID);
       
       for(unsigned int i = 0; i < hitlist.size(); ++i)
         clusters[fPtMan.fClustIDs[i]].Add(hitlist[i]);
       
       // Move hits in non-noise clusters that are too small
       // to the noise cluster.
       for(unsigned int i = 1; i < clusters.size(); ++i) {
 
         if(clusters[i].NXCell() >= fMinHitsPerView &&
            clusters[i].NYCell() >= fMinHitsPerView) continue;
 
         // This cluster is too small.  Put its hits into the noise
         // cluster and clear it.
         for(unsigned int j = 0; j < clusters[i].NCell(); ++j) {
           art::Ptr<rb::CellHit> hit(clusters[i].Cell(j));
           clusters[0].Add(hit);
         } // end for j (loop over hits)
         clusters[i].Clear();
       } // end for i (loop over clusters)
 
       // Tag the noise cluster as such.
       clusters[0].SetNoise(true);
 
       // Always put in the noise cluster even if it is empty.
       clustercol->push_back(clusters[0]);
       
       // Add all non-empty, non-noise clusters to clustercol
       for(unsigned int i = 1; i < clusters.size(); ++i) {
 
         if(clusters[i].NCell() == 0) continue;
 
         geo::View_t V = geo::kXorY;
         if(clusters[i].NXCell() == 0) V = geo::kY;
         if(clusters[i].NYCell() == 0) V = geo::kX;
 
         rb::Cluster tempcluster(clusters[i].AllCells(),V);
         clustercol->push_back(tempcluster);
 
       }
 
     } // end else { do the DBSCAN clustering }
 
     //
     // Before saving the clusters, put the hits inside them into a
     // standard order
     //
     for (unsigned int i=0; i<clustercol->size(); ++i) {
       (*clustercol)[i].StandardSort();
     }
 
     // put the slices into the event
     evt.put(std::move(clustercol));
 
   } // end Produce function

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Referenced by art::RootOutput::endJob().

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

protectedinherited

Member Data Documentation

bool slicer::Slicer4D::fApplyNeighborhoodCleanUp

protected

scrub loner hits from the slice?

Definition at line 47 of file Slicer4D_module.cc.

Referenced by produce().

std::string slicer::Slicer4D::fCellHitInput

protected

Read CellHits from this input.

Definition at line 45 of file Slicer4D_module.cc.

Referenced by produce().

double slicer::Slicer4D::fDistPen

protected

Distance (in cm) for which the distance penalty will be 1 (roughly one strong interaction length.)

Definition at line 53 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

bool slicer::Slicer4D::fDoNotSliceAnything

protected

If true, one big slice is written out.

Definition at line 46 of file Slicer4D_module.cc.

Referenced by produce().

double slicer::Slicer4D::fEpsilon

protected

Minimum causal separation value for neighbors.

Definition at line 49 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

int slicer::Slicer4D::fMaxEventHits

protected

Definition at line 57 of file Slicer4D_module.cc.

Referenced by produce().

unsigned int slicer::Slicer4D::fMinHitsPerView

protected

Minimum number of hits per view to make a cluster.

Definition at line 55 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

unsigned int slicer::Slicer4D::fMinPts

protected

minimum number of casual neighbors for a hit to be in a cluster

Definition at line 50 of file Slicer4D_module.cc.

Referenced by beginRun(), and GenerateCluster().

double slicer::Slicer4D::fOpVPlPen

protected

Allowed plane gap for hits in opposite views for which the distance penalty will be 1.

Definition at line 54 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

double slicer::Slicer4D::fPEPen

protected

PE value for which the low PE penalty will be 1.

Definition at line 52 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

fhicl::ParameterSet slicer::Slicer4D::fPSetFD

protected

Definition at line 59 of file Slicer4D_module.cc.

Referenced by beginRun().

fhicl::ParameterSet slicer::Slicer4D::fPSetND

protected

Definition at line 59 of file Slicer4D_module.cc.

Referenced by beginRun().

fhicl::ParameterSet slicer::Slicer4D::fPSetNDOS

protected

Definition at line 59 of file Slicer4D_module.cc.

Referenced by beginRun().

fhicl::ParameterSet slicer::Slicer4D::fPSetTB

protected

Definition at line 59 of file Slicer4D_module.cc.

Referenced by beginRun().

PointManager slicer::Slicer4D::fPtMan

protected

Helper class for the 4D clustering.

Definition at line 62 of file Slicer4D_module.cc.

Referenced by GenerateCluster(), and produce().

bool slicer::Slicer4D::fUseLowPEPen

protected

Add a causal distance penalty for PE (low PE is INCREASES the distance)

Definition at line 51 of file Slicer4D_module.cc.

Referenced by beginRun(), and produce().

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

/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-08-14/Slicer/Slicer4D_module.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation