#include <ToolBasedRawDigitPrepService.h>

Inheritance diagram for ToolBasedRawDigitPrepService:

Classes
struct	NamedTool

class	State

Public Types
using	Index = unsigned int

using	AdcChannelToolPtr = std::unique_ptr< AdcChannelTool >

using	AdcChannelToolVector = std::vector< AdcChannelToolPtr >

using	AdcChannelNamedToolVector = std::vector< NamedTool >

Public Types inherited from RawDigitPrepService
using	Index = unsigned int

using	LongIndex = unsigned long

Public Member Functions
	ToolBasedRawDigitPrepService (fhicl::ParameterSet const &pset, art::ActivityRegistry &)

	~ToolBasedRawDigitPrepService ()

int	beginEvent (const DuneEventInfo &devt) const override

int	endEvent (const DuneEventInfo &devt) const override

int	prepare (detinfo::DetectorClocksData const &clockData, AdcChannelDataMap &prepdigs, std::vector< recob::Wire > pwires, WiredAdcChannelDataMap pintStates) const override

std::ostream &	print (std::ostream &out=std::cout, std::string prefix="") const override

Public Member Functions inherited from RawDigitPrepService
virtual	~RawDigitPrepService ()=default

Private Types
using	Clock = std::chrono::steady_clock

using	Duration = std::chrono::duration< double >

Private Member Functions
State &	state () const

Private Attributes
int	m_LogLevel

bool	m_DoWires

std::vector< std::string >	m_ToolNames

std::vector< std::string >	m_CallgrindToolNames

AdcChannelToolVector	m_AdcChannelTools

AdcChannelNamedToolVector	m_AdcChannelNamedTools

const AdcWireBuildingService *	m_pWireBuildingService

std::set< std::string >	m_cgset

std::unique_ptr< State >	m_pstate

Detailed Description

Definition at line 36 of file ToolBasedRawDigitPrepService.h.

Member Typedef Documentation

using ToolBasedRawDigitPrepService::AdcChannelNamedToolVector = std::vector<NamedTool>

Definition at line 48 of file ToolBasedRawDigitPrepService.h.

using ToolBasedRawDigitPrepService::AdcChannelToolPtr = std::unique_ptr<AdcChannelTool>

Definition at line 41 of file ToolBasedRawDigitPrepService.h.

using ToolBasedRawDigitPrepService::AdcChannelToolVector = std::vector<AdcChannelToolPtr>

Definition at line 47 of file ToolBasedRawDigitPrepService.h.

using ToolBasedRawDigitPrepService::Clock = std::chrono::steady_clock

private

Definition at line 78 of file ToolBasedRawDigitPrepService.h.

using ToolBasedRawDigitPrepService::Duration = std::chrono::duration<double>

private

Definition at line 79 of file ToolBasedRawDigitPrepService.h.

using ToolBasedRawDigitPrepService::Index = unsigned int

Definition at line 40 of file ToolBasedRawDigitPrepService.h.

Constructor & Destructor Documentation

ToolBasedRawDigitPrepService::ToolBasedRawDigitPrepService	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &
	)

Definition at line 29 of file ToolBasedRawDigitPrepService_service.cc.

 : m_LogLevel(pset.get<int>("LogLevel")),
   m_DoWires(pset.get<bool>("DoWires")),
   m_ToolNames(pset.get<vector<string>>("ToolNames")),
   m_CallgrindToolNames(pset.get<vector<string>>("CallgrindToolNames")),
   m_pWireBuildingService(nullptr),
   m_cgset(m_CallgrindToolNames.begin(), m_CallgrindToolNames.end()),
   m_pstate(new State) {
   const string myname = "ToolBasedRawDigitPrepService::ctor: ";
   pset.get_if_present<int>("LogLevel", m_LogLevel);
   // Fetch the tools.
   if ( m_ToolNames.size() ) {
     DuneToolManager* ptm = DuneToolManager::instance("");
     if ( ptm == nullptr ) {
       cout << myname << "ERROR: Unable to retrieve tool manaager." << endl;
     } else {
       for ( string tname : m_ToolNames ) {
         if ( m_LogLevel ) cout << myname << "     Fetching " << tname << endl;
         AdcChannelToolPtr ptool = ptm->getPrivate<AdcChannelTool>(tname);
         NamedTool nt(tname, ptool.get());
         if ( nt.tool ) {
           if ( m_LogLevel ) cout << myname << "    Found tool " << tname << " @ " << nt.tool << endl;
           m_AdcChannelTools.push_back(std::move(ptool));
           m_AdcChannelNamedTools.push_back(nt);
         } else {
           cout << myname << "ERROR: Unable to retrieve display tool " << tname << endl;
         }
       }
     }
   }
   state().toolTimes.resize(m_ToolNames.size());
   if ( m_DoWires ) {
     if ( m_LogLevel ) cout << myname << "Fetching wire building service." << endl;
     m_pWireBuildingService = &*art::ServiceHandle<AdcWireBuildingService>();
     if ( m_LogLevel ) cout << myname << "  Wire building service: @" <<  m_pWireBuildingService << endl;
   }
   if ( m_LogLevel >=1 ) print(cout, myname);
 }

ToolBasedRawDigitPrepService::~ToolBasedRawDigitPrepService ( )

Definition at line 70 of file ToolBasedRawDigitPrepService_service.cc.

                                                             {
   const string myname = "ToolBasedRawDigitPrepService:dtor: ";
   if ( state().nevtBegin != state().nevtEnd ) {
     cout << myname << "WARNING: Event counts are inconsistent: " << state().nevtBegin
          << " != " << state().nevtEnd << endl;
   }
   Index ntoo = m_ToolNames.size();
   Index nevt = state().nevtEnd;
   if ( m_LogLevel >= 1 ) {
     cout << myname << "Event count: " << nevt << endl;
     cout << myname << " Call count: " << state().ncall << endl;
     cout << myname << "Time report for " << ntoo << " tools." << endl;
     string sunit = "sec/event";
     float xnevt = float(nevt);
     if ( nevt == 0 ) {
       xnevt = 1.0;
       sunit = "sec";
     }
     for ( Index itoo=0; itoo<ntoo; ++itoo ) {
       string name = m_ToolNames[itoo];
       double time = state().toolTimes[itoo].count();
       cout << myname << setw(30) << name << ":"
            << setw(7) << std::fixed << setprecision(2)
            << time/xnevt << " " << sunit << endl;
     }
   }
 }

Member Function Documentation

int ToolBasedRawDigitPrepService::beginEvent ( const DuneEventInfo & devt ) const

overridevirtual

Reimplemented from RawDigitPrepService.

Definition at line 100 of file ToolBasedRawDigitPrepService_service.cc.

                                                                             {
   const string myname = "ToolBasedRawDigitPrepService:beginEvent: ";
   if ( m_LogLevel >= 2 ) {
     cout << myname << "Begin processing run " << devt.runString();
     cout << " event " << devt.event;
     cout << " with " << m_AdcChannelNamedTools.size() << " tools." << endl;
   }
   if ( state().nevtBegin != state().nevtEnd ) {
     cout << myname << "WARNING: Event counts are inconsistent: " << state().nevtBegin
          << " != " << state().nevtEnd << endl;
   }
   ++state().nevtBegin;
   Index nfail = 0;
   if ( m_AdcChannelNamedTools.size() ) {
     for ( NamedTool nt : m_AdcChannelNamedTools ) {
       DataMap ret = nt.tool->beginEvent(devt);
       if ( ret.status() ) {
         ++nfail;
         cout << myname << "WARNING: Iniitalization for tool " << nt.name
              << " failed for event " << devt.event << " with status code " << ret.status() << endl;
       }
     }
   }
   return nfail;
 }

int ToolBasedRawDigitPrepService::endEvent ( const DuneEventInfo & devt ) const

overridevirtual

Reimplemented from RawDigitPrepService.

Definition at line 128 of file ToolBasedRawDigitPrepService_service.cc.

                                                                           {
   const string myname = "ToolBasedRawDigitPrepService:endEvent: ";
   if ( m_LogLevel >= 2 ) {
     cout << myname << "End processing run " << devt.runString();
     cout << " event " << devt.event;
     cout << " with " << m_AdcChannelNamedTools.size() << " tools." << endl;
   }
   Index nfail = 0;
   ++state().nevtEnd;
   if ( state().nevtBegin != state().nevtEnd ) {
     cout << myname << "WARNING: Event counts are inconsistent: " << state().nevtBegin
          << " != " << state().nevtEnd << endl;
   }
   if ( m_AdcChannelNamedTools.size() ) {
     for ( NamedTool nt : m_AdcChannelNamedTools ) {
       DataMap ret = nt.tool->endEvent(devt);
       if ( ret.status() ) {
         ++nfail;
         cout << myname << "WARNING: Event finalization for tool " << nt.name
              << " failed for event " << devt.event << " with status code " << ret.status() << endl;
       }
     }
   }
   return nfail;
 }

int ToolBasedRawDigitPrepService::prepare	(	detinfo::DetectorClocksData const &	clockData,
		AdcChannelDataMap &	prepdigs,
		std::vector< recob::Wire > *	pwires,
		WiredAdcChannelDataMap *	pintStates
	)		const

overridevirtual

Implements RawDigitPrepService.

Definition at line 157 of file ToolBasedRawDigitPrepService_service.cc.

                                                                                 {
   const string myname = "ToolBasedRawDigitPrepService:prepare: ";
   // Loop over tools.
   ++state().ncall;
   if ( m_LogLevel >= 2 ) cout << myname << "Processing " << datamap.size() << " channels with "
                               << m_AdcChannelNamedTools.size() << " tools." << endl;
   if ( m_AdcChannelNamedTools.size() ) {
     Index itoo = 0;
     for ( NamedTool nt : m_AdcChannelNamedTools ) {
       if ( m_LogLevel >= 3 ) cout << myname << "  Running tool " << nt.name << endl;
       bool useCallgrind = m_cgset.count(nt.name);
       if ( useCallgrind ) {
         CALLGRIND_START_INSTRUMENTATION;
         CALLGRIND_TOGGLE_COLLECT;
       }
       auto start = Clock::now();
       DataMap ret = nt.tool->updateMap(datamap);
       auto stop = Clock::now();
       if ( useCallgrind ) {
         CALLGRIND_TOGGLE_COLLECT;
         CALLGRIND_STOP_INSTRUMENTATION;
       }
       Duration dtim =stop - start;
       state().toolTimes[itoo] += dtim;
       if ( ret ) {
         cout << myname << "WARNING: Tool " << nt.name << " failed";
         if ( ret.haveIntVector("failedChannels") ) {
           Index ncha = ret.getIntVector("failedChannels").size();
           cout << " for " << ncha << " channel" << (ncha == 1 ? "" : "s");
         }
         cout << " with error " << ret.status();
         if ( ret.haveIntVector("failedCodes") ) {
           Index ncod = ret.getIntVector("failedCodes").size();
           if ( ncod > 1 ) cout << " and "  << ncod - 1 << " other errors";
         }
         cout << "." << endl;
       }
       if ( m_LogLevel >= 4 ) {
         cout << myname << "----------------------------" << endl;
         ret.print();
         cout << myname << "----------------------------" << endl;
       }
       ++itoo;
     }
   }
   if ( m_DoWires ) {
     for ( auto& chdata : datamap ) {
       AdcChannelData& acd = chdata.second;
       m_pWireBuildingService->build(acd, pwires);
     }
   }
   return 0;
 }

std::ostream & ToolBasedRawDigitPrepService::print	(	std::ostream &	out = `std::cout`,
		std::string	prefix = `""`
	)		const

overridevirtual

Implements RawDigitPrepService.

Definition at line 216 of file ToolBasedRawDigitPrepService_service.cc.

                                                {
   out << prefix << "ToolBasedRawDigitPrepService:"                      << endl;
   out << prefix << "                    LogLevel: " << m_LogLevel             << endl;
   out << prefix << "                     DoWires: " << m_DoWires              << endl;
   if ( m_AdcChannelNamedTools.size() ) {
     cout << prefix << "     ADC channel tools:";
     for ( const NamedTool& nm : m_AdcChannelNamedTools ) {
        out << "\n" << prefix << "           " << nm.name;
        if ( m_cgset.count(nm.name) ) cout << " (callgrind enabled)";
     }
     cout << endl;
   } else {
     out << prefix << "    No ADC channel tools." << endl;
   }
   return out;
 }