#include <AdcEventViewer.h>

Inheritance diagram for AdcEventViewer:

Classes
class	ChannelRangeState

struct	GraphInfo

class	HistInfo

class	State

Public Types
using	Index = unsigned int

using	IndexVector = std::vector< Index >

using	IndexSet = std::set< Index >

using	LongIndex = unsigned long

using	LongIndexVector = std::vector< LongIndex >

using	Name = std::string

using	NameVector = std::vector< Name >

using	HistVector = std::vector< TH1 * >

using	HistMap = std::map< Name, TH1 * >

using	NameMap = std::map< Name, Name >

using	FloatVector = std::vector< float >

using	GraphVector = std::vector< TGraph * >

using	IndexRangeVector = std::vector< IndexRange >

using	HistInfoMap = std::map< Name, HistInfo >

using	GraphInfoVector = std::vector< GraphInfo >

using	ChannelRangeStates = std::map< Name, ChannelRangeState >

using	StatePtr = std::shared_ptr< State >

Public Member Functions
	AdcEventViewer (fhicl::ParameterSet const &ps)

	~AdcEventViewer () override

DataMap	beginEvent (const DuneEventInfo &devt) const override

DataMap	endEvent (const DuneEventInfo &devt) const override

DataMap	view (const AdcChannelData &acd) const override

DataMap	viewMap (const AdcChannelDataMap &acds) const override

bool	updateWithView () const override

State &	state () const

ChannelRangeState &	crstate (Name crn) const

void	beginEventState (const DuneEventInfo &devt) const

void	endEventState (const DuneEventInfo &devt) const

void	printReport () const

void	displayHists () const

void	displayGraphs () const

Private Attributes
int	m_LogLevel

NameVector	m_EventHists

NameVector	m_EventGraphs

NameVector	m_ChannelRanges

Name	m_ChannelRangeLabel

Name	m_ClockUnit

double	m_ClockRate

IndexRangeVector	m_crs

StatePtr	m_state

Additional Inherited Members
Private Types inherited from AdcChannelTool
using	Index = unsigned int

Private Member Functions inherited from TpcDataTool
virtual DataMap	updateTpcData (TpcData &) const

virtual DataMap	viewTpcData (const TpcData &) const

virtual int	forwardTpcData () const

Private Member Functions inherited from AdcChannelTool
virtual	~AdcChannelTool ()=default

virtual DataMap	update (AdcChannelData &) const

virtual DataMap	updateMap (AdcChannelDataMap &acds) const

virtual bool	viewWithUpdate () const

virtual DataMap	close (const DataMap *dmin=nullptr)

Static Private Member Functions inherited from AdcChannelTool
static int	interfaceNotImplemented ()

Detailed Description

Definition at line 45 of file AdcEventViewer.h.

Member Typedef Documentation

using AdcEventViewer::ChannelRangeStates = std::map<Name,ChannelRangeState>

Definition at line 121 of file AdcEventViewer.h.

using AdcEventViewer::FloatVector = std::vector<float>

Definition at line 59 of file AdcEventViewer.h.

using AdcEventViewer::GraphInfoVector = std::vector<GraphInfo>

Definition at line 108 of file AdcEventViewer.h.

using AdcEventViewer::GraphVector = std::vector<TGraph*>

Definition at line 60 of file AdcEventViewer.h.

using AdcEventViewer::HistInfoMap = std::map<Name, HistInfo>

Definition at line 72 of file AdcEventViewer.h.

using AdcEventViewer::HistMap = std::map<Name, TH1*>

Definition at line 57 of file AdcEventViewer.h.

using AdcEventViewer::HistVector = std::vector<TH1*>

Definition at line 56 of file AdcEventViewer.h.

using AdcEventViewer::Index = unsigned int

Definition at line 49 of file AdcEventViewer.h.

using AdcEventViewer::IndexRangeVector = std::vector<IndexRange>

Definition at line 61 of file AdcEventViewer.h.

using AdcEventViewer::IndexSet = std::set<Index>

Definition at line 51 of file AdcEventViewer.h.

using AdcEventViewer::IndexVector = std::vector<Index>

Definition at line 50 of file AdcEventViewer.h.

using AdcEventViewer::LongIndex = unsigned long

Definition at line 52 of file AdcEventViewer.h.

using AdcEventViewer::LongIndexVector = std::vector<LongIndex>

Definition at line 53 of file AdcEventViewer.h.

using AdcEventViewer::Name = std::string

Definition at line 54 of file AdcEventViewer.h.

using AdcEventViewer::NameMap = std::map<Name, Name>

Definition at line 58 of file AdcEventViewer.h.

using AdcEventViewer::NameVector = std::vector<Name>

Definition at line 55 of file AdcEventViewer.h.

using AdcEventViewer::StatePtr = std::shared_ptr<State>

Definition at line 146 of file AdcEventViewer.h.

Constructor & Destructor Documentation

AdcEventViewer::AdcEventViewer ( fhicl::ParameterSet const & ps )

Definition at line 111 of file AdcEventViewer_tool.cc.

 : m_LogLevel(ps.get<int>("LogLevel")),
   m_EventHists(ps.get<NameVector>("EventHists")),
   m_EventGraphs(ps.get<NameVector>("EventGraphs")),
   m_ChannelRanges(ps.get<NameVector>("ChannelRanges")),
   m_ChannelRangeLabel(ps.get<Name>("ChannelRangeLabel")),
   m_ClockUnit(ps.get<Name>("ClockUnit")),
   m_ClockRate(ps.get<double>("ClockRate")),
   m_state(new AdcEventViewer::State) {
   const string myname = "AdcEventViewer::ctor: ";
   // Fetch the channel ranges.
   bool toolNotFound = false;
   const IndexRangeTool* pcrt = nullptr;
   DuneToolManager* ptm = DuneToolManager::instance();
   for ( Name crn : m_ChannelRanges.size() ? m_ChannelRanges : NameVector(1, "") ) {
     if ( crn.size() == 0 || crn == "all" ) {
       m_crs.emplace_back("all", 0, 0, "All");
     } else {
       if ( pcrt == nullptr && !toolNotFound ) {
         pcrt = ptm->getShared<IndexRangeTool>("channelRanges");
         if ( pcrt == nullptr ) {
           cout << myname << "ERROR: IndexRangeTool not found: channelRanges" << endl;
         }
       }
       if ( pcrt != nullptr ) {
         IndexRange ran = pcrt->get(crn);
         if ( ran.isValid() ) {
           m_crs.push_back(ran);
         } else {
           cout << myname << "WARNING: Channel range not found: " << crn << endl;
         }
       }
     }
   }
   // Display the configuration.
   if ( m_LogLevel>= 1 ) {
     cout << myname << "         LogLevel: " << m_LogLevel << endl;
     cout << myname << "       EventHists: [" << endl;
     for ( Index ievh=0; ievh<m_EventHists.size(); ++ievh ) {
       cout << myname << "                     " << m_EventHists[ievh] << endl;
     }
     cout << myname << "                   " << "]" << endl;
     cout << myname << "      EventGraphs: [" << endl;
     for ( Index ievg=0; ievg<m_EventGraphs.size(); ++ievg ) {
       cout << myname << "                     " << m_EventGraphs[ievg] << endl;
     }
     cout << myname << "                   " << "]" << endl;
     cout << myname << "       ChannelRanges: [";
     bool first = true;
     for ( const IndexRange& ran : m_crs ) {
       if ( ! first ) cout << ", ";
       else first = false;
       cout << ran.name;
     }
     cout << "]" << endl;
     cout << myname << "   ChannelRangeLabel: " << m_ChannelRangeLabel << endl;
     cout << myname << "           ClockUnit: " << m_ClockUnit << endl;
     cout << myname << "           ClockRate: " << m_ClockRate << " tick/sec" << endl;
   }
   state().firstClock = 0;
   state().minClock = 0;
   const string::size_type& npos = string::npos;
   // Make sure clock unit is valid.
   if ( m_ClockUnit != "tick" &&
        m_ClockUnit != "ktick" &&
        m_ClockUnit != "Mtick" &&
        m_ClockUnit != "Gtick" ) {
     cout << myname << "WARNING: invalid clock unit changed to tick" << endl;
     m_ClockUnit = "tick";
   }
   // Loop over channel ranges
   for ( const IndexRange& cr : m_crs ) {
     // Create the substate;
     Name crn = cr.name;
     if ( state().crstates.find(crn) != state().crstates.end() ) {
       cout << myname << "WARNING: Skipping duplicate CR name: " << crn << endl;
       continue;
     }
     ChannelRangeState& crstate = state().crstates[crn];
     // Create the histograms.
     for ( string hspec : m_EventHists ) {
       string basename;
       int nbin = 0;
       float xmin = 0.0;
       float xmax = 0.0;
       bool ok = false;
       string::size_type ipos = 0;
       string::size_type jpos = 0;
       istringstream ssin;
       jpos = hspec.find(":");
       if ( jpos != npos ) {
         basename = hspec.substr(ipos, jpos-ipos);
         ipos = jpos + 1;
         jpos = hspec.find(":", ipos);
         if ( jpos != npos && jpos > ipos ) {
           istringstream ssnbin(hspec.substr(ipos, jpos-ipos));
           ssnbin >> nbin;
           ipos = jpos + 1;
           jpos = hspec.find(":", ipos);
           if ( jpos != npos && jpos > ipos ) {
             istringstream ssxmin(hspec.substr(ipos, jpos-ipos));
             ssxmin >> xmin;
             ipos = jpos + 1;
             jpos = hspec.size();
             istringstream ssxmax(hspec.substr(ipos, jpos-ipos));
             ssxmax >> xmax;
             ok = true;
           }
         }
       }
       if ( ! ok ) {
         cout << "WARNING: Invalid histogram configuration string: " << hspec << endl;
         continue;
       }
       string hname = basename;
       if ( crn != "all " ) hname += "_" + crn;
       string vname;
       if ( basename.find("nfemb") != string::npos ) {
         vname = "nfemb";
       } else if ( basename.find("rmPedPower") != string::npos ) {
         vname = "rmPedPower";
       } else if ( basename.find("meanPed") != string::npos ) {
         vname = "meanPed";
       } else {
         cout << myname << "ERROR: No variable for histogram name " << hname << endl;
         continue;
       }
       VarInfo vinfo(vname, cr, m_ClockUnit);
       string sttl = vinfo.label;
       sttl += ";" + vinfo.label;
       Name unit = vinfo.unit;
       if ( unit.size() ) sttl += " [" + unit + "]";
       sttl += ";# event";
       if ( m_LogLevel >= 2 ) {
         cout << myname << "Creating in histogram " << hname << ", nbin=" << nbin
              << ", range=(" << xmin << ", " << xmax << ")" << endl;
       }
       TH1* ph = new TH1F(hname.c_str(), sttl.c_str(), nbin, xmin, xmax);
       ph->SetDirectory(nullptr);
       ph->SetStats(0);
       ph->SetLineWidth(2);
       crstate.hists.push_back(ph);
       if ( m_LogLevel>= 1 ) cout << myname << "Created histogram " << hname << endl;
     }
     for ( string gspec : m_EventGraphs ) {
       if ( m_LogLevel >= 2 ) cout << myname << "Building graph info" << endl;
       string xname;
       string yname;
       float xmin = 0.0;
       float xmax = 0.0;
       float xoff = 0.0;
       float ymin = 0.0;
       float ymax = 0.0;
       float yoff = 0.0;
       string::size_type ipos = 0;
       string::size_type jpos = 0;
       istringstream ssin;
       jpos = gspec.find(":");
       // x name
       if ( jpos != npos ) {
         xname = gspec.substr(ipos, jpos-ipos);
         ipos = jpos + 1;
         jpos = gspec.find(":", ipos);
         if ( m_LogLevel >= 2 ) cout << myname << "  xname: " << xname << endl;
       }
       // x range
       if ( jpos != npos && jpos > ipos ) {
         // Range from job range tool:   name:ranName:xoff
         if ( isalpha(gspec[ipos]) ) {
           if ( m_LogLevel >= 2 ) cout << myname << "  Taking x range from tool." << endl;
           istringstream ssnran(gspec.substr(ipos, jpos-ipos));
           Name ranName = gspec.substr(ipos, jpos-ipos);
           const IndexRangeTool* pcrt = ptm->getShared<IndexRangeTool>("jobRanges");
           if ( pcrt == nullptr ) {
             cout << myname << "ERROR: Unable to find index range tool jobRanges" << endl;
           } else {
             IndexRange ran = pcrt->get(ranName);
             if ( ran.isValid() ) {
               xmin = ran.begin;
               xmax = ran.end;
             } else {
               cout << myname << "ERROR: Unable to find job range " << ranName << endl;
             }
           }
           ipos = jpos + 1;
           jpos = gspec.find(":", ipos);
           if ( jpos != npos && jpos > ipos ) {
             istringstream ssxoff(gspec.substr(ipos, jpos-ipos));
             ssxoff >> xoff;
           }
         // Explicit range
         } else {
           if ( m_LogLevel >= 2 ) cout << myname << "  Using explicit x range." << endl;
           istringstream ssxmin(gspec.substr(ipos, jpos-ipos));
           ssxmin >> xmin;
           ipos = jpos + 1;
           jpos = gspec.find(":", ipos);
           if ( jpos != npos && jpos > ipos ) {
             istringstream ssxmax(gspec.substr(ipos, jpos-ipos));
             ssxmax >> xmax;
           }
         }
       }
       ipos = jpos + 1;
       jpos = gspec.find(":", ipos);
       // y name
       if ( jpos != npos && jpos > ipos ) {
         yname = gspec.substr(ipos, jpos-ipos);
         ipos = jpos + 1;
         jpos = gspec.find(":", ipos);
         if ( m_LogLevel >= 2 ) cout << myname << "  yname: " << yname << endl;
       }
       // y range
       if ( jpos != npos && jpos > ipos ) {
         // Range from job range tool:   name:ranName:yoff
         if ( isalpha(gspec[ipos]) ) {
           if ( m_LogLevel >= 2 ) cout << myname << "  Taking y range from tool." << endl;
           istringstream ssnran(gspec.substr(ipos, jpos-ipos));
           Name ranName = gspec.substr(ipos, jpos-ipos);
           cout << myname << "Taking y-range from job range " << ranName << endl;
           const IndexRangeTool* pcrt = ptm->getShared<IndexRangeTool>("jobRanges");
           if ( pcrt == nullptr ) {
             cout << myname << "ERROR: Unable to find index range tool jobRanges" << endl;
           } else {
             IndexRange ran = pcrt->get(ranName);
             if ( ran.isValid() ) {
               ymin = ran.begin;
               ymax = ran.end;
             } else {
               cout << myname << "ERROR: Unable to fund job range " << ranName << endl;
             }
           }
           ipos = jpos + 1;
           jpos = gspec.find(":", ipos);
           if ( jpos != npos && jpos > ipos ) {
             istringstream ssyoff(gspec.substr(ipos, jpos-ipos));
             ssyoff >> yoff;
           }
         // Explicit range
         } else {
           if ( m_LogLevel >= 2 ) cout << myname << "  Using explicit y range." << endl;
           istringstream ssymin(gspec.substr(ipos, jpos-ipos));
           ssymin >> ymin;
           ipos = jpos + 1;
           jpos = gspec.find(":", ipos);
           if ( jpos > ipos ) {
             istringstream ssymax(gspec.substr(ipos, jpos-ipos));
             ssymax >> ymax;
           }
         }
       }
       VarInfo xvin(xname, cr, m_ClockUnit);
       VarInfo yvin(yname, cr, m_ClockUnit);
       bool ok = xvin.isValid() && yvin.isValid();
       if ( ! ok ) {
         cout << myname << "WARNING: Invalid graph configuration string: " << gspec << endl;
         continue;
       }
       string sttl = yvin.label + " vs. " + xvin.label;
       if ( m_LogLevel >= 2 ) {
         cout << myname << "Creating graph of " << yname;
         if ( ymax > ymin ) cout << " range=(" << ymin - yoff << ", " << ymax + yoff << ")";
         else if ( ymax >= 0.0 ) cout << " range from data with border " << yoff << endl;
         cout << " vs. " << xname;
         if ( xmax > xmin ) cout << " range=(" << xmin << ", " << xmax << ")";
         else if ( xmax >= 0.0 ) cout << " range from data with border " << xoff << endl;
         cout << endl;
       } 
       crstate.graphs.emplace_back(xname, xvin.label, xvin.unit, xmin, xmax, xoff,
                                   yname, yvin.label, yvin.unit, ymin, ymax, yoff );
       if ( m_LogLevel>= 1 ) cout << myname << "Created graph info for " << yname << " vs. " << xname << endl;
     }
   }  // end loop over channel ranges
 }

AdcEventViewer::~AdcEventViewer ( )

override

Definition at line 388 of file AdcEventViewer_tool.cc.

                                 {
   const string myname = "AdcEventViewer::dtor: ";
   if ( state().beginEventCount == 0 ) endEventState(state().eventInfo);
   cout << myname << " Begin event count: " <<  state().beginEventCount << endl;
   cout << myname << "Unique event count: " <<  state().events.size() << endl;
   displayHists();
   displayGraphs();
   cout << myname << "Exiting." << endl;
 }

Member Function Documentation

DataMap AdcEventViewer::beginEvent ( const DuneEventInfo & devt ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 400 of file AdcEventViewer_tool.cc.

                                                                   {
   const string myname = "AdcEventViewer::beginEvent: ";
   DataMap ret;
   if ( m_LogLevel >= 2 ) {
     cout << myname << "Begin processing event " << devt.event << " for run " << devt.run;
     if ( devt.subRun ) cout << "-" << devt.subRun;
     cout << endl;
   }
   if ( state().haveEvent() ) {
     cout << myname << "WARNING: Begin called wth event " << devt.event
          << " during processing of event " << state().eventInfo.event
          << ". Ending current event." << endl;
     endEvent(state().eventInfo);
   }
   ++state().beginEventCount;
   beginEventState(devt);
   return ret;
 }

void AdcEventViewer::beginEventState ( const DuneEventInfo & devt ) const

Definition at line 504 of file AdcEventViewer_tool.cc.

                                                                     {
   const string myname = "AdcEventViewer::beginEventState: ";
   if ( state().haveEvent() ) {
     cout << "WARNING: Begin called during event processing. Ending current event." << endl;
     endEventState(devt);
   }
   if ( m_LogLevel >= 4 ) cout << myname << "Starting run" << devt.runString()
                               << " event " << devt.event << endl;
   if ( state().haveEvent() && state().run() != devt.run ) {
     cout << myname << "ERROR: change in run number is not (yet) supported." << endl;
     return;
   }
   Index ievt = devt.event;
   Index irun = devt.run;
   state().eventInfo = devt;
   state().events.push_back(ievt);
   state().eventSet.insert(ievt);
   state().runSet.insert(irun);
   LongIndex clk = devt.triggerClock;
   if ( state().firstClock == 0 ) state().firstClock = clk;
   if ( clk < state().minClock ) state().minClock = clk;
   state().ngroup = 0;
   for ( ChannelRangeStates::iterator icr=state().crstates.begin();
         icr!=state().crstates.end(); ++icr ) {
     ChannelRangeState& crstate = icr->second;
     crstate.fembIDSet.clear();
     crstate.nchan = 0;
     crstate.pedSum = 0.0;
     crstate.pedPower = 0.0;
   }
 }

AdcEventViewer::ChannelRangeState & AdcEventViewer::crstate ( Name crn ) const

Definition at line 491 of file AdcEventViewer_tool.cc.

                                                                        {
   const string myname = "AdcEventViewer::crstate: ";
   ChannelRangeStates::iterator icrs = state().crstates.find(crn);
   if ( icrs == state().crstates.end() ) {
     cout << myname << "ERROR: There is no substate for channel range " << crn << endl;
     static ChannelRangeState crsbad;
     return crsbad;
   }
   return icrs->second;
 }

void AdcEventViewer::displayGraphs ( ) const

Definition at line 656 of file AdcEventViewer_tool.cc.

                                          {
   const string myname = "AdcEventViewer::displayGraphs: ";
   string sttlSufBase = " for run " + state().runString();
   for ( const IndexRange& cr : m_crs ) {
     ChannelRangeState& crstate = state().crstates[cr.name];
     Index nplt = crstate.graphs.size();
     Index nevt = state().eventSet.size();
     string sttlSuf = sttlSufBase;
     if ( nevt == 0 ) sttlSuf += " with no events.";
     else if ( nevt == 1 ) sttlSuf += " event " + to_string(*state().eventSet.begin());
     else sttlSuf += " events " + to_string(*state().eventSet.begin()) + "-" + to_string(*state().eventSet.rbegin());
     if ( m_LogLevel >= 1 ) cout << myname << "Creating " << nplt << " graph"
                                 << (nplt == 1 ? "" : "s") << sttlSuf
                                 << (nplt > 0 ? ":" : "") << endl;
     string crlab = m_ChannelRangeLabel;
     StringManipulator smlab(crlab, false);
     smlab.replace("%CRNAME%", cr.name);
     smlab.replace("%CRLABEL%", cr.label());
     smlab.replace("%CRLABEL1%", cr.label(1));
     smlab.replace("%CRLABEL2%", cr.label(2));
     if ( crlab.size() ) sttlSuf += " " + crlab;
     for ( GraphInfo& gin : crstate.graphs ) {
       if ( m_LogLevel >= 1 ) cout << myname << "Creating graph of " << gin.vary << " vs. " << gin.varx << endl;
       Index npt = gin.xvals.size();
       if ( npt == 0 ) {
         cout << myname << "Skipping graph with no entries." << endl;
         continue;
       }
       if ( gin.yvals.size() != npt ) {
         cout << myname << "Skipping graph with inconsistent entries." << endl;
         continue;
       }
       TGraph* pg = new TGraph(npt, &gin.xvals[0], &gin.yvals[0]);
       pg->GetXaxis()->SetTitle(gin.xAxisLabel().c_str());
       pg->GetYaxis()->SetTitle(gin.yAxisLabel().c_str());
       pg->SetMarkerStyle(2);
       double xmin = gin.xmin;
       double xmax = gin.xmax;
       double xoff = gin.xoff;
       double ymin = gin.ymin;
       double ymax = gin.ymax;
       double yoff = gin.yoff;
       bool setXLimitsFromData = pg->GetN() && xmax == xmin && xmax >= 0.0;
       bool setYLimitsFromData = pg->GetN() && ymax == ymin && ymax >= 0.0;
       if ( setXLimitsFromData || setYLimitsFromData ) {
         double xdmin = 0.0;
         double xdmax = 0.0;
         double ydmin = 0.0;
         double ydmax = 0.0;
         double xpt, ypt;
         for ( int ipt=0; ipt<pg->GetN(); ++ipt ) {
           pg->GetPoint(ipt, xpt, ypt);
           if ( ipt == 0 ) {
             xdmin = xpt;
             xdmax = xpt;
             ydmin = ypt;
             ydmax = ypt;
           } else {
             if ( xpt < xdmin ) xdmin = xpt;
             if ( xpt > xdmax ) xdmax = xpt;
             if ( ypt < ydmin ) ydmin = ypt;
             if ( ypt > ydmax ) ydmax = ypt;
           }
         }
         if ( setXLimitsFromData ) {
           xoff = xmax;
           xmin = xdmin;
           xmax = xdmax;
           if ( m_LogLevel >= 2 ) {
             cout << myname << "  Setting graph X range from data (" << xdmin << ", " << xdmax << ") to ("
                  << xmin-xoff << ", " << xmax+xoff << ")" << endl;
           }
         }
         if ( setYLimitsFromData ) {
           yoff = ymax;
           ymin = ydmin;
           ymax = ydmax;
           if ( m_LogLevel >= 2 ) {
             cout << myname << "  Setting graph Y range from data (" << ydmin << ", " << ydmax << ") to ("
                  << ymin-yoff << ", " << ymax+yoff << ")" << endl;
           }
         }
       }
       if ( xmax > xmin ) pg->GetXaxis()->SetRangeUser(xmin-xoff, xmax+xoff);
       if ( ymax > ymin ) pg->GetYaxis()->SetRangeUser(ymin-yoff, ymax+yoff);
       TPadManipulator man(1400, 500);
       man.add(pg, "P");
       string sttl = gin.ylab + " vs. " + gin.xlab + sttlSuf;
       man.setTitle(sttl.c_str());
       man.showUnderflow();
       man.showOverflow();
       man.addAxis();
       man.setGridX();
       man.setGridY();
       if ( xmax > xmin ) man.setRangeX(xmin-xoff, xmax+xoff);
       if ( ymax > ymin ) man.setRangeY(ymin-yoff, ymax+yoff);
       ostringstream ssfname;
       ssfname << "eviewg_" << gin.varx;
       if ( gin.xmax > gin.xmin ) ssfname << "-" << formatValue(gin.xmin, gin.varx)
                                          << "-" << formatValue(gin.xmax, gin.varx);
       ssfname << "_" << gin.vary;
       if ( gin.ymax > gin.ymin ) ssfname << "-" << formatValue(gin.ymin, gin.vary)
                                          << "-" << formatValue(gin.ymax, gin.vary);
       ssfname << "_run" << state().runString();
       ssfname << "_" << cr.name;
       ssfname << ".{png,tpad}";
       Name fname = ssfname.str();
       man.print(fname);
       if ( m_LogLevel >= 1 ) cout << myname << "  " << fname << endl;
     }
   }
 }

void AdcEventViewer::displayHists ( ) const

Definition at line 610 of file AdcEventViewer_tool.cc.

                                         {
   const string myname = "AdcEventViewer::displayHists: ";
   string sttlSuf = " for run " + state().runString();
   Index nevt = state().eventSet.size();
   if ( nevt == 0 ) sttlSuf += " with no events.";
   else if ( nevt == 1 ) sttlSuf += " event " + to_string(*state().eventSet.begin());
   else sttlSuf += " events " + to_string(*state().eventSet.begin()) + "-" + to_string(*state().eventSet.rbegin());
   string evstring;
   if ( state().eventSet.size() ) {
     evstring += "_event" + formatValue(*state().eventSet.cbegin(), "event");
     if ( state().eventSet.size() > 1 ) {
       evstring += "-" + formatValue(*state().eventSet.crbegin(), "event");
     }
   }
   for ( const IndexRange& cr : m_crs ) {
     ChannelRangeState& crstate = state().crstates[cr.name];
     Index nplt = crstate.hists.size();
     if ( m_LogLevel >= 1 ) cout << myname << "Creating " << nplt << " plot"
                                 << (nplt == 1 ? "" : "s") << sttlSuf
                                 << (nplt > 0 ? ":" : "") << endl;
     for ( TH1* ph : crstate.hists ) {
       TPadManipulator man;
       man.add(ph);
       string sttl = ph->GetTitle() + sttlSuf;
       string crlab = m_ChannelRangeLabel;
       StringManipulator smlab(crlab, false);
       smlab.replace("%CRNAME%", cr.name);
       smlab.replace("%CRLABEL%", cr.label());
       smlab.replace("%CRLABEL1%", cr.label(1));
       smlab.replace("%CRLABEL2%", cr.label(2));
       if ( crlab.size() ) sttl += " " + crlab;
       man.setTitle(sttl.c_str());
       
       string fname = string("eviewh_") + ph->GetName() + "_run" + state().runString()
                      + evstring + "_" + cr.name + ".{png,tpad}";
       man.showUnderflow();
       man.showOverflow();
       man.addAxis();
       man.print(fname);
       if ( m_LogLevel >= 1 ) cout << myname << "  " << fname << endl;
     }
   }
 }

DataMap AdcEventViewer::endEvent ( const DuneEventInfo & devt ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 421 of file AdcEventViewer_tool.cc.

                                                                 {
   const string myname = "AdcEventViewer::endEvent: ";
   if ( m_LogLevel >= 2 ) {
     cout << myname << "End processing event " << devt.event << " for run " << devt.run;
     if ( devt.subRun ) cout << "-" << devt.subRun;
     cout << endl;
   }
   DataMap ret;
   endEventState(devt);
   return ret;
 }

void AdcEventViewer::endEventState ( const DuneEventInfo & devt ) const

Definition at line 538 of file AdcEventViewer_tool.cc.

                                                                   {
   const string myname = "AdcEventViewer::endEventState: ";
   if ( ! devt.isValid() ) {
     cout << myname << "ERROR: End called without an active event." << endl;
     return;
   }
   if ( devt != state().eventInfo ) {
     cout << myname << "ERROR: End called without incorrect event info." << endl;
     return;
   }
   if ( state().event() == 0 ) return;
   Index nevt = state().events.size();
   Index ndup = nevt - state().eventSet.size();
   const int w = 5;
   long iclk = state().clock();
   iclk -= state().firstClock;
   // Plotted clock has zero 1 sec after the clock for the first event.
   float xclk = iclk + m_ClockRate;
   float time = m_ClockRate == 0.0 ? 0.0 : xclk/m_ClockRate;
   Name clkunit = m_ClockUnit;
   if      ( clkunit == "ktick" ) xclk *= 0.001;
   else if ( clkunit == "Mtick" ) xclk *= 0.000001;
   else if ( clkunit == "Gtick" ) xclk *= 0.000000001;
   if ( m_LogLevel >= 2 ) {
     cout << myname << "                 run: " << setw(w) << state().runString() << endl;
     cout << myname << "               event: " << setw(w) << state().event() << endl;
     cout << myname << "            # events: " << setw(w) << state().events.size() << endl;
     cout << myname << "  # duplicate events: " << setw(w) << ndup << endl;
     cout << myname << "           Min clock: " << setw(w) << state().minClock << endl;
     cout << myname << "               clock: " << setw(w+3) << fixed << setprecision(2) << xclk << " " << clkunit << endl;
     cout << myname << "                time: " << setw(w+3) << fixed << setprecision(2) << time << " sec" << endl;
     cout << myname << "            # groups: " << setw(w) << state().ngroup << endl;
   }
   for ( const IndexRange& cr : m_crs ) {
     ChannelRangeState& crstate = state().crstates[cr.name];
     Index nfmb = crstate.fembIDSet.size();
     Index nchn = crstate.nchan;
     float meanPed = nchn > 0 ? crstate.pedSum/nchn : 0.0;
     float meanPedPower = nchn > 0 ? crstate.pedPower/nchn : 0.0;
     float rmPedPower = sqrt(meanPedPower);
     double chanPerFemb = nfmb > 0 ? double(nchn)/nfmb : 0.0;
     if ( m_LogLevel >= 2 ) {
       cout << myname << "----- Channel range " << cr.label() << ":" << endl;
       cout << myname << "             # FEMBs: " << setw(w) << nfmb << endl;
       cout << myname << "          # channels: " << setw(w) << nchn << endl;
       cout << myname << "     # channels/FEMB: " << setw(w+5) << fixed << setprecision(4) << chanPerFemb << endl;
       cout << myname << "       Mean pedestal: " << setw(w+3) << fixed << setprecision(2) << meanPed << endl;
       cout << myname << "   RM pedestal power: " << setw(w+3) << fixed << setprecision(2) << rmPedPower << endl;
     }
     for ( TH1* ph : crstate.hists ) {
       string name = ph->GetName();
       if ( name.find("nfemb") != string::npos ) ph->Fill(nfmb);
       else if ( name.find("rmPedPower") != string::npos ) ph->Fill(rmPedPower);
       else if ( name.find("meanPed") != string::npos ) ph->Fill(meanPed);
       else {
         cout << myname << "ERROR: No variable for histogram name " << name << endl;
       }
     }
     for ( GraphInfo& gin : crstate.graphs ) {
       gin.add("event", state().event());
       gin.add("clock", xclk);
       gin.add("time", time);
       gin.add("nfemb", nfmb);
       gin.add("rmPedPower", rmPedPower);
       gin.add("meanPed", meanPed);
     }
   }
   state().eventInfo.clear();
 }

void AdcEventViewer::printReport ( ) const

State& AdcEventViewer::state ( ) const

inline

Definition at line 160 of file AdcEventViewer.h.

160 { return *m_state; }

AdcEventViewer::m_state

StatePtr m_state

Definition: AdcEventViewer.h:195

bool AdcEventViewer::updateWithView ( ) const

inlineoverridevirtual

Reimplemented from AdcChannelTool.

Definition at line 157 of file AdcEventViewer.h.

157 { return true; }

DataMap AdcEventViewer::view ( const AdcChannelData & acd ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 435 of file AdcEventViewer_tool.cc.

                                                             {
   const string myname = "AdcEventViewer::view: ";
   DataMap res;
   if ( m_LogLevel >= 4 ) cout << myname << "Processing channel " << acd.channel()
                               << " (FEMB " << acd.fembID() << ")"
                               << " in run " << acd.run() << " event " << acd.event() << endl;
   if ( acd.event() != state().event() || acd.run() != state().run() ) {
     if ( state().beginEventCount ) {
       cout << myname << "ERROR: Run:event from data " << acd.run() << ":" << acd.event()
            << " does not match that from beginEvent "
            << state().runString() << ":" << state().event() << endl;
       return res.setStatus(1);
     }
     beginEventState(acd.getEventInfo());
   }
   for ( const IndexRange& cr : m_crs ) {
     if ( cr.name != "all" && !cr.contains(acd.channel()) ) continue;
     ChannelRangeState& crstate = state().crstates[cr.name];
     crstate.fembIDSet.insert(acd.fembID());
     ++crstate.nchan;
     crstate.pedSum += acd.pedestal;
     float pedNoise = acd.pedestalRms;
     crstate.pedPower += pedNoise*pedNoise;
   }
   return res;
 }

DataMap AdcEventViewer::viewMap ( const AdcChannelDataMap & acds ) const

overridevirtual

Reimplemented from AdcChannelTool.

Definition at line 464 of file AdcEventViewer_tool.cc.

                                                                    {
   const string myname = "AdcEventViewer::viewMap: ";
   if ( m_LogLevel >= 3 ) {
     Index ncha = acds.size();
     cout << myname << "Processing " << ncha << " channel" << (ncha == 1 ? "" : "s");
     if ( ncha > 0 ) {
       const AdcChannelData& acd = acds.begin()->second;
       cout << " in run " << acd.run() << " event " << acd.event();
       cout << ". Count is " << state().beginEventCount << "." << endl;
     }
   }
   DataMap ret;
   if ( state().beginEventCount == 0 ) {
     if ( acds.size() == 0 ) {
       if ( m_LogLevel >=2 ) cout << myname << "Skipping group with no data" << endl;
       return ret;
     }
     const AdcChannelData& acd = acds.begin()->second;
     if ( acd.event() != state().event() ) beginEventState(acd.getEventInfo());
   }
   ++state().ngroup;
   for ( const AdcChannelDataMap::value_type& iacd : acds ) view(iacd.second);
   return ret;
 }

Member Data Documentation

Name AdcEventViewer::m_ChannelRangeLabel

private

Definition at line 187 of file AdcEventViewer.h.

NameVector AdcEventViewer::m_ChannelRanges

private

Definition at line 186 of file AdcEventViewer.h.

double AdcEventViewer::m_ClockRate

private

Definition at line 189 of file AdcEventViewer.h.

Name AdcEventViewer::m_ClockUnit

private

Definition at line 188 of file AdcEventViewer.h.

IndexRangeVector AdcEventViewer::m_crs

private

Definition at line 192 of file AdcEventViewer.h.

NameVector AdcEventViewer::m_EventGraphs

private

Definition at line 185 of file AdcEventViewer.h.

NameVector AdcEventViewer::m_EventHists

private

Definition at line 184 of file AdcEventViewer.h.

int AdcEventViewer::m_LogLevel

private

Definition at line 183 of file AdcEventViewer.h.

StatePtr AdcEventViewer::m_state

private

Definition at line 195 of file AdcEventViewer.h.

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

dunedataprep/dunedataprep/DataPrep/Tool/AdcEventViewer.h
dunedataprep/dunedataprep/DataPrep/Tool/AdcEventViewer_tool.cc

Classes

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation