CRT::DQMPlotter< TFS > Class Template Reference

Classes
struct	ModulePlots

Public Member Functions
	DQMPlotter (TFS &tfs, const double timeTickSize, std::unique_ptr< CRT::Geometry > &&geom)
virtual	~DQMPlotter ()=default
void	AnalyzeEvent (const std::vector< CRT::Trigger > &triggers)

Private Attributes
TFS	fFileService
std::map< CRT::ModuleID, ModulePlots< decltype(fFileService->mkdir("test"))> >	fModules
TH1D *	fTimestamps
TH1D *	fTriggerDeltaT
TH1D *	fTriggerTime
TH1D *	fDeltaTSeconds
TH1D *	fEventLength
uint64_t	fFirstTime
const double	fTickSize
std::unique_ptr< CRT::Geometry >	fGeom

Detailed Description

template<class TFS>
class CRT::DQMPlotter< TFS >

Definition at line 35 of file DQMPlotter.cpp.

Constructor & Destructor Documentation

template<class TFS >

CRT::DQMPlotter< TFS >::DQMPlotter ( TFS &  tfs, const double  timeTickSize, std::unique_ptr< CRT::Geometry > &&  geom  )

inline

Definition at line 39 of file DQMPlotter.cpp.

                                                                                        : fFileService(tfs), 
                                                                                              fFirstTime(std::numeric_limits<uint64_t>::max()), 
                                                                                              fTickSize(timeTickSize), fGeom(std::move(geom))
      {
        fTimestamps = fFileService->template make<TH1D>("timestamps", "Timestamps for All Modules;Timestamp;Triggers", 300, 6.592522e18, 6.592525e18); //Trigger automatic binning?
        fTriggerDeltaT = fFileService->template make<TH1D>("triggerDeltaT", "Time Difference Between Two Triggers on Any Channel;"
                                                                            "#Delta T[ns];Triggrs", 1000, -50, 100);

        fTriggerTime = fFileService->template make<TH1D>("triggerTime", "Time of each Trigger in Run;Time [s];Triggers", 100, 0, 3);

        fDeltaTSeconds =  fFileService->template make<TH1D>("deltaTSeconds", "Difference in Elapsed Time Between Adjacent Triggers;#Delta T [s];"
                                                                             "Triggers", 400, -0.3, 0.3);

        fEventLength = fFileService->template make<TH1D>("EventLength", "Time Ticks Between Earliest and Latest Triggers;#DeltaT [ticks];Events", 
                                                         100, 0, 100);
      }

template<class TFS >

virtual CRT::DQMPlotter< TFS >::~DQMPlotter ( )

virtualdefault

Member Function Documentation

template<class TFS >

void CRT::DQMPlotter< TFS >::AnalyzeEvent ( const std::vector< CRT::Trigger > &  triggers )

inline

Definition at line 60 of file DQMPlotter.cpp.

      {
        const auto end = triggers.cend();
        auto prev = end;

        //If first timestamp hasn't been set to a suitable value yet, try to set it now to the 
        //earliest timestamp in this event.
        if(fFirstTime == std::numeric_limits<uint64_t>::max())
        {
          for(const auto& trigger: triggers) 
          {
            if(trigger.Timestamp() > 1e18 && trigger.Timestamp() < fFirstTime) 
            {
              fFirstTime =  trigger.Timestamp();
            }
          }
        }

        //Map from Trigger to times in frame along each axis.  First element is first 2 Triggers (alternates x and y), and second element is 
        //second 2 triggers (alternates y and x).  What the "first" element means is different between frames, but it is consistent within a 
        //frame.  
        std::map<CRT::FrameID, std::map<CRT::PlaneID, std::vector<uint64_t>>> moduleToOverlapTimes; 
        uint64_t earliest = std::numeric_limits<uint64_t>::max(), latest = 1e16;
        for(auto iter = triggers.cbegin(); iter != end; ++iter)
        { 
          const auto& trigger = *iter;

          fTimestamps->Fill(trigger.Timestamp());
          if(prev != end)
          {
            fTriggerDeltaT->Fill(trigger.Timestamp()-prev->Timestamp());
          }

          //Find the plots for this Module
          const auto moduleID = fGeom->ModuleID(trigger.Channel());
          std::cout << "Looking for plots for module " << trigger.Channel() << "\n";
          auto found = fModules.find(moduleID);
          if(found == fModules.end())
          {
            std::cout << "Adding directory for module " << trigger.Channel() << "\n";
            found = fModules.emplace(moduleID, ModulePlots<decltype(fFileService->mkdir("test"))>(fFileService->mkdir("module"+std::to_string(trigger.Channel())))).first;
          }
          auto& module = found->second;

          //Keep track of times of overlaps in this event
          moduleToOverlapTimes[moduleID][moduleID].push_back(trigger.Timestamp());

          //Keep track of earliest and latest Trigger times in the event
          if(trigger.Timestamp() > 1e16 && trigger.Timestamp() < earliest) earliest = trigger.Timestamp();
          if(trigger.Timestamp() > latest) latest = trigger.Timestamp();
          
          if(trigger.Timestamp() > 1e16) //TODO: What do the very small timestamps represent?  They have UNIX timestamp of 0
          {
            //Plot lower 32 timestamp bits versus time since beginning of event.
            //To get time since beginning of event, I have to extract each part of the timestamp and convert the lower half to seconds.  
            const double elapsed = (trigger.Timestamp() - fFirstTime)*fTickSize; //In seconds.  
            fTriggerTime->Fill(elapsed);
            fDeltaTSeconds->Fill(elapsed-module.fPrevSeconds); 
            module.fPrevSeconds = elapsed; 

            if(module.fPrevTimestamp < std::numeric_limits<unsigned long long>::max()) //Don't fill fPrevTimestamp if there WAS no 
                                                                                       //fPrevTimestamp
            {
              module.fTriggerDeltaT->Fill(trigger.Timestamp()-module.fPrevTimestamp);
            }
            module.fPrevTimestamp = trigger.Timestamp(); //This also sets the first fPrevTimestamp value
          }

          const auto& hits = trigger.Hits();
          module.fHitsPerTrigger->Fill(hits.size());
          for(const auto& hit: hits)
          {
            const auto channel = hit.Channel();
            module.fHits->Fill(channel);

            const auto adcFound = module.fChannelToADC.find(channel);
            if(adcFound == module.fChannelToADC.end())
            {
              const auto name = "channel"+std::to_string(channel);
              module.fChannelToADC[channel] = module.fDir.template make<TH1D>(name.c_str(), ("Hits on Channel "
                                                                              +std::to_string(channel)).c_str(), 
                                                                              500, 0, 2000);
            } 

            module.fChannelToADC[channel]->Fill(hit.ADC());
            module.fAllADC->Fill(hit.ADC());
          } //For each Hit
          prev = iter;
        } //For each Trigger

        if(triggers.size() > 1) fEventLength->Fill(latest-earliest);

        //Fill overlap histograms
        for(const auto& trigger: triggers)
        {
          const auto thisTime = trigger.Timestamp();
          const auto& id = fGeom->ModuleID(trigger.Channel());

          //Find the plots for this module if any
          auto found = fModules.find(id); 
          if(found == fModules.end()) continue; 
          auto& plots = found->second;

          const auto& frame = moduleToOverlapTimes[id];
          const auto thisPlane = frame.find(id);
          for(auto plane = frame.begin(); plane != frame.end(); ++plane)
          {
            if(plane != thisPlane) //TODO: I know that there will always be exactly 2 orientations for the CRT, 
                                   //      so maybe I should use some dedicated keyed container with a complement() 
                                   //      function here.  
            {
              for(const auto& time: plane->second) plots.fDeltaTOverlap->Fill(thisTime-time); 
            } //If this is not the plane of the current Trigger
          } //For each plane in this Trigger's frame
        } //For each Trigger in this event
      }

Member Data Documentation

template<class TFS >

TH1D* CRT::DQMPlotter< TFS >::fDeltaTSeconds

private

Definition at line 217 of file DQMPlotter.cpp.

template<class TFS >

TH1D* CRT::DQMPlotter< TFS >::fEventLength

private

Definition at line 218 of file DQMPlotter.cpp.

template<class TFS >

TFS CRT::DQMPlotter< TFS >::fFileService

private

Definition at line 178 of file DQMPlotter.cpp.

template<class TFS >

uint64_t CRT::DQMPlotter< TFS >::fFirstTime

private

Definition at line 221 of file DQMPlotter.cpp.

template<class TFS >

std::unique_ptr<CRT::Geometry> CRT::DQMPlotter< TFS >::fGeom

private

Definition at line 223 of file DQMPlotter.cpp.

template<class TFS >

std::map<CRT::ModuleID, ModulePlots<decltype(fFileService->mkdir("test"))> > CRT::DQMPlotter< TFS >::fModules

private

Definition at line 213 of file DQMPlotter.cpp.

template<class TFS >

const double CRT::DQMPlotter< TFS >::fTickSize

private

Definition at line 222 of file DQMPlotter.cpp.

template<class TFS >

TH1D* CRT::DQMPlotter< TFS >::fTimestamps

private

Definition at line 214 of file DQMPlotter.cpp.

template<class TFS >

TH1D* CRT::DQMPlotter< TFS >::fTriggerDeltaT

private

Definition at line 215 of file DQMPlotter.cpp.

template<class TFS >

TH1D* CRT::DQMPlotter< TFS >::fTriggerTime

private

Definition at line 216 of file DQMPlotter.cpp.

---

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

• duneprototypes/duneprototypes/Protodune/singlephase/CRT/alg/monitor/DQMPlotter.cpp