ArtState.h

Go to the documentation of this file.

#ifndef NUTOOLS_RANDOMUTILS_ARTSTATE_H
#define NUTOOLS_RANDOMUTILS_ARTSTATE_H 1

// NuRandomService libraries
#include "nutools/RandomUtils/Providers/EventSeedInputData.h"

// framework libraries
#include "canvas/Utilities/Exception.h"
#include "canvas/Persistency/Provenance/EventAuxiliary.h"
#include "canvas/Persistency/Provenance/Timestamp.h"
#include "canvas/Persistency/Provenance/ModuleDescription.h"
#include "art/Framework/Principal/Event.h"

// supporting libraries
#include "messagefacility/MessageLogger/MessageLogger.h"

// C/C++ standard libraries
#include <string>


namespace rndm {
  
  namespace NuRandomServiceHelper {
    
    class ArtState {
        public:
      typedef enum {
        unDefined,             
        inServiceConstructor,  
        inModuleConstructor,   
        inBeginRun,            
        inModuleBeginRun,      
        inEvent,               
        inModuleEvent,         
        inEndJob,              
        inOther                
      } state_type; 
      
      using EventInfo_t = art::EventAuxiliary;
      
      
      ArtState(state_type start_state = unDefined)
        : artState(start_state)
        , lastEvent()
        , lastModule()
        , procName()
        {}
      
      // Accept compiler written d'tor, copy c'tor and copy assignment.
      
      void set_state(state_type astate) { artState = astate; }
      
      state_type transit_to(state_type astate)
        {
          state_type old_state = state();
          set_state(astate);
          LOG_DEBUG("ArtState")
            << "NuRandomService::ArtState: transition from "
            << stateName(old_state) << " to " << stateName();
          return old_state;
        } // transit_to()
      
      void reset_state() { transit_to(inOther); }
      
      void set_event(art::Event const& evt)
        {
          lastEvent = {
            evt.id(), evt.time(), evt.isRealData(), evt.experimentType()
            };
        } // set_event()
      void reset_event() { lastEvent = EventInfo_t(); }
      
      void set_module(art::ModuleDescription const& desc)
        {
          lastModule = desc;
          set_process_name(desc);
        }
      void reset_module() { lastModule = art::ModuleDescription(); }
      
      void set_process_name(std::string pn) { procName = pn; }
      void set_process_name(art::ModuleDescription const& currentModuleDesc)
        {
          if (!procName.empty()
            && (procName != currentModuleDesc.processName()))
          {
            throw art::Exception(art::errors::LogicError)
              << "Process name changed from '" << procName << "' to '"
              << currentModuleDesc.processName() << "'?!?";
          }
          procName = currentModuleDesc.processName();
        } // set_process_name()
      
      
      
      
      state_type state() const { return artState; }
      
      std::string stateName() const { return stateName(state()); }
      
      art::EventID const& eventID() const { return lastEvent.id(); }
      
      EventInfo_t const& eventInfo() const { return lastEvent; }
      
      art::ModuleDescription const& moduleDesc() const { return lastModule; }
      
      std::string moduleLabel() const { return lastModule.moduleLabel(); }
      
      std::string processName() const { return procName; }
      
      
      EventSeedInputData getEventSeedInputData() const
        {
          EventSeedInputData data;
          data.runNumber = eventID().run();
          data.subRunNumber = eventID().subRun();
          data.eventNumber = eventID().event();
          
          data.time = eventInfo().time().value();
          data.isTimeValid
            = (eventInfo().time() != art::Timestamp::invalidTimestamp());
          
          data.isData = eventInfo().isRealData();
          
          data.processName = processName();
          data.moduleType = moduleDesc().moduleName();
          data.moduleLabel = moduleLabel();
          
          return data;
        } // getEventSeedInputData()
      
      static std::string stateName(state_type state)
        {
          switch (state) {
            case unDefined:            return "(not assigned yet)";
            case inServiceConstructor: return "service construction";
            case inModuleConstructor:  return "module construction";
            case inBeginRun:           return "begin of run";
            case inModuleBeginRun:     return "begin of run for module";
            case inEvent:              return "event preparation";
            case inModuleEvent:        return "event processing by a module";
            case inEndJob:             return "end job";
            case inOther:              return "unidentified";
          } // switch
          throw art::Exception(art::errors::LogicError)
            << "artext::NuRandomServiceHelper::ArtState::stateName: unknown state #"
            << ((int) state) << "\n";
        } // stateName()
      
        protected:
      state_type artState; 
      
      EventInfo_t lastEvent;
      art::ModuleDescription lastModule;
      std::string procName;
    }; // end ArtState

  } // end namespace NuRandomServiceHelper

} // namespace rndm

#endif // NUTOOLS_RANDOMUTILS_ARTSTATE_H