Inheritance diagram for nnet::PointIdTrainingData:

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
	PointIdTrainingData (Parameters const &config)

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	analyze (const art::Event &event) override

Private Attributes
nnet::TrainingDataAlg	fTrainingDataAlg

std::string	fOutTextFilePath

bool	fDumpToRoot

std::vector< int >	fSelectedTPC

std::vector< int >	fSelectedPlane

int	fEvent

int	fRun
	number of the event being processed More...

int	fSubRun
	number of the run being processed More...

bool	fCrop
	number of the sub-run being processed More...

geo::GeometryCore const *	fGeometry
	crop data to event (set to false when dumping noise!) More...

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 50 of file PointIdTrainingData_module.cc.

Member Typedef Documentation

using nnet::PointIdTrainingData::Parameters = art::EDAnalyzer::Table<Config>

Definition at line 76 of file PointIdTrainingData_module.cc.

Constructor & Destructor Documentation

nnet::PointIdTrainingData::PointIdTrainingData ( PointIdTrainingData::Parameters const & config )

explicit

Definition at line 102 of file PointIdTrainingData_module.cc.

     : art::EDAnalyzer(config)
     , fTrainingDataAlg(config().TrainingDataAlg())
     , fOutTextFilePath(config().OutTextFilePath())
     , fDumpToRoot(config().DumpToRoot())
     , fSelectedTPC(config().SelectedTPC())
     , fSelectedPlane(config().SelectedView())
     , fCrop(config().Crop())
   {
     fGeometry = &*(art::ServiceHandle<geo::Geometry const>());
 
     const size_t TPC_CNT = (size_t)fGeometry->NTPC(0);
     if (fSelectedTPC.empty()) {
       for (size_t tpc = 0; tpc < TPC_CNT; ++tpc)
         fSelectedTPC.push_back(tpc);
     }
 
     if (fSelectedPlane.empty()) {
       for (size_t p = 0; p < fGeometry->MaxPlanes(); ++p)
         fSelectedPlane.push_back(p);
     }
   }

Member Function Documentation

void nnet::PointIdTrainingData::analyze ( const art::Event & event )

overrideprivate

Definition at line 127 of file PointIdTrainingData_module.cc.

   {
     fEvent = event.id().event();
     fRun = event.run();
     fSubRun = event.subRun();
 
     bool saveSim = fTrainingDataAlg.saveSimInfo() && !event.isRealData();
 
     std::ostringstream os;
     os << "event_" << fEvent << "_run_" << fRun << "_subrun_" << fSubRun;
 
     std::cout << "analyze " << os.str() << std::endl;
 
     auto const clockData =
       art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
 
     for (size_t i = 0; i < fSelectedTPC.size(); ++i)
       for (size_t v = 0; v < fSelectedPlane.size(); ++v) {
         fTrainingDataAlg.setEventData(
           event, clockData, detProp, fSelectedPlane[v], fSelectedTPC[i], 0);
 
         unsigned int w0, w1, d0, d1;
         if (fCrop && saveSim) {
           if (fTrainingDataAlg.findCrop(0.004F, w0, w1, d0, d1)) {
             std::cout << "   crop: " << w0 << " " << w1 << " " << d0 << " " << d1 << std::endl;
           }
           else {
             std::cout << "   skip empty tpc:" << fSelectedTPC[i] << " / view:" << fSelectedPlane[v]
                       << std::endl;
             continue;
           }
         }
         else {
           w0 = 0;
           w1 = fTrainingDataAlg.NWires();
           d0 = 0;
           d1 = fTrainingDataAlg.NScaledDrifts();
         }
 
         if (fDumpToRoot) {
           std::ostringstream ss1;
           ss1 << "raw_" << os.str() << "_tpc_" << fSelectedTPC[i] << "_view_"
               << fSelectedPlane[v]; // TH2's name
 
           art::ServiceHandle<art::TFileService const> tfs;
           TH2F* rawHist =
             tfs->make<TH2F>((ss1.str() + "_raw").c_str(), "ADC", w1 - w0, w0, w1, d1 - d0, d0, d1);
           TH2F* depHist = 0;
           TH2I* pdgHist = 0;
           if (saveSim) {
             depHist = tfs->make<TH2F>(
               (ss1.str() + "_deposit").c_str(), "Deposit", w1 - w0, w0, w1, d1 - d0, d0, d1);
             pdgHist = tfs->make<TH2I>(
               (ss1.str() + "_pdg").c_str(), "PDG", w1 - w0, w0, w1, d1 - d0, d0, d1);
           }
 
           for (size_t w = w0; w < w1; ++w) {
             auto const& raw = fTrainingDataAlg.wireData(w);
             for (size_t d = d0; d < d1; ++d) {
               rawHist->Fill(w, d, raw[d]);
             }
 
             if (saveSim) {
               auto const& edep = fTrainingDataAlg.wireEdep(w);
               for (size_t d = d0; d < d1; ++d) {
                 depHist->Fill(w, d, edep[d]);
               }
 
               auto const& pdg = fTrainingDataAlg.wirePdg(w);
               for (size_t d = d0; d < d1; ++d) {
                 pdgHist->Fill(w, d, pdg[d]);
               }
             }
           }
 
           writeAndDelete(rawHist);
           writeAndDelete(depHist);
           writeAndDelete(pdgHist);
 
         }
         else {
           std::ostringstream ss1;
           ss1 << fOutTextFilePath << "/raw_" << os.str() << "_tpc_" << fSelectedTPC[i] << "_view_"
               << fSelectedPlane[v];
 
           std::ofstream fout_raw, fout_deposit, fout_pdg;
 
           fout_raw.open(ss1.str() + ".raw");
           if (saveSim) {
             fout_deposit.open(ss1.str() + ".deposit");
             fout_pdg.open(ss1.str() + ".pdg");
           }
 
           for (size_t w = w0; w < w1; ++w) {
             auto const& raw = fTrainingDataAlg.wireData(w);
             for (size_t d = d0; d < d1; ++d) {
               fout_raw << raw[d] << " ";
             }
             fout_raw << std::endl;
 
             if (saveSim) {
               auto const& edep = fTrainingDataAlg.wireEdep(w);
               for (size_t d = d0; d < d1; ++d) {
                 fout_deposit << edep[d] << " ";
               }
               fout_deposit << std::endl;
 
               auto const& pdg = fTrainingDataAlg.wirePdg(w);
               for (size_t d = d0; d < d1; ++d) {
                 fout_pdg << pdg[d] << " ";
               }
               fout_pdg << std::endl;
             }
           }
 
           fout_raw.close();
           if (saveSim) {
             fout_deposit.close();
             fout_pdg.close();
           }
         }
       }
 
   } // PointIdTrainingData::analyze()