Inheritance diagram for filter::ProtoDUNEUnstableHVFilter:

Public Member Functions
	ProtoDUNEUnstableHVFilter (fhicl::ParameterSet const &)

virtual	~ProtoDUNEUnstableHVFilter ()

uint64_t	GetRawDecoderInfo (art::Event &e)

bool	filter (art::Event &evt)

void	beginJob ()

void	endJob ()

void	reconfigure (fhicl::ParameterSet const &p)

Public Member Functions inherited from art::EDFilter
	EDFilter (fhicl::ParameterSet const &pset)

template<typename Config >
	EDFilter (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Filter
virtual	~Filter () noexcept

	Filter (fhicl::ParameterSet const &)

	Filter (Filter const &)=delete

	Filter (Filter &&)=delete

Filter &	operator= (Filter const &)=delete

Filter &	operator= (Filter &&)=delete

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 &)

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::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

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 Attributes
std::vector< std::pair< UInt_t, UInt_t > >	fTimeRanges

UInt_t	fTimeRangeLow

UInt_t	fTimeRangeHigh

bool	fDebug

long long	RDTSTime

double	RDTSTimeSec

int	RDTSTrigger

art::Handle< std::vector< raw::RDTimeStamp > >	RDTimeStampHandle

TH1D *	fSelectedEvents

TH1D *	fTotalEvents

Additional Inherited Members
Public Types inherited from art::EDFilter
using	ModuleType = EDFilter

using	WorkerType = WorkerT< EDFilter >

Public Types inherited from art::detail::Filter
template<typename UserConfig >
using	Table = Modifier::Table< UserConfig >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Attributes inherited from art::detail::Filter
static constexpr bool	Pass {true}

static constexpr bool	Fail {false}

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 45 of file ProtoDUNEUnstableHVFilter_module.cc.

Constructor & Destructor Documentation

filter::ProtoDUNEUnstableHVFilter::ProtoDUNEUnstableHVFilter ( fhicl::ParameterSet const & pset )

explicit

Definition at line 88 of file ProtoDUNEUnstableHVFilter_module.cc.

 : EDFilter(pset) {
         this->reconfigure(pset);
 }

filter::ProtoDUNEUnstableHVFilter::~ProtoDUNEUnstableHVFilter ( )

virtual

Definition at line 92 of file ProtoDUNEUnstableHVFilter_module.cc.

92 { }

Member Function Documentation

void filter::ProtoDUNEUnstableHVFilter::beginJob ( )

virtual

Reimplemented from art::EDFilter.

Definition at line 72 of file ProtoDUNEUnstableHVFilter_module.cc.

                                                { 
 
     art::ServiceHandle<art::TFileService> tfs;
     fSelectedEvents = tfs->make<TH1D>("fSelectedEvents", "Number of Selected Events", 3, 0, 3); //counts the number of selected events 
     fTotalEvents = tfs->make<TH1D>("fTotalEvents", "Total Events", 3, 0, 3); //counts the initial number of events in the unfiltered root input file
 }

void filter::ProtoDUNEUnstableHVFilter::endJob ( )

virtual

Reimplemented from art::EDFilter.

Definition at line 78 of file ProtoDUNEUnstableHVFilter_module.cc.

78 { }

bool filter::ProtoDUNEUnstableHVFilter::filter ( art::Event & evt )

virtual

Implements art::EDFilter.

Definition at line 133 of file ProtoDUNEUnstableHVFilter_module.cc.

                                                           {   
 
 
         fTotalEvents->Fill(1);
 
 
 
         if(!evt.isRealData()){
             fSelectedEvents->Fill(1); 
             return true;   //Filter is designed for Data only. Don't want to filter on MC
             }
 
 
 
         const std::string myname = "ProtoDUNEUnstableHVFilter::filter: ";
         bool keep = true;
         TTimeStamp * evtTTS;
         evtTTS = new TTimeStamp(GetRawDecoderInfo(evt));
         // if (evtTime.timeHigh() == 0) { evtTTS = new TTimeStamp(evtTime.timeLow()); }
         // else { evtTTS = new TTimeStamp(evtTime.timeHigh(), evtTime.timeLow()); }
         if (fDebug) std::cout << "Event time:  " << evtTTS -> AsString() << std::endl;
         // Requested time range lower end
 
         for (auto TimeRange : fTimeRanges){ //loop through unstable hv time ranges
 
             fTimeRangeLow=TimeRange.first;
             fTimeRangeHigh=TimeRange.second;
 
 
                         // Check that input time is in correct format
             
             
             // Check that input times are in correct format
             if (fTimeRangeHigh < 1000000000 || fTimeRangeLow < 1000000000 ) {
                     std::cout << "Warning: please provide time in POSIX foramt, event time "
                               << "filter returning false." << std::endl; 
                     return false;
 
             }
 
 
 
             if (fTimeRangeHigh < fTimeRangeLow ) {
                     std::cout << "Warning: Lower limit bigger than lower limit "
                               << "filter returning false." << std::endl; 
                     return false;
 
             }
             //no idea what this is supposed to be doing!! will reject any times before 10am
             // 
             // if (fTimeRangeHigh > 0 && fTimeRangeHigh < 100000) {
             //         std::cout << "Warning: please provide time in format HHMMSS, event time "
             //                   << "filter returning false.2" << std::endl; 
             //         return false;
             // }
             // if (fTimeRangeLow > 0 && fTimeRangeLow < 100000) {
             //         std::cout << "Warning: please provide time in format HHMMSS, event time "
             //                   << "filter returning false.3" << std::endl; 
             //         return false;
             // }
             // Event time
             //art::Timestamp evtTime = evt.time();
 
 
                 // all the checking he dies then ask if its in the correct range
 
             TTimeStamp * ttsLow(nullptr); 
             
         
             ttsLow = new TTimeStamp(fTimeRangeLow); 
             // Requested time range higher end
             TTimeStamp * ttsHigh(nullptr);
 
             ttsHigh = new TTimeStamp(fTimeRangeHigh); 
   
             // Filter decision
             if(fDebug){
                 std::cout << "Lower Limit:  " << ttsLow -> AsString() << std::endl;
                 std::cout << "Upper Limit:  " << ttsHigh -> AsString() << std::endl;
             }
     
                 
             if (evtTTS -> GetSec() > ttsLow -> GetSec() && 
                 evtTTS -> GetSec() < ttsHigh -> GetSec()) { keep=false; }
                     
 
     }
     if ( fDebug ) std::cout << myname << (keep ? "Keep" : "Reject") << "ing event." << std::endl;
     if (keep==true) fSelectedEvents->Fill(1); //count total events
     //keep=false; //for testing
     return keep;    //need this to stop the get to end error make sure to check this is working as intended
 }

uint64_t filter::ProtoDUNEUnstableHVFilter::GetRawDecoderInfo ( art::Event & e )

Definition at line 95 of file ProtoDUNEUnstableHVFilter_module.cc.

                                                                        {
     MF_LOG_INFO("BeamEvent") << "\n";
     MF_LOG_INFO("BeamEvent") << "Getting Raw Decoder Info" << "\n";
 
     art::InputTag itag1("timingrawdecoder","daq");
     RDTimeStampHandle = e.getHandle< std::vector<raw::RDTimeStamp> >(itag1);
     MF_LOG_INFO("BeamEvent") << "RDTS valid? " << RDTimeStampHandle.isValid() << "\n";
     for (auto const & RDTS : *RDTimeStampHandle){
         MF_LOG_INFO("BeamEvent") << "High: " << RDTS.GetTimeStamp_High() << "\n";
         MF_LOG_INFO("BeamEvent") << "Low: " << RDTS.GetTimeStamp_Low() << "\n";
 
         uint64_t high = RDTS.GetTimeStamp_High();
         uint64_t low  = RDTS.GetTimeStamp_Low();
 
         high = high << 32;
         uint64_t joined = (high | low);
 
         MF_LOG_INFO("BeamEvent") << "Raw Decoder Timestamp: " << joined << "\n";
 
         RDTSTime = joined;
         RDTSTrigger = RDTS.GetFlags();
         MF_LOG_INFO("BeamEvent") << "Trigger: " << RDTSTrigger << "\n";
 
         //Separates seconds portion of the ticks 
         //From the nanoseconds
         long long RDTSTickSec = (RDTSTime * 2) / (int)(TMath::Power(10,8));
         RDTSTickSec = RDTSTickSec * (int)(TMath::Power(10,8)) / 2;
         //long long RDTSTickNano = RDTSTime - RDTSTickSec;
 
         //Units are 20 nanoseconds ticks
         RDTSTimeSec  = 20.e-9 * RDTSTickSec;
         //RDTSTimeNano = 20.    * RDTSTickNano;
 
 
   }
   return RDTSTimeSec;
 }

void filter::ProtoDUNEUnstableHVFilter::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 81 of file ProtoDUNEUnstableHVFilter_module.cc.

                                                                             {
         fTimeRanges  = p.get<std::vector <std::pair<UInt_t,UInt_t >>>("TimeRanges");
         fDebug = p.get<int>("Debug");
 
 }  