dune::T0Counter Class Reference

Inheritance diagram for dune::T0Counter:

Classes
struct	t0

Public Member Functions
	T0Counter (fhicl::ParameterSet const &p)
	T0Counter (T0Counter const &)=delete
	T0Counter (T0Counter &&)=delete
T0Counter &	operator= (T0Counter const &)=delete
T0Counter &	operator= (T0Counter &&)=delete
void	produce (art::Event &e) override
void	beginJob () override
Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDProducer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept
	Producer (fhicl::ParameterSet const &)
	Producer (Producer const &)=delete
	Producer (Producer &&)=delete
Producer &	operator= (Producer const &)=delete
Producer &	operator= (Producer &&)=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 &mc)
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 Member Functions
double	tick2Time (unsigned int t)

Private Attributes
std::string	fTriggerModuleLabel
double	fClockSpeedCounter
double	fCombinedTimeDelay
int	fCoincidenceTolerance
bool	fVerbose
bool	fMakeTree
double	fSampleTimeCounter
double	fTriggerOffsetTPC
double	t0time
unsigned int	trigtype
int	trigbits
TTree *	fTree
int	run
int	subrun
int	event
int	ntrigs
unsigned int	auxdetid
unsigned int	tick
double	time

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >
Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)
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 37 of file T0Counter_module.cc.

Constructor & Destructor Documentation

dune::T0Counter::T0Counter ( fhicl::ParameterSet const &  p )

explicit

Definition at line 128 of file T0Counter_module.cc.

  : EDProducer{p}, fTriggerModuleLabel(p.get<std::string>("TriggerModuleLabel")),
    fClockSpeedCounter(p.get<double>("ClockSpeedCounter")), // MHz
    fCombinedTimeDelay(p.get<double>("CombinedTimeDelay")), // ns
    fCoincidenceTolerance(p.get<int>("CoincidenceTolerance")), // ticks
    fVerbose(p.get<bool>("Verbose",true)),
    fMakeTree(p.get<bool>("MakeTree",false))
{
  fSampleTimeCounter = 1.e3/fClockSpeedCounter;//ns

  auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();

  fTriggerOffsetTPC = clockData.TriggerOffsetTPC()*1.e3; // ns

  produces< std::vector< anab::T0 > >();
  produces< art::Assns< anab::T0, raw::ExternalTrigger> >();
}

dune::T0Counter::T0Counter ( T0Counter const &  )

delete

dune::T0Counter::T0Counter ( T0Counter &&  )

delete

Member Function Documentation

void dune::T0Counter::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 233 of file T0Counter_module.cc.

{
  art::ServiceHandle<art::TFileService> tfs;

  if (fMakeTree) {
    fTree = tfs->make<TTree>("T0Counter","T0Counter");
    fTree->Branch("run",&run,"run/I");
    fTree->Branch("subrun",&subrun,"subrun/I");
    fTree->Branch("event",&event,"event/I");
    fTree->Branch("ntrigs",&ntrigs,"ntrigs/I");
    fTree->Branch("auxdetid",&auxdetid,"auxdetid/I");
    fTree->Branch("tick",&tick,"tick/I");
    fTree->Branch("time",&time,"time/D");
  }
}

T0Counter& dune::T0Counter::operator= ( T0Counter const &  )

delete

T0Counter& dune::T0Counter::operator= ( T0Counter &&  )

delete

void dune::T0Counter::produce ( art::Event &  e )

overridevirtual

Implements art::EDProducer.

Definition at line 148 of file T0Counter_module.cc.

{
  // make collection of T0 objects, and associations
  std::unique_ptr< std::vector< anab::T0> > t0col(new std::vector<anab::T0>);
  std::unique_ptr< art::Assns< anab::T0, raw::ExternalTrigger> > assn( new art::Assns< anab::T0, raw::ExternalTrigger>);

  // get basic info
  run = e.run();
  subrun = e.subRun();
  event = e.id().event();
  
  // get raw::ExternalTriggers
  auto externalTriggerListHandle = e.getHandle< std::vector< raw::ExternalTrigger> >(fTriggerModuleLabel);
  if (externalTriggerListHandle)
    {

      std::vector< art::Ptr< raw::ExternalTrigger> > trigs;
      art::fill_ptr_vector(trigs,externalTriggerListHandle);

      ntrigs = externalTriggerListHandle->size();

      // this vector will contain t0 objects in a nice, convenient, organised package
      std::vector<t0> t0vect;

      // fill t0vect with triggers, group if times are within fCoincidenceTolerance
      for (auto const& trig : trigs) {
        auxdetid = trig->GetTrigID();
        tick = trig->GetTrigTime();
        time = tick2Time(tick);
        if (fMakeTree) fTree->Fill();
    
        // convert # PENN ticks tolerance to nsec
        double tol = fCoincidenceTolerance*fSampleTimeCounter;

        // loop over t0vect
        std::vector<t0>::iterator t0it;
        for (t0it = t0vect.begin(); t0it != t0vect.end(); ++t0it) {      
          // get t0 object
          t0* t = &(*t0it);
          // test for coincidence with all triggers associated with t0 object
          if (t->testCoincidence(time,tol)) {
            // insert trigger into t0
            t->insert(time,auxdetid,trig);
            // stop loop after one hit to prevent multiple insertions
            break;
          }      
        }
        // if the above loop didn't find a coincidence, create a new t0 object
        if (t0it == t0vect.end()) t0vect.push_back(t0(time,auxdetid,trig));
      }
  
      // print information, if interested
      if (fVerbose) {
        int num = 0;
        for (auto const &i : t0vect) {
          std::cout << "Trigger " << num << " has " << i.idtime.size() << " triggers associated." << std::endl;
          for (auto const &tit : i.idtime) {
            std::cout << "       time=" << std::fixed << std::setprecision(1) << tit.second << "  ID=" << tit.first << std::endl;
          }
          ++num;
        }
      }


      // make anab::T0 and Assns<anab::T0, raw::ExternalTrigger>
      for (auto const &i : t0vect) {
        t0time = i.avgTime(); // calculate average time of triggers, use as T0 time
        trigtype = 1; // use 1 for counters
        trigbits = i.idtime.size(); // number of associated triggers
        t0col->push_back(anab::T0(t0time,
                                  trigtype,
                                  trigbits,
                                  (*t0col).size()
                                  ));
        util::CreateAssn(*this, e, *t0col, i.trigs, *assn);
      }                       

    }
  e.put(std::move(t0col));
  e.put(std::move(assn));

}

double dune::T0Counter::tick2Time ( unsigned int  t )

private

Definition at line 251 of file T0Counter_module.cc.

{
  double calctime = (double)t+0.5;//get central value of tick bin
  calctime *= fSampleTimeCounter;//convert tick to time in ns
  calctime += fTriggerOffsetTPC;//adjust for possible TPC window offset
  calctime -= fCombinedTimeDelay;//correct for delay in signal propagation in cables and processing
  return calctime;
}

Member Data Documentation

unsigned int dune::T0Counter::auxdetid

private

Definition at line 119 of file T0Counter_module.cc.

int dune::T0Counter::event

private

Definition at line 117 of file T0Counter_module.cc.

double dune::T0Counter::fClockSpeedCounter

private

Definition at line 97 of file T0Counter_module.cc.

int dune::T0Counter::fCoincidenceTolerance

private

Definition at line 99 of file T0Counter_module.cc.

double dune::T0Counter::fCombinedTimeDelay

private

Definition at line 98 of file T0Counter_module.cc.

bool dune::T0Counter::fMakeTree

private

Definition at line 101 of file T0Counter_module.cc.

double dune::T0Counter::fSampleTimeCounter

private

Definition at line 104 of file T0Counter_module.cc.

TTree* dune::T0Counter::fTree

private

Definition at line 114 of file T0Counter_module.cc.

std::string dune::T0Counter::fTriggerModuleLabel

private

Definition at line 96 of file T0Counter_module.cc.

double dune::T0Counter::fTriggerOffsetTPC

private

Definition at line 105 of file T0Counter_module.cc.

bool dune::T0Counter::fVerbose

private

Definition at line 100 of file T0Counter_module.cc.

int dune::T0Counter::ntrigs

private

Definition at line 118 of file T0Counter_module.cc.

int dune::T0Counter::run

private

Definition at line 115 of file T0Counter_module.cc.

int dune::T0Counter::subrun

private

Definition at line 116 of file T0Counter_module.cc.

double dune::T0Counter::t0time

private

Definition at line 108 of file T0Counter_module.cc.

unsigned int dune::T0Counter::tick

private

Definition at line 120 of file T0Counter_module.cc.

double dune::T0Counter::time

private

Definition at line 121 of file T0Counter_module.cc.

int dune::T0Counter::trigbits

private

Definition at line 110 of file T0Counter_module.cc.

unsigned int dune::T0Counter::trigtype

private

Definition at line 109 of file T0Counter_module.cc.

---

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

• duneprototypes/duneprototypes/Protodune/singlephase/T0Reco/T0Counter_module.cc