Inheritance diagram for cvn::GCNGraphMakerProtoDUNE:

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

	~GCNGraphMakerProtoDUNE ()

void	produce (art::Event &evt)

void	beginJob ()

void	endJob ()

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 Attributes
std::string	fSpacePointLabel
	Module label for input space points. More...

unsigned short	fMinClusterHits
	Minimum number of space points to produce a graph. More...

std::vector< float >	fNeighbourRadii
	Radii for calculating number of neighbours for any number of cut values. More...

bool	fUseBeamSliceOnly
	Use only the beam slice as determined by Pandora. More...

bool	fUseAllSlices

std::string	fSliceLabel
	Slicing module (typically Pandora) More...

std::string	fParticleLabel
	PFParticle module (typically Pandora) More...

bool	fUseEM

bool	fUseHitsForTruthMatching

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 31 of file GCNGraphMakerProtoDUNE_module.cc.

Constructor & Destructor Documentation

cvn::GCNGraphMakerProtoDUNE::GCNGraphMakerProtoDUNE ( fhicl::ParameterSet const & pset )

explicit

Definition at line 72 of file GCNGraphMakerProtoDUNE_module.cc.

                                                                              : art::EDProducer(pset),
   fSpacePointLabel (pset.get<std::string>    ("SpacePointLabel")),
   fMinClusterHits  (pset.get<unsigned short> ("MinClusterHits")),
   fNeighbourRadii (pset.get<std::vector<float>>("NeighbourRadii")),
   fUseBeamSliceOnly(pset.get<bool>("UseBeamSliceOnly")),
   fUseAllSlices(pset.get<bool>("UseAllSlices")),
   fSliceLabel      (pset.get<std::string>("SliceModuleLabel")),
   fParticleLabel   (pset.get<std::string>("ParticleModuleLabel")),
   fUseEM           (pset.get<bool>("UseEM",true)),
   fUseHitsForTruthMatching (pset.get<bool>("UseHitsForTruthMatching",true))
   {
 
     produces< std::vector<cvn::GCNGraph> >();
 
   }

cvn::GCNGraphMakerProtoDUNE::~GCNGraphMakerProtoDUNE ( )

Definition at line 89 of file GCNGraphMakerProtoDUNE_module.cc.

   {
     //======================================================================
     // Clean up any memory allocated by your module
     //======================================================================
   }

Member Function Documentation

void cvn::GCNGraphMakerProtoDUNE::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 97 of file GCNGraphMakerProtoDUNE_module.cc.

98 { }

void cvn::GCNGraphMakerProtoDUNE::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 101 of file GCNGraphMakerProtoDUNE_module.cc.

102 {

103 }

void cvn::GCNGraphMakerProtoDUNE::produce ( art::Event & evt )

virtual

Implements art::EDProducer.

Definition at line 106 of file GCNGraphMakerProtoDUNE_module.cc.

   {
 
 
     // Create the Graph vector and fill it if we have enough hits
     std::unique_ptr<std::vector<cvn::GCNGraph>> graphs(new std::vector<cvn::GCNGraph>);
     //    std::cout << "GCNGraphMakerProtoDUNE: checking if we have enough space points (" << pointList.size() << " / " << fMinClusterHits << ")" << std::endl;
     // Vector for all of the space points
     // Get the space points from the event
     std::vector<art::Ptr<recob::SpacePoint>> allSpacePoints;
     auto spacePointHandle = evt.getHandle<std::vector<recob::SpacePoint>>(fSpacePointLabel);
     if (spacePointHandle){
       art::fill_ptr_vector(allSpacePoints, spacePointHandle);
     }
 
     // Graph space points for each slice we want to consider
     std::map<unsigned int,std::map<unsigned int,art::Ptr<recob::SpacePoint>>> allGraphSpacePoints;
 
     // Get the utility to help us calculate features
     cvn::GCNFeatureUtils graphUtil;
 
     // We can calculate the number of neighbours for each space point with some radius
     // Store the number of neighbours for each spacepoint ID, for each slice. If we
     // only want the beam slice, or all of the slices together, this will have one
     // element
     std::map<unsigned int,std::vector<std::map<int,unsigned int>>> neighbourMap;
 
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     if(fUseAllSlices || fUseBeamSliceOnly){
       // We need to get a vector of space points from the beam slice
       cvn::CVNProtoDUNEUtils pfpUtil;
 
       const unsigned short beamSliceIndex = pfpUtil.GetBeamSlice(evt,fParticleLabel);
       if(beamSliceIndex > 500 && fUseBeamSliceOnly){
         std::cerr << "Requested beam slice only yet one didn't exist, returning no graphs" << std::endl; 
         evt.put(std::move(graphs));
         return;
       }
 
       // Get a map of slice index to all of the PFParticles within it
       const std::map<unsigned int,std::vector<const recob::PFParticle*>> particleSliceMap = pfpUtil.GetAllPFParticleSliceMap(evt, fParticleLabel);
       for(const std::pair<unsigned int,std::vector<const recob::PFParticle*>> m : particleSliceMap){
         unsigned int sliceID = m.first;
         std::map<unsigned int,art::Ptr<recob::SpacePoint>> sliceSpacePoints;
         // If we want the beam slice then make sure we have it
         if(fUseBeamSliceOnly && (sliceID != beamSliceIndex)) continue;
 
         for(const recob::PFParticle* p : m.second){
           // Get the SpacePoints associated to the PFParticle
           const std::vector<const recob::SpacePoint*> particlePoints = pfpUtil.GetPFParticleSpacePoints(*p, evt, fParticleLabel);
           //std::cout << "Got beam slice particle with " << particlePoints.size() << " space points" << std::endl;
           for(const recob::SpacePoint* s : particlePoints){
             sliceSpacePoints.insert(std::make_pair(s->ID(),allSpacePoints.at(s->ID())));
           }
         }
         allGraphSpacePoints[sliceID] = sliceSpacePoints;
         neighbourMap.insert(std::make_pair(sliceID,graphUtil.GetNeighboursForRadii(evt,fNeighbourRadii,sliceSpacePoints)));
       }
     }
     else{
       std::vector<art::Ptr<recob::SpacePoint>> eventSpacePoints;
       spacePointHandle = evt.getHandle<std::vector<recob::SpacePoint>>(fSpacePointLabel);
       if (spacePointHandle){
         art::fill_ptr_vector(eventSpacePoints, spacePointHandle);
       }
       //Convert this vector to a map
       std::map<unsigned int,art::Ptr<recob::SpacePoint>> mapVec;
       for(art::Ptr<recob::SpacePoint> p : eventSpacePoints){
         mapVec.insert(std::make_pair(p->ID(),p));
       }
       neighbourMap.insert(std::make_pair(0,graphUtil.GetNeighboursForRadii(evt,fNeighbourRadii,eventSpacePoints)));
       allGraphSpacePoints.insert(std::make_pair(0,mapVec));
     }
 
     // Get some maps we'll need to fill our features
     std::cout << "Found all neighbours for " << neighbourMap.size() << " slices, building graphs..." << std::endl;
 
     // Function is linear in number of points so just do it once
     std::map<unsigned int,float> chargeMap = graphUtil.GetSpacePointChargeMap(evt,fSpacePointLabel);
 
     // Mean hit RMS for each spacepoint
     std::map<unsigned int, float> hitRMSMap = graphUtil.GetSpacePointMeanHitRMSMap(evt,fSpacePointLabel);
 
     // The true particle PDG code is needed for training node classifiers
     std::map<unsigned int,int> trueIDMap = graphUtil.GetTruePDG(clockData, evt, fSpacePointLabel, !fUseEM, fUseHitsForTruthMatching);
 
     // Now we want to produce a graph for each one of the slices
     for(const std::pair<unsigned int,std::map<unsigned int,art::Ptr<recob::SpacePoint>>> &sps : allGraphSpacePoints){
       if(sps.second.size() >= fMinClusterHits){
        
         cvn::GCNGraph newGraph;
 
         std::map<int,std::pair<int,int>> twoNearest = graphUtil.GetTwoNearestNeighbours(evt,sps.second);
 
         std::cout << "Constructing graph for slice " << sps.first << " with " << sps.second.size() << " nodes." << std::endl;
         for(const std::pair<unsigned int,art::Ptr<recob::SpacePoint>> &sp : sps.second){
   
           // Get the position
           std::vector<float> position;
           // Why does this use an array... we want a vector in any case
           const double *pos = sp.second->XYZ();
           for(unsigned int p = 0; p < 3; ++p) position.push_back(pos[p]);
   
           // Calculate some features
           std::vector<float> features;
   
           // The neighbour map gives us our first feature(s)
           for(unsigned int m = 0; m < fNeighbourRadii.size(); ++m){
             features.push_back(neighbourMap.at(sps.first)[m].at(sp.second->ID()));
           }
   
           // How about charge?
           features.push_back(chargeMap.at(sp.second->ID()));
   
           // Now the hit width
 //          features.push_back(hitRMSMap.at(sp.second->ID()));
 
           // Angle and dot product between node and its two nearest neighbours
           float angle = -999.;
           float dotProduct = -999.;
           int n1ID = twoNearest[sp.second->ID()].first;
           int n2ID = twoNearest[sp.second->ID()].second;
           const recob::SpacePoint n1 = *(sps.second.at(n1ID).get());
           const recob::SpacePoint n2 = *(sps.second.at(n2ID).get());
           graphUtil.GetAngleAndDotProduct(*(sp.second.get()),n1,n2,dotProduct,angle);
           features.push_back(dotProduct);
           features.push_back(angle);
   
           // We set the "ground truth" as the particle PDG code in this case
           std::vector<float> truePDG;
           truePDG.push_back(static_cast<float>(trueIDMap.at(sp.second->ID())));
           newGraph.AddNode(position,features,truePDG);
 //          if(abs(trueIDMap.at(sp.second->ID())) != 13) std::cout << "Adding node " << sp.second->ID() << " with neighbours " << n1ID << " and " << n2ID << " and PDG = " << truePDG[0] << std::endl;
         }
   
         std::cout << "GCNGraphMakerProtoDUNE: produced GCNGraph object with " << newGraph.GetNumberOfNodes() << " nodes" << std::endl;
   
         // Add out graph to the vector
         graphs->push_back(newGraph);
       }
     }
 
     // Write our graph to the event
     evt.put(std::move(graphs));
   }