Inheritance diagram for gar::rec::vertexfinder1:

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

	vertexfinder1 (vertexfinder1 const &)=delete

	vertexfinder1 (vertexfinder1 &&)=delete

vertexfinder1 &	operator= (vertexfinder1 const &)=delete

vertexfinder1 &	operator= (vertexfinder1 &&)=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
bool	goodTrack (TrackPar trk, TrackEnd usebeg)

Private Attributes
float	fChisquaredCut

int	fPrintLevel

float	fRCut

float	fDCut

std::string	fTrackLabel

int	fNTPCClusCut

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 30 of file vertexfinder1_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 60 of file vertexfinder1_module.cc.

                                                             : EDProducer{p} 
     {
       fTrackLabel = p.get<std::string>("TrackLabel","track");
       fChisquaredCut = p.get<float>("ChisquaredPerDOFCut",5.0);
       fRCut = p.get<float>("RCut", 12.0); // endpoints must be within this distnace in cm
       fDCut = p.get<float>("DCut", 2.0); // doca must be smaller than this in cm
       fNTPCClusCut = p.get<int>("NTPCClusCut",20);  // dimensionless
       fPrintLevel = p.get<int>("PrintLevel",0);
 
       art::InputTag trackTag(fTrackLabel);
       consumes< std::vector<rec::Track> >(trackTag);
 
       // Produce vertex, associated tracks & ends.  TrackEnd is defined in Track.h
       produces< std::vector<rec::Vertex> >();
       produces< art::Assns<rec::Track, rec::Vertex, rec::TrackEnd> >();
     }

gar::rec::vertexfinder1::vertexfinder1 ( vertexfinder1 const & )

delete

gar::rec::vertexfinder1::vertexfinder1 ( vertexfinder1 && )

delete

Member Function Documentation

bool gar::rec::vertexfinder1::goodTrack	(	TrackPar	trk,
		TrackEnd	usebeg
	)

private

Definition at line 221 of file vertexfinder1_module.cc.

     {
       int trknclus = trk.getNTPCClusters();
       if ( trknclus < fNTPCClusCut ) return false;
       return true;     // just a stub for now
     }

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

delete

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

delete

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

overridevirtual

Implements art::EDProducer.

Definition at line 77 of file vertexfinder1_module.cc.

                                             {
       std::unique_ptr< std::vector<rec::Vertex> >
         vtxCol(new std::vector<rec::Vertex>);
       std::unique_ptr< art::Assns<rec::Track, rec::Vertex, rec::TrackEnd> >
         trkVtxAssns(new art::Assns<rec::Track, rec::Vertex, rec::TrackEnd>);
 
       auto trackHandle = e.getValidHandle< std::vector<Track>  >(fTrackLabel);
       auto const& tracks = *trackHandle;
 
       auto const vtxPtrMaker   = art::PtrMaker<rec::Vertex>(e);
       auto const trackPtrMaker = art::PtrMaker<rec::Track>(e, trackHandle.id());
 
       size_t nTrack = tracks.size();
       std::vector<int> usedflag_beg(nTrack,0);  // to tell if we've used a track yet or not.
       std::vector<int> usedflag_end(nTrack,0);  // to tell if we've used a track yet or not.
 
       if (nTrack>=2) {
 
         // For each track, build a vector of ends that can be vertexed with it.  Include
         // the number of the track for later ouroboros test
 
         std::vector< std::tuple<TrackPar,TrackEnd,int> > trackParEnds;
         for (size_t iTrack=0; iTrack<nTrack-1; ++iTrack) {
           TrackPar thisTrack = tracks.at(iTrack);
           // Build that vector for each of the 2 ends of the track
           for (int fin=0; fin<2; ++fin) {
             trackParEnds.clear();
             TrackEnd thisTrackEnd(fin == 0 ? 1 : 0);
             if (! goodTrack(thisTrack,thisTrackEnd)) continue;
             trackParEnds.emplace_back( std::make_tuple(thisTrack,thisTrackEnd,iTrack) );
             TVector3 thisEndinSpace;
             if (thisTrackEnd == TrackEndBeg) 
               { 
                 usedflag_beg.at(iTrack) = 1; 
                 thisEndinSpace = thisTrack.getXYZBeg();
               }
             else
               { 
                 usedflag_end.at(iTrack) = 1; 
                 thisEndinSpace = thisTrack.getXYZEnd();
               }
 
             // Loop over other trackends to see what is close
             for (size_t jTrack=iTrack+1; jTrack<nTrack; ++jTrack) {
               TrackPar thatTrack = tracks.at(jTrack);
               for (int fin2=0; fin2<2; ++fin2)
                 {
                   TrackEnd thatTrackEnd(fin2 == 0 ? 1 : 0);
                   if (thatTrackEnd == TrackEndBeg && usedflag_beg.at(jTrack) != 0) continue;
                   if (thatTrackEnd == TrackEndEnd && usedflag_end.at(jTrack) != 0) continue;
                   if (!goodTrack(thatTrack,thatTrackEnd)) continue;
                   TVector3 thatEndinSpace;
                   if (thatTrackEnd == TrackEndBeg) 
                     { 
                       thatEndinSpace = thatTrack.getXYZBeg();
                     }
                   else
                     { 
                       thatEndinSpace = thatTrack.getXYZEnd();
                     }
 
                   if ( (thisEndinSpace-thatEndinSpace).Mag() > fRCut) continue;
 
 
                   // call the fitter to see what the docas are and cut on the doca
 
                   std::vector<TrackPar> vtracks;
                   std::vector<TrackEnd> usebeg;
                   vtracks.push_back(thisTrack);
                   vtracks.push_back(thatTrack);
                   usebeg.push_back(thisTrackEnd);
                   usebeg.push_back(thatTrackEnd);
                   std::vector<float> xyz(3,0);
                   std::vector< std::vector<float> > covmat;
                   std::vector<float> doca;
                   float chisquared=0;
                   double time;
 
                   if (gar::rec::fitVertex(vtracks,xyz,chisquared,covmat,time,usebeg,doca) == 0) 
                     {
                       if (doca.at(0) < fDCut && doca.at(1) < fDCut)
                         {
                           if (thatTrackEnd == TrackEndBeg)
                             {
                               usedflag_beg.at(jTrack) = 1;
                             }
                           else
                             {
                               usedflag_end.at(jTrack) = 1;
                             }
                           trackParEnds.emplace_back( std::make_tuple(thatTrack,thatTrackEnd,jTrack) );
                           continue;  // don't add the other end of the same track
                         } // end if doca test
                     } // end if vertex fit succeeded
                 } // end loop over jtrack end
             } // End loop over jTrack
  
             size_t nTrackEnds = trackParEnds.size();
 
             if ( nTrackEnds>=2) {
               // Feed the vertexable ends into the vertex finder
               std::vector<TrackPar> vtracks;
               std::vector<TrackEnd> usebeg;
               for (size_t iTrackEnd=0; iTrackEnd<nTrackEnds; ++iTrackEnd) {
                 vtracks.push_back( std::get<TrackPar>(trackParEnds[iTrackEnd]) );            
                 usebeg.push_back ( std::get<1>(trackParEnds[iTrackEnd]) );            
               }
               std::vector<float> xyz(3,0);
               std::vector< std::vector<float> > covmat;
               std::vector<float> doca;
               float chisquared=0;
               double time;
               if (gar::rec::fitVertex(vtracks,xyz,chisquared,covmat,time,usebeg,doca) == 0) {
                 float cmv[9];
                 size_t icounter=0;
                 for (size_t i=0; i<3;++i) {
                   for (size_t j=0; j<3; ++j) {
                     cmv[icounter] = covmat.at(i).at(j);
                   }
                 }
 
                 // Save vertex & its tracks into vectors that will be written 
                 // to event.
                 vtxCol->emplace_back(xyz.data(),cmv,time);
                 auto const vtxpointer = vtxPtrMaker(vtxCol->size()-1);
                 for (size_t i=0; i<trackParEnds.size(); ++i) {
                   TrackEnd endInVertex = std::get<1>(trackParEnds[i]);
                   auto const trackpointer = trackPtrMaker( std::get<2>(trackParEnds[i]) );
                   trkVtxAssns->addSingle(trackpointer,vtxpointer,endInVertex);
                 }
               } // end if (fitVertex...)
             }
           } // end loop on 2 ends of iTrack
         } // end loop on iTrack
       }  // End test for nTrack>=2; might put empty vertex list & Assns into event
       e.put(std::move(vtxCol));
       e.put(std::move(trkVtxAssns));
     } // end produce method.

Member Data Documentation

float gar::rec::vertexfinder1::fChisquaredCut

private

Definition at line 47 of file vertexfinder1_module.cc.

float gar::rec::vertexfinder1::fDCut

private

Definition at line 50 of file vertexfinder1_module.cc.

int gar::rec::vertexfinder1::fNTPCClusCut

private

Definition at line 52 of file vertexfinder1_module.cc.

int gar::rec::vertexfinder1::fPrintLevel

private

Definition at line 48 of file vertexfinder1_module.cc.

float gar::rec::vertexfinder1::fRCut

private

Definition at line 49 of file vertexfinder1_module.cc.

std::string gar::rec::vertexfinder1::fTrackLabel

private

Definition at line 51 of file vertexfinder1_module.cc.

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

garsoft/Reco/vertexfinder1_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation