event::EventCheater Class Reference

Inheritance diagram for event::EventCheater:

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

Private Member Functions
void	produce (art::Event &evt)

Private Attributes
std::string	fCheatedVertexLabel
	label for module creating recob::Vertex objects More...
std::string	fG4ModuleLabel
	label for module running G4 and making particles, etc More...

Detailed Description

Definition at line 33 of file EventCheater_module.cc.

Constructor & Destructor Documentation

event::EventCheater::EventCheater ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 50 of file EventCheater_module.cc.

    : EDProducer{pset}
  {
    fCheatedVertexLabel = pset.get< std::string >("CheatedVertexLabel", "prong" );
    fG4ModuleLabel      = pset.get< std::string >("G4ModuleLabel",      "largeant");

    produces< std::vector<recob::Event> >();
    produces< art::Assns<recob::Event, recob::Vertex> >();
    produces< art::Assns<recob::Event, recob::Hit> >();
  }

Member Function Documentation

void event::EventCheater::produce ( art::Event &  evt )

private

Definition at line 62 of file EventCheater_module.cc.

  {

    art::View<simb::MCParticle> pcol;
    evt.getView(fG4ModuleLabel, pcol);

    art::FindOneP<simb::MCTruth> fo(pcol, evt, fG4ModuleLabel);

    // make a map of the track id for each sim::Particle to its entry in the
    // collection of sim::Particles
    std::map<int, int> trackIDToPColEntry;
    for(size_t p = 0; p < pcol.vals().size(); ++p) trackIDToPColEntry[pcol.vals().at(p)->TrackId()] = p;

    // grab the vertices that have been reconstructed
    art::Handle< std::vector<recob::Vertex> > vertexcol;
    evt.getByLabel(fCheatedVertexLabel, vertexcol);

    art::FindManyP<recob::Hit> fm(vertexcol, evt, fCheatedVertexLabel);

    // make a vector of them - we aren't writing anything out to a file
    // so no need for a art::PtrVector here
    std::vector< art::Ptr<recob::Vertex> > vertices;
    art::fill_ptr_vector(vertices, vertexcol);

    // loop over the vertices and figure out which primaries they are associated with
    std::vector< art::Ptr<recob::Vertex> >::iterator vertexitr = vertices.begin();

    // make a map of primary product id's to collections of vertices
    std::map<art::Ptr<simb::MCTruth>, std::vector< art::Ptr<recob::Vertex> > > vertexMap;
    std::map<art::Ptr<simb::MCTruth>, std::vector< art::Ptr<recob::Vertex> > >::iterator vertexMapItr = vertexMap.begin();

    // loop over all prongs
    while( vertexitr != vertices.end() ){

      size_t pcolEntry = trackIDToPColEntry.find((*vertexitr)->ID())->second;
      const art::Ptr<simb::MCTruth> primary = fo.at(pcolEntry);

      vertexMap[primary].push_back(*vertexitr);

      vertexitr++;
    }// end loop over vertices

    std::unique_ptr< std::vector<recob::Event> >               eventcol(new std::vector<recob::Event>);
    std::unique_ptr< art::Assns<recob::Event, recob::Vertex> > evassn(new art::Assns<recob::Event, recob::Vertex>);
    std::unique_ptr< art::Assns<recob::Event, recob::Hit> >    ehassn(new art::Assns<recob::Event, recob::Hit>);

    // loop over the map and associate all vertex objects with an event
    for(vertexMapItr = vertexMap.begin(); vertexMapItr != vertexMap.end(); vertexMapItr++){

      art::PtrVector<recob::Vertex> ptrvs;

      std::vector< art::Ptr<recob::Vertex> > verts( (*vertexMapItr).second );

      // add an event to the collection.
      eventcol->push_back(recob::Event(eventcol->size()-1));

      // associate the event with its vertices
      util::CreateAssn(*this, evt, *eventcol, verts, *evassn);

      // get the hits associated with each vertex and associate those with the event
      for(size_t p = 0; p < ptrvs.size(); ++p){
        std::vector< art::Ptr<recob::Hit> > hits = fm.at(p);
        util::CreateAssn(*this, evt, *eventcol, hits, *ehassn);
      }


      mf::LogInfo("EventCheater") << "adding event: \n"
                                  << eventcol->back()
                                  << "\nto collection";

    } // end loop over the map

    evt.put(std::move(eventcol));
    evt.put(std::move(evassn));
    evt.put(std::move(ehassn));

    return;

  } // end produce

Member Data Documentation

std::string event::EventCheater::fCheatedVertexLabel

private

label for module creating recob::Vertex objects

Definition at line 41 of file EventCheater_module.cc.

std::string event::EventCheater::fG4ModuleLabel

private

label for module running G4 and making particles, etc

Definition at line 42 of file EventCheater_module.cc.

---

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

• EventCheater_module.cc