tutorial::ReadSpacePointAndCnn Class Reference

Inheritance diagram for tutorial::ReadSpacePointAndCnn:

Classes
struct	Config

Public Types
using	Parameters = art::EDAnalyzer::Table< Config >
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer

Public Member Functions
	ReadSpacePointAndCnn (Parameters const &config)
	ReadSpacePointAndCnn (ReadSpacePointAndCnn const &)=delete
	ReadSpacePointAndCnn (ReadSpacePointAndCnn &&)=delete
ReadSpacePointAndCnn &	operator= (ReadSpacePointAndCnn const &)=delete
ReadSpacePointAndCnn &	operator= (ReadSpacePointAndCnn &&)=delete
void	analyze (art::Event const &e) override
void	beginJob () override
void	endJob () override
Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDAnalyzer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept
	Analyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	Analyzer (Table< Config > const &config)
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::Observer
	~Observer () noexcept
	Observer (Observer const &)=delete
	Observer (Observer &&)=delete
Observer &	operator= (Observer const &)=delete
Observer &	operator= (Observer &&)=delete
void	registerProducts (ProductDescriptions &, ModuleDescription const &)
void	fillDescriptions (ModuleDescription const &)
fhicl::ParameterSetID	selectorConfig () const
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	clear ()

Private Attributes
size_t	fEvNumber
TTree *	fEventTree
size_t	fNHits [3]
size_t	fNPoints
std::vector< unsigned char >	fHitTpc [3]
std::vector< float >	fHitWire [3]
std::vector< float >	fHitTime [3]
std::vector< float >	fHitCharge [3]
std::vector< float >	fPointX
std::vector< float >	fPointY
std::vector< float >	fPointZ
std::vector< float >	fPointCharge
std::vector< float >	fPointEmScore
art::InputTag	fHitsModuleLabel
art::InputTag	fSpacePointModuleLabel
art::InputTag	fCnnModuleLabel

Additional Inherited Members
Protected Member Functions inherited from art::Observer
std::string const &	processName () const
bool	wantAllEvents () const noexcept
bool	wantEvent (ScheduleID id, Event const &e) const
Handle< TriggerResults >	getTriggerResults (Event const &e) const
	Observer (fhicl::ParameterSet const &config)
	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)
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 36 of file ReadSpacePointAndCnn_module.cc.

Member Typedef Documentation

using tutorial::ReadSpacePointAndCnn::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 55 of file ReadSpacePointAndCnn_module.cc.

Constructor & Destructor Documentation

tutorial::ReadSpacePointAndCnn::ReadSpacePointAndCnn ( Parameters const &  config )

explicit

Definition at line 96 of file ReadSpacePointAndCnn_module.cc.

                                                                   : art::EDAnalyzer(config),
    fHitsModuleLabel(config().HitsModuleLabel()),
    fSpacePointModuleLabel(config().SpacePointModuleLabel()),
    fCnnModuleLabel(config().CnnModuleLabel())
{
}

tutorial::ReadSpacePointAndCnn::ReadSpacePointAndCnn ( ReadSpacePointAndCnn const &  )

delete

tutorial::ReadSpacePointAndCnn::ReadSpacePointAndCnn ( ReadSpacePointAndCnn &&  )

delete

Member Function Documentation

void tutorial::ReadSpacePointAndCnn::analyze ( art::Event const &  e )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 145 of file ReadSpacePointAndCnn_module.cc.

{
    clear();

    fEvNumber = evt.id().event();
    mf::LogVerbatim("ReadSpacePointAndCnn") << "ReadSpacePointAndCnn module on event #" << fEvNumber;

    // store 2D hits info, sorted by plane (but not by TPC, you need to select
    // on that later in your analysis)
    auto hitsHandle = evt.getValidHandle< std::vector<recob::Hit> >(fHitsModuleLabel);
    fNHits[0] = 0; fNHits[1] = 0; fNHits[2] = 0;

    for (const auto & h : *hitsHandle)
    {
        size_t p = h.WireID().Plane;
        fHitTpc[p].push_back(h.WireID().TPC);
        fHitWire[p].push_back(h.WireID().Wire);
        fHitTime[p].push_back(h.PeakTime());
        fHitCharge[p].push_back(h.Integral());
        fNHits[p]++;
    }

    // store SpacePoints basic info
    auto spHandle = evt.getValidHandle< std::vector<recob::SpacePoint> >(fSpacePointModuleLabel);
    auto qHandle = evt.getValidHandle< std::vector<recob::PointCharge> >(fSpacePointModuleLabel);
    if (spHandle->size() != qHandle->size())
    {
        throw cet::exception("tutorial::ReadSpacePointAndCnn")
            << "size of point and charge containers must be equal" << std::endl;
    }

    fNPoints = spHandle->size();
    fPointX.resize(fNPoints); fPointY.resize(fNPoints); fPointZ.resize(fNPoints);
    fPointCharge.resize(fNPoints);
    fPointEmScore.resize(fNPoints);

    for (size_t i = 0; i < spHandle->size(); ++i)
    {
        fPointX[i] = (*spHandle)[i].XYZ()[0];
        fPointY[i] = (*spHandle)[i].XYZ()[1];
        fPointZ[i] = (*spHandle)[i].XYZ()[2];
        fPointCharge[i] = (*qHandle)[i].charge();
        fPointEmScore[i] = 0.5; // neutral P(EM-like) value
    }

    // and tag SpacePoints with EM-like scores calculated by CNN on the cluster level
    // connect these scores to SpacePoints throuh hits, and choose the score of the
    // largest cluster containing the hit associated to SpacePoint;
    // other option could be e.g.: use CNN scores on the hit level, multiplying scores
    // from hits in all planes
    auto cluResults = anab::MVAReader<recob::Cluster, MVA_LENGTH>::create(evt, fCnnModuleLabel);
    if (cluResults)
    {
        size_t emLikeIdx = cluResults->getIndex("em"); // at which index EM-like is stored in CNN output vector

        const art::FindManyP<recob::Hit> hitsFromClusters(cluResults->dataHandle(), evt, cluResults->dataTag());
        const art::FindManyP<recob::SpacePoint> spFromHits(hitsHandle, evt, fSpacePointModuleLabel);

        std::vector<size_t> sizeScore(fNPoints, 0); // keep track of the max size of a cluster containing hit associated to spacepoint

        for (size_t c = 0; c < cluResults->size(); ++c)
        {
            //const recob::Cluster & clu = cluResults->item(c); // one can get the cluster object in this way, here not really used

            const std::vector< art::Ptr<recob::Hit> > & hits = hitsFromClusters.at(c);
            std::array<float, MVA_LENGTH> cnn_out = cluResults->getOutput(c);

            for (const auto & hptr : hits)
            {
                const std::vector< art::Ptr<recob::SpacePoint> > & sp = spFromHits.at(hptr.key());
                for (const auto & spptr : sp) // with SpacePointSolver should be just 1 hit, but be prepared for any other algorithm
                {
                    if (hits.size() > sizeScore[spptr.key()])
                    {
                        sizeScore[spptr.key()] = hits.size();
                        fPointEmScore[spptr.key()] = cnn_out[emLikeIdx];
                    }
                }
             }
        }
    }

    fEventTree->Fill();

    clear();
}

void tutorial::ReadSpacePointAndCnn::beginJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 103 of file ReadSpacePointAndCnn_module.cc.

{
    art::ServiceHandle<art::TFileService> tfs; // TTree's are created in the memory managed by ROOT (you don't delete them)

    fEventTree = tfs->make<TTree>("EventTree", "event by event info");
    fEventTree->Branch("event", &fEvNumber, "fEvNumber/I");
    fEventTree->Branch("nhits", &fNHits, "fNHits[3]/I");
    fEventTree->Branch("npoints", &fNPoints, "fNPoints/I");

    fEventTree->Branch("hit0tpc", &fHitTpc[0]);
    fEventTree->Branch("hit0w", &fHitWire[0]);
    fEventTree->Branch("hit0t", &fHitTime[0]);
    fEventTree->Branch("hit0q", &fHitCharge[0]);

    fEventTree->Branch("hit1tpc", &fHitTpc[1]);
    fEventTree->Branch("hit1w", &fHitWire[1]);
    fEventTree->Branch("hit1t", &fHitTime[1]);
    fEventTree->Branch("hit1q", &fHitCharge[1]);

    fEventTree->Branch("hit2tpc", &fHitTpc[2]);
    fEventTree->Branch("hit2w", &fHitWire[2]);
    fEventTree->Branch("hit2t", &fHitTime[2]);
    fEventTree->Branch("hit2q", &fHitCharge[2]);

    fEventTree->Branch("pointx", &fPointX);
    fEventTree->Branch("pointy", &fPointY);
    fEventTree->Branch("pointz", &fPointZ);
    fEventTree->Branch("pointq", &fPointCharge);
    fEventTree->Branch("emscore", &fPointEmScore);
}

void tutorial::ReadSpacePointAndCnn::clear ( )

private

Definition at line 134 of file ReadSpacePointAndCnn_module.cc.

{
    for (size_t p = 0; p < 3; ++p)
    {
        fHitTpc[p].clear();
        fHitWire[p].clear();
        fHitTime[p].clear();
        fHitCharge[p].clear();
    }
}

void tutorial::ReadSpacePointAndCnn::endJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 232 of file ReadSpacePointAndCnn_module.cc.

{
    mf::LogVerbatim("ReadSpacePointAndCnn") << "ReadSpacePointAndCnn finished job";
}

ReadSpacePointAndCnn& tutorial::ReadSpacePointAndCnn::operator= ( ReadSpacePointAndCnn const &  )

delete

ReadSpacePointAndCnn& tutorial::ReadSpacePointAndCnn::operator= ( ReadSpacePointAndCnn &&  )

delete

Member Data Documentation

art::InputTag tutorial::ReadSpacePointAndCnn::fCnnModuleLabel

private

Definition at line 93 of file ReadSpacePointAndCnn_module.cc.

TTree* tutorial::ReadSpacePointAndCnn::fEventTree

private

Definition at line 74 of file ReadSpacePointAndCnn_module.cc.

size_t tutorial::ReadSpacePointAndCnn::fEvNumber

private

Definition at line 72 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fHitCharge[3]

private

Definition at line 83 of file ReadSpacePointAndCnn_module.cc.

art::InputTag tutorial::ReadSpacePointAndCnn::fHitsModuleLabel

private

Definition at line 91 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fHitTime[3]

private

Definition at line 83 of file ReadSpacePointAndCnn_module.cc.

std::vector<unsigned char> tutorial::ReadSpacePointAndCnn::fHitTpc[3]

private

Definition at line 82 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fHitWire[3]

private

Definition at line 83 of file ReadSpacePointAndCnn_module.cc.

size_t tutorial::ReadSpacePointAndCnn::fNHits[3]

private

Definition at line 77 of file ReadSpacePointAndCnn_module.cc.

size_t tutorial::ReadSpacePointAndCnn::fNPoints

private

Definition at line 78 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fPointCharge

private

Definition at line 87 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fPointEmScore

private

Definition at line 88 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fPointX

private

Definition at line 86 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fPointY

private

Definition at line 86 of file ReadSpacePointAndCnn_module.cc.

std::vector<float> tutorial::ReadSpacePointAndCnn::fPointZ

private

Definition at line 86 of file ReadSpacePointAndCnn_module.cc.

art::InputTag tutorial::ReadSpacePointAndCnn::fSpacePointModuleLabel

private

Definition at line 92 of file ReadSpacePointAndCnn_module.cc.

---

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

• protoduneana/protoduneana/TutorialExamples/ReadSpacePointAndCnn_module.cc