Inheritance diagram for gar::rec::CaloStripSplitter:

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

	CaloStripSplitter (CaloStripSplitter const &)=delete

	CaloStripSplitter (CaloStripSplitter &&)=delete

CaloStripSplitter &	operator= (CaloStripSplitter const &)=delete

CaloStripSplitter &	operator= (CaloStripSplitter &&)=delete

void	produce (art::Event &e) override

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

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

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

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

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

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

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

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

void	sortConsumables (std::string const &current_process_name)

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

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

Private Member Functions
void	CollectHits (const art::Event &evt, const std::string &label, const std::string &instance, std::vector< art::Ptr< gar::rec::CaloHit > > &hitVector)

std::array< double, 3 >	CalculateStripHitPosition (float x, float y, float z, std::pair< float, float > time, raw::CellID_t cID)

float	CorrectStripHitTime (float x, float y, float z, std::pair< float, float > hitTime, raw::CellID_t cID)

Private Attributes
std::string	fCaloHitLabel
	label to find the right reco calo hits More...

std::string	fInstanceName
	product instance name More...

bool	fSaveStripEndsOnly

bool	fSaveUnsplitHits

bool	fSaveStripEnds

const detinfo::DetectorProperties *	fDetProp
	detector properties More...

const geo::GeometryCore *	fGeo
	pointer to the geometry More...

std::unique_ptr< rec::alg::StripSplitterAlg >	fSSAAlgo

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

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

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

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

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

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

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

Detailed Description

Definition at line 38 of file CaloStripSplitter_module.cc.

Constructor & Destructor Documentation

gar::rec::CaloStripSplitter::CaloStripSplitter ( fhicl::ParameterSet const & p )

explicit

Definition at line 74 of file CaloStripSplitter_module.cc.

                                                                         : EDProducer{p}
         {
             fCaloHitLabel = p.get<std::string>("CaloHitLabel", "calohit");
             fInstanceName =  p.get<std::string >("InstanceLabelName", "");
 
             fGeo     = gar::providerFrom<geo::GeometryGAr>();
             fDetProp = gar::providerFrom<detinfo::DetectorPropertiesService>();
             fSaveStripEndsOnly = p.get<bool>("SaveStripEndsOnly", false);
             fSaveUnsplitHits   = p.get<bool>("SaveUnsplitHits", true);
 
             //configure the cluster algorithm
             auto fSSAAlgoPars = p.get<fhicl::ParameterSet>("SSAAlgPars");
             fSSAAlgo = std::make_unique<rec::alg::StripSplitterAlg>(fSSAAlgoPars);
             fSaveStripEnds = fSSAAlgo->GetSaveStripEndsFlag();
 
             if(fSaveStripEnds) {
                 MF_LOG_INFO("CaloStripSplitter_module")
                 << " Saving Strip ends flag turned on! ";
             }
 
             art::InputTag tag(fCaloHitLabel, fInstanceName);
             consumes<std::vector<gar::rec::CaloHit>>(tag);
             produces<std::vector<gar::rec::CaloHit>>(fInstanceName);
         }

gar::rec::CaloStripSplitter::CaloStripSplitter ( CaloStripSplitter const & )

delete

gar::rec::CaloStripSplitter::CaloStripSplitter ( CaloStripSplitter && )

delete

Member Function Documentation

std::array< double, 3 > gar::rec::CaloStripSplitter::CalculateStripHitPosition	(	float	x,
		float	y,
		float	z,
		std::pair< float, float >	time,
		raw::CellID_t	cID
	)

private

Definition at line 201 of file CaloStripSplitter_module.cc.

         {
             std::array<double, 3> point = {x, y, z};
             std::array<double, 3> pointLocal;
             gar::geo::LocalTransformation<TGeoHMatrix> trans;
             fGeo->WorldToLocal(point, pointLocal, trans);
 
             //Calculate the position of the hit based on the corrected time along the strip
             float c = (CLHEP::c_light * CLHEP::mm / CLHEP::ns) / CLHEP::cm; // in cm/ns
             float xlocal = c * ( time.first - time.second ) / 2.;
 
             std::array<double, 3> local_back = fGeo->ReconstructStripHitPosition(point, pointLocal, xlocal, cID);
             std::array<double, 3> world_back;
             fGeo->LocalToWorld(local_back, world_back, trans);
 
             return world_back;
         }

void gar::rec::CaloStripSplitter::CollectHits	(	const art::Event &	evt,
		const std::string &	label,
		const std::string &	instance,
		std::vector< art::Ptr< gar::rec::CaloHit > > &	hitVector
	)

private

Definition at line 187 of file CaloStripSplitter_module.cc.

         {
             art::InputTag itag(label,instance);
             auto theHits = evt.getHandle< std::vector<gar::rec::CaloHit> >(itag);
             if (!theHits) return;
 
             for (unsigned int i = 0; i < theHits->size(); ++i)
             {
                 const art::Ptr<gar::rec::CaloHit> hit(theHits, i);
                 hitVector.push_back(hit);
             }
         }

float gar::rec::CaloStripSplitter::CorrectStripHitTime	(	float	x,
		float	y,
		float	z,
		std::pair< float, float >	hitTime,
		raw::CellID_t	cID
	)

private

Definition at line 220 of file CaloStripSplitter_module.cc.

         {
             std::array<double, 3> point = {x, y, z};
             double stripLength = fGeo->getStripLength(point, cID); // in cm
 
             float c = (CLHEP::c_light * CLHEP::mm / CLHEP::ns) / CLHEP::cm; // in cm/ns
             float time = (hitTime.first + hitTime.second) / 2. - (stripLength / (2 * c));
 
             return time;
         }

CaloStripSplitter& gar::rec::CaloStripSplitter::operator= ( CaloStripSplitter const & )

delete

CaloStripSplitter& gar::rec::CaloStripSplitter::operator= ( CaloStripSplitter && )

delete

void gar::rec::CaloStripSplitter::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 100 of file CaloStripSplitter_module.cc.

         {
             //Collect the hits to be passed to the algo
             std::vector< art::Ptr<gar::rec::CaloHit> > artHits;
             this->CollectHits(e, fCaloHitLabel, fInstanceName, artHits);
 
             //Prepare the hits for SSA
             fSSAAlgo->PrepareAlgo(artHits);
             //Perform the SS
             fSSAAlgo->DoStripSplitting();
             //Get back the vector of split hits
             std::vector<const gar::rec::CaloHit*> splitHits = fSSAAlgo->getSplitHits();
             //Get back the vector of unsplit hits
             std::vector<const gar::rec::CaloHit*> unsplitHits = fSSAAlgo->getUnSplitHits();
 
             // make an art::PtrVector of the hits
             std::unique_ptr< std::vector<gar::rec::CaloHit> > HitCol(new std::vector<gar::rec::CaloHit>);
 
             if(not fSaveStripEndsOnly) {
                 //Copy the split hits to the collection
                 for(auto const &it : splitHits) {
 
                     //Need to correct the time for the strips
                     float energy = it->Energy();
                     std::pair<float, float> time = it->Time();
                     raw::CellID_t cellID = it->CellID();
                     const float *pos = it->Position();
                     float newpos[3] = { pos[0], pos[1], pos[2] };
                     float newtime = time.first;
                     unsigned int layer = it->Layer();
                     const std::array<double, 3> point = { pos[0], pos[1], pos[2] };
 
                     if(not fGeo->isTile(point, cellID)) {
                         newtime = this->CorrectStripHitTime(newpos[0], newpos[1], newpos[2], time, cellID);
                     }
 
                     rec::CaloHit hit(energy, newtime, newpos, cellID, layer);
                     HitCol->emplace_back(hit);
                 }
 
                 if( fSaveUnsplitHits ) {
                     //Copy the unsplit hits to the collection
                     for(auto const &it : unsplitHits) {
 
                         //Need to correct the position of the un-used strips
                         float energy = it->Energy();
                         std::pair<float, float> time = it->Time();
                         raw::CellID_t cellID = it->CellID();
                         const float *pos = it->Position();
                         float newpos[3] = { pos[0], pos[1], pos[2] };
                         float newtime = time.first;
                         unsigned int layer = it->Layer();
                         const std::array<double, 3> point = { pos[0], pos[1], pos[2] };
 
                         if(not fGeo->isTile(point, cellID)) {
                             // Need to correct for the position of these based on time information
                             std::array<double, 3> strip_pos = this->CalculateStripHitPosition(newpos[0], newpos[1], newpos[2], time, cellID);
                             newpos[0] = strip_pos[0];
                             newpos[1] = strip_pos[1];
                             newpos[2] = strip_pos[2];
                             newtime = this->CorrectStripHitTime(newpos[0], newpos[1], newpos[2], time, cellID);
                         }
 
                         rec::CaloHit hit(energy, newtime, newpos, cellID, layer);
 
                         HitCol->emplace_back(hit);
                     }
                 }
             }
 
             //Copy the strip end hits to the collection
             if(fSaveStripEnds) {
                 std::vector<const gar::rec::CaloHit*> stripEndsHits = fSSAAlgo->getStripEndsHits();
                 for(auto const &it : stripEndsHits)
                 HitCol->emplace_back(*it);
 
                 std::vector<const gar::rec::CaloHit*> stripInterHits = fSSAAlgo->getIntersectionHits();
                 for(auto const &it : stripInterHits)
                 HitCol->emplace_back(*it);
             }
 
             e.put(std::move(HitCol), fInstanceName);
 
             return;
         }