vertex::PrimaryVertexFinder Class Reference

Inheritance diagram for vertex::PrimaryVertexFinder:

Public Types
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = ProducerBase::Table< UserConfig, KeysToIgnore >

Public Member Functions
	PrimaryVertexFinder (fhicl::ParameterSet const &pset)
virtual	~PrimaryVertexFinder ()
void	beginJob ()
void	reconfigure (fhicl::ParameterSet const &p)
void	produce (art::Event &evt)
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
double	StartPointSeperation (recob::SpacePoint sp1, recob::SpacePoint sp2)
bool	IsInVertexCollection (int a, std::vector< std::vector< int > > vertex_collection)
int	IndexInVertexCollection (int a, int b, std::vector< std::vector< int > > vertex_collection)
bool	IsInNewVertex (int a, std::vector< int > newvertex)
double	gammavalue (TVector3 startpoint1, TVector3 startpoint2, TVector3 dircos1, TVector3 dircos2)
double	alphavalue (double gamma, TVector3 startpoint1, TVector3 startpoint2, TVector3 dircos1, TVector3 dircos2)
double	MinDist (double alpha, double gamma, TVector3 startpoint1, TVector3 startpoint2, TVector3 dircos1, TVector3 dircos2)
TVector3	PointOnExtendedTrack (double alphagamma, TVector3 startpoint, TVector3 dircos)

Private Attributes
std::string	fTrackModuleLabel
double	fVertexWindow
TH2F *	fNoTracks
TH1F *	fLength_1stTrack
TH1F *	fLength_2ndTrack
TH1F *	fLength_3rdTrack
TH1F *	fLength_4thTrack
TH1F *	fLength_5thTrack

Detailed Description

Definition at line 61 of file PrimaryVertexFinder_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

vertex::PrimaryVertexFinder::PrimaryVertexFinder ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 106 of file PrimaryVertexFinder_module.cc.

  {  
    this->reconfigure(pset);    
    produces< std::vector<recob::Vertex> >();
    produces< art::Assns<recob::Vertex, recob::Hit> >();
    produces< art::Assns<recob::Vertex, recob::Track> >();
    produces< art::Assns<recob::Vertex, recob::Shower> >();
  }

vertex::PrimaryVertexFinder::~PrimaryVertexFinder ( )

virtual

Definition at line 116 of file PrimaryVertexFinder_module.cc.

  {
  }

Member Function Documentation

double vertex::PrimaryVertexFinder::alphavalue ( double  gamma, TVector3  startpoint1, TVector3  startpoint2, TVector3  dircos1, TVector3  dircos2  )

private

Definition at line 475 of file PrimaryVertexFinder_module.cc.

{
  double alpha = (gamma*(dircos1*dircos2)) + (startpoint2*dircos1) - (startpoint1*dircos1);

  return alpha;
}

void vertex::PrimaryVertexFinder::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 128 of file PrimaryVertexFinder_module.cc.

References art::TFileDirectory::make().

                                    {
    // get access to the TFile service
    art::ServiceHandle<art::TFileService> tfs;
    
    //    fNoVertices= tfs->make<TH2F>("fNoVertices", ";Event No; No of vertices", 100,0, 100, 30, 0, 30);
     fNoTracks= tfs->make<TH2F>("fNoTracks", ";Event No; No of Tracks", 10,0, 10, 10, 0, 10);
     fLength_1stTrack = tfs->make<TH1F>("fLength_Track1", "Muon Track Length", 100,0,100);
     fLength_2ndTrack = tfs->make<TH1F>("fLength_Track2", "2nd Track Length", 100,0,100);
     fLength_3rdTrack = tfs->make<TH1F>("fLength_Track3", "3rd Track Length", 100,0,100);
     fLength_4thTrack = tfs->make<TH1F>("fLength_Track4", "4th Track Length", 100,0,100);
     fLength_5thTrack = tfs->make<TH1F>("fLength_Track5", "5th Track Length", 100,0,100);
  }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

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

inherited

Definition at line 147 of file Consumer.h.

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

{
  if (!moduleContext_)
    return ProductToken<T>::invalid();

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

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

{
  if (!moduleContext_)
    return;

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

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

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

inherited

Definition at line 172 of file Consumer.h.

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

{
  if (!moduleContext_)
    return ViewToken<T>::invalid();

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

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

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

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

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

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

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

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

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

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

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

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

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

  {
    return current_context_.get();
  }

double vertex::PrimaryVertexFinder::gammavalue ( TVector3  startpoint1, TVector3  startpoint2, TVector3  dircos1, TVector3  dircos2  )

private

Definition at line 468 of file PrimaryVertexFinder_module.cc.

{
  double gamma = ((startpoint1*dircos2)-(startpoint2*dircos2)+((dircos1*dircos2)*(startpoint2*dircos1))-((dircos1*dircos2)*(startpoint1*dircos1)))/(1-((dircos1*dircos2)*(dircos1*dircos2)));

  return gamma;
}

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

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

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

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

template<typename PROD , BranchType B>

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

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

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

template<typename PROD , BranchType B>

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

inherited

Definition at line 56 of file ProducerBase.h.

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

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

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

int vertex::PrimaryVertexFinder::IndexInVertexCollection ( int  a, int  b, std::vector< std::vector< int > >  vertex_collection  )

private

Definition at line 441 of file PrimaryVertexFinder_module.cc.

References evd::details::begin().

{
  int index = -1;
  for(unsigned int i = 0; i < vertex_collection.size() ; i++){
    for(std::vector<int>::iterator itr = vertex_collection[i].begin(); itr < vertex_collection[i].end(); ++itr){
      if (a == *itr || b == *itr)
        index = i; 
    }
  }
  return index;
}

bool vertex::PrimaryVertexFinder::IsInNewVertex ( int  a, std::vector< int >  newvertex  )

private

Definition at line 453 of file PrimaryVertexFinder_module.cc.

{
  int flag = 0;
  for(unsigned int i = 0; i < newvertex.size() ; i++){
    if (a == newvertex[i]){
      flag = 1;
      break;
    }
  }
  
  if(flag==1)
    return true;
  return false; 
}

bool vertex::PrimaryVertexFinder::IsInVertexCollection ( int  a, std::vector< std::vector< int > >  vertex_collection  )

private

Definition at line 424 of file PrimaryVertexFinder_module.cc.

References evd::details::begin().

{
  int flag = 0;
  
  for(unsigned int i = 0; i < vertex_collection.size() ; i++){
    for(std::vector<int>::iterator itr = vertex_collection[i].begin(); itr < vertex_collection[i].end(); ++itr){
      if (a == *itr){
        flag = 1;
        break;
      }
    }
  }
  if(flag==1)
    return true;
  return false; 
}

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

double vertex::PrimaryVertexFinder::MinDist ( double  alpha, double  gamma, TVector3  startpoint1, TVector3  startpoint2, TVector3  dircos1, TVector3  dircos2  )

private

Definition at line 482 of file PrimaryVertexFinder_module.cc.

{
  TVector3 mindis_vector = startpoint1 - startpoint2 + alpha*dircos1 - gamma*dircos2;
  double mindis = mindis_vector.Mag();
  return mindis;
}

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.

Referenced by art::RootOutput::beginSubRun(), art::OutputModule::doBeginRun(), art::OutputModule::doBeginSubRun(), art::OutputModule::doEndRun(), art::OutputModule::doEndSubRun(), art::ProducingService::doPostReadEvent(), art::ProducingService::doPostReadRun(), art::ProducingService::doPostReadSubRun(), art::OutputModule::doWriteEvent(), 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::EventProcessor::readEvent(), art::EventProcessor::readRun(), art::EmptyEvent::readRun_(), art::EventProcessor::readSubRun(), and art::EmptyEvent::readSubRun_().

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

TVector3 vertex::PrimaryVertexFinder::PointOnExtendedTrack ( double  alphagamma, TVector3  startpoint, TVector3  dircos  )

private

Definition at line 489 of file PrimaryVertexFinder_module.cc.

References DEFINE_ART_MODULE.

{
  TVector3 PointOnExtendedTrack = startpoint + (alphagamma * dircos);
  return PointOnExtendedTrack;
}

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 vertex::PrimaryVertexFinder::produce ( art::Event &  evt )

virtual

Todo:

replace with the real query when this module is updated to look for showers too

Implements art::EDProducer.

Definition at line 142 of file PrimaryVertexFinder_module.cc.

References evd::details::begin(), util::CreateAssn(), evd::details::end(), art::EventID::event(), art::DataViewImpl::getByLabel(), hits(), art::Event::id(), art::Ptr< T >::key(), LOG_VERBATIM, art::Event::put(), sort_pred2(), track, lar::dump::vector(), x, y, and z.

  {

    mf::LogInfo("PrimaryVertexFinder") << "------------------------------------------------------------------------------";

    //   std::cout << "run    : " << evt.Header().Run() << std::endl;
    //   std::cout << "subrun : " << evt.Header().Subrun() << std::endl;
    //std::cout << "event  : " << evt.Header().Event() << std::endl;
    
    mf::LogInfo("PrimaryVertexFinder") << "event  : " << evt.id().event();
    
    
    art::ServiceHandle<geo::Geometry> geom;
    
    //mf::LogInfo("PrimaryVertexFinder") << "I am in Primary vertex finder " << std::endl;
        
    art::Handle< std::vector<recob::Track> > trackListHandle;
    evt.getByLabel(fTrackModuleLabel,trackListHandle);
    
    //Point to a collection of vertices to output.
    std::unique_ptr< std::vector<recob::Vertex> > vcol(new std::vector<recob::Vertex>);
    std::unique_ptr< art::Assns<recob::Vertex, recob::Hit> > vhassn(new art::Assns<recob::Vertex, recob::Hit>);
    std::unique_ptr< art::Assns<recob::Vertex, recob::Track> > vtassn(new art::Assns<recob::Vertex, recob::Track>);
    std::unique_ptr< art::Assns<recob::Vertex, recob::Shower> > vsassn(new art::Assns<recob::Vertex, recob::Shower>);
    

    std::vector<recob::Track> const& trkIn = *trackListHandle;

    mf::LogInfo("PrimaryVertexFinder") << "number of tracks in this event = " << trkIn.size();
    fNoTracks->Fill(evt.id().event(),trkIn.size());

    std::vector<recob::SpacePoint> startpoints_vec; // first space point of each track

    std::vector <TVector3> startvec;
    TVector3 startXYZ;
    
    std::vector <TVector3> endvec;
    TVector3 endXYZ;

    std::vector <TVector3> dircosvec;
    TVector3 dircosXYZ;

    std::vector< std::pair<art::Ptr<recob::Track>, double> > trackpair;
    
    art::FindMany<recob::SpacePoint> TrackSpacePoints
      (trackListHandle, evt, fTrackModuleLabel);
    
    for(unsigned int i = 0; i<trkIn.size(); ++i){
      recob::Track::Point_t start, end;
      std::tie(start, end) = trkIn[i].Extent();
      startXYZ.SetXYZ(start.X(),start.Y(),start.Z());
      endXYZ.SetXYZ(end.X(),end.Y(),end.Z());


      double length = (endXYZ-startXYZ).Mag();// (endvec[i]-startvec[i]).Mag();
      //mf::LogInfo("PrimaryVertexFinder") << "Track length calculated = " << length << std::endl;
      trackpair.push_back(std::pair<art::Ptr<recob::Track>,double>({ trackListHandle, i },length));
    }
    
    for(size_t i = 0; i<trackpair.size(); ++i){
      mf::LogInfo("PrimaryVertexFinder") << "track id is  = " << (trackpair[i].first)->ID() 
                                         << " track length = " << (trackpair[i].second);
    }
    
    std::sort(trackpair.rbegin(), trackpair.rend(), sort_pred2);
    
    mf::LogInfo("PrimaryVertexFinder") << "AFTER SORTING ";
    for(size_t i = 0; i < trackpair.size(); ++i){
      mf::LogInfo("PrimaryVertexFinder") << "track id is  = " << (trackpair[i].first)->ID() 
                                         << " track length = " << (trackpair[i].second);
    }
    
    if(trackpair.size()>0)
    fLength_1stTrack->Fill(trackpair[0].second);

    if(trackpair.size()>1)
    fLength_2ndTrack->Fill(trackpair[1].second);

    if(trackpair.size()>2)
    fLength_3rdTrack->Fill(trackpair[2].second);

    if(trackpair.size()>3)
    fLength_4thTrack->Fill(trackpair[3].second);

    if(trackpair.size()>4)
    fLength_5thTrack->Fill(trackpair[4].second);

    for(size_t j = 0; j < trackpair.size(); ++j) { //loop over tracks
      art::Ptr<recob::Track> const& track = trackpair[j].first;

      // the index of this track in the query is the same as its position in
      // the data product:
      std::vector<recob::SpacePoint const*> const& spacepoints
        = TrackSpacePoints.at(track.key());

      startXYZ  = trackpair[j].first->Vertex<TVector3>();
      endXYZ    = trackpair[j].first->End<TVector3>();
      dircosXYZ = trackpair[j].first->VertexDirection<TVector3>();
 
      startvec.push_back(startXYZ);
      endvec.push_back(endXYZ);
      dircosvec.push_back(dircosXYZ);
      
      mf::LogInfo("PrimaryVertexFinder") << "PrimaryVertexFinder got "<< spacepoints.size() 
                                         <<" 3D spacepoint(s) from Track3Dreco.cxx";
            
      // save the first SpacePoint of each Track... from now the SpacePoint ID represents the Track ID!!
      startpoints_vec.emplace_back(
        spacepoints[0]->XYZ(), spacepoints[0]->ErrXYZ(),
        spacepoints[0]->Chisq(), startpoints_vec.size()
        );
    
    }// loop over tracks

    for(size_t i = 0; i < startvec.size();  ++i){ //trackpair.size()
      mf::LogInfo("PrimaryVertexFinder") << "Tvector3 start point SORTED = ";
      startvec[i].Print();
    }
    for(size_t i = 0; i < dircosvec.size(); ++i){ //trackpair.size()
      mf::LogInfo("PrimaryVertexFinder") << "Tvector3 dir cos SORTED = ";
      dircosvec[i].Print();
    }

    std::vector<std::vector<int> > vertex_collection_int;
    std::vector <std::vector <TVector3> > vertexcand_vec;

    for (unsigned int i=0; i<trackpair.size(); ++i){
      for (unsigned int j=i+1; j<trackpair.size(); ++j){
        mf::LogInfo("PrimaryVertexFinder") << "distance between " << i << " and " << j 
                                           << " = " 
                                           << StartPointSeperation(startpoints_vec[i], startpoints_vec[j]);
        double GAMMA = gammavalue(startvec[i], startvec[j], dircosvec[i], dircosvec[j]);
        double ALPHA = alphavalue(GAMMA, startvec[i], startvec[j], dircosvec[i], dircosvec[j]);
        double MINDIST = MinDist(ALPHA, GAMMA, startvec[i], startvec[j], dircosvec[i], dircosvec[j]);
        mf::LogInfo("PrimaryVertexFinder") << "alpha = " << ALPHA << " gamma = " 
                                           << GAMMA << " MINIMUM DISTANCE = " << MINDIST;

        TVector3 TRACK1POINT = PointOnExtendedTrack(ALPHA, startvec[i], dircosvec[i]);
        TVector3 TRACK2POINT = PointOnExtendedTrack(GAMMA, startvec[j], dircosvec[j]);

        mf::LogInfo("PrimaryVertexFinder") << "POINTS ON THE TRACKS ARE:: ";
        TRACK1POINT.Print();
        TRACK2POINT.Print();

        //if(StartPointSeperation(startpoints_vec[i], startpoints_vec[j])<fVertexWindow){ ///// correct this
        //if(MINDIST<2 && trackpair[i].second >30 && trackpair[j].second >30){
        if(MINDIST < fVertexWindow && ((TRACK1POINT-startvec[i]).Mag()) < fVertexWindow){

          if((!IsInVertexCollection(i, vertex_collection_int)) && (!IsInVertexCollection(j, vertex_collection_int))){
            std::vector<int> newvertex_int;
            std::vector <TVector3> vertexcand;
            newvertex_int.push_back(i);
            newvertex_int.push_back(j);
            vertex_collection_int.push_back(newvertex_int);
            //newvertex.clear();
            vertexcand.push_back(TRACK1POINT);
            vertexcand.push_back(TRACK2POINT);
            vertexcand_vec.push_back(vertexcand);
          }
          else{
            int index = IndexInVertexCollection(i, j, vertex_collection_int);
            //mf::LogInfo("PrimaryVertexFinder") << "index where a new vertex will be added = " << index << std::endl;
            if(!IsInNewVertex(i, vertex_collection_int[index])){
              vertex_collection_int[index].push_back(i);
              vertexcand_vec[index].push_back(TRACK1POINT); //need to fix for delta rays
            }
            if(!IsInNewVertex(j, vertex_collection_int[index])){
              vertex_collection_int[index].push_back(j);
              vertexcand_vec[index].push_back(TRACK2POINT); //need to fix for delta rays
            }
          }
        }// end else
      }
    }

    
    //now add the unmatched track IDs to the collection
    for(size_t i = 0; i < trackpair.size(); ++i){
      if(!IsInVertexCollection(i, vertex_collection_int)){
        //if(trackpair[i].second>30){
        std::vector<int> temp;
        std::vector <TVector3> temp1;
        temp.push_back(i);
        temp1.push_back(startvec[i]);   
        vertex_collection_int.push_back(temp);
        vertexcand_vec.push_back(temp1);
        //}
      }
    }

    // indices (in their data products) of tracks and showers connected to the vertex
    std::vector<size_t> vTrackIndices, vShowerIndices;

    // find the hits of all the tracks
    art::FindManyP<recob::Hit> TrackHits(trackListHandle, evt, fTrackModuleLabel);
    
    // find the hits of all the showers
  //  art::FindManyP<recob::Hit> ShowerHits(showerListHandle, evt, fShowerModuleLabel);
    art::FindManyP<recob::Hit> ShowerHits(std::vector<art::Ptr<recob::Shower>>(), evt, fTrackModuleLabel);
    
    for(size_t i = 0; i < vertex_collection_int.size(); ++i){
      double x = 0.;
      double y = 0.;
      double z = 0.;
      int elemsize = 0.;
      for(std::vector<int>::iterator itr = vertex_collection_int[i].begin(); itr < vertex_collection_int[i].end(); ++itr){
        mf::LogInfo("PrimaryVertexFinder") << "vector elements at index " << i << " are " << *itr
                                           << "\ntrack original ID = " << (trackpair[*itr].first)->ID();
        // save the index in the data product of this track
        vTrackIndices.push_back(trackpair[*itr].first.key());
      }
      mf::LogInfo("PrimaryVertexFinder") << "------------";

      
      for(std::vector<TVector3>::iterator itr = vertexcand_vec[i].begin(); itr < vertexcand_vec[i].end(); ++itr){
        //calculate sum of x, y and z of a vertex
        x += (*itr).X();
        y += (*itr).Y();
        z += (*itr).Z();
        elemsize = vertexcand_vec[i].size();
      }

      double avgx = x/elemsize;
      double avgy = y/elemsize;
      double avgz = z/elemsize;
      
      Double_t vtxcoord[3];
      vtxcoord[0] = avgx;
      vtxcoord[1] = avgy;
      vtxcoord[2] = avgz;    
      
      recob::Vertex the3Dvertex(vtxcoord, vcol->size());
      vcol->push_back(the3Dvertex);

      if(!vTrackIndices.empty()){
        // associate the tracks and their hits with the vertex
        util::CreateAssn(*this, evt, *vtassn,
          vcol->size() - 1, vTrackIndices.begin(), vTrackIndices.end());
        for(size_t tIndex: vTrackIndices) {
          std::vector<art::Ptr<recob::Hit>> const& hits = TrackHits.at(tIndex);
          util::CreateAssn(*this, evt, *vcol, hits, *vhassn);
        }
        vTrackIndices.clear();
      } // if tracks

      if(!vShowerIndices.empty()){
        // associate the showers and their hits with the vertex
        util::CreateAssn(*this, evt, *vsassn,
          vcol->size() - 1, vShowerIndices.begin(), vShowerIndices.end());
        for(size_t sIndex: vShowerIndices){
          std::vector<art::Ptr<recob::Hit>> const& hits = ShowerHits.at(sIndex);
          util::CreateAssn(*this, evt, *vcol, hits, *vhassn);
        }
        vShowerIndices.clear();
      } // if showers

      
    }// end loop over vertex_collection_ind

    LOG_VERBATIM("Summary") << std::setfill('-') << std::setw(175) << "-" << std::setfill(' ');
    LOG_VERBATIM("Summary") << "PrimaryVertexFinder Summary:";
    for(size_t i = 0; i < vcol->size(); ++i) LOG_VERBATIM("Summary") << vcol->at(i) ;

    evt.put(std::move(vcol));
    evt.put(std::move(vtassn));
    evt.put(std::move(vhassn));
    evt.put(std::move(vsassn));
    
  } // end of produce

void vertex::PrimaryVertexFinder::reconfigure

(

fhicl::ParameterSet const &

p

)

Definition at line 121 of file PrimaryVertexFinder_module.cc.

References fhicl::ParameterSet::get().

  {
    fTrackModuleLabel  = p.get< std::string >("TrackModuleLabel");
    fVertexWindow      = p.get<double     >  ("VertexWindow");
    return;
  }

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

double vertex::PrimaryVertexFinder::StartPointSeperation ( recob::SpacePoint  sp1, recob::SpacePoint  sp2  )

private

Definition at line 415 of file PrimaryVertexFinder_module.cc.

References x, recob::SpacePoint::XYZ(), y, and z.

{
  double x= (sp2.XYZ()[0])-(sp1.XYZ()[0]);
  double y= (sp2.XYZ()[1])-(sp1.XYZ()[1]);
  double z= (sp2.XYZ()[2])-(sp1.XYZ()[2]);
  double distance = std::sqrt(pow(x,2)+pow(y,2)+pow(z,2));
  return distance;
}

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

TH1F* vertex::PrimaryVertexFinder::fLength_1stTrack

private

Definition at line 87 of file PrimaryVertexFinder_module.cc.

TH1F* vertex::PrimaryVertexFinder::fLength_2ndTrack

private

Definition at line 88 of file PrimaryVertexFinder_module.cc.

TH1F* vertex::PrimaryVertexFinder::fLength_3rdTrack

private

Definition at line 89 of file PrimaryVertexFinder_module.cc.

TH1F* vertex::PrimaryVertexFinder::fLength_4thTrack

private

Definition at line 90 of file PrimaryVertexFinder_module.cc.

TH1F* vertex::PrimaryVertexFinder::fLength_5thTrack

private

Definition at line 91 of file PrimaryVertexFinder_module.cc.

TH2F* vertex::PrimaryVertexFinder::fNoTracks

private

Definition at line 86 of file PrimaryVertexFinder_module.cc.

std::string vertex::PrimaryVertexFinder::fTrackModuleLabel

private

Definition at line 76 of file PrimaryVertexFinder_module.cc.

double vertex::PrimaryVertexFinder::fVertexWindow

private

Definition at line 77 of file PrimaryVertexFinder_module.cc.

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/VertexFinder/PrimaryVertexFinder_module.cc