Writes a set collection of beam gates into each event. More...

Inheritance diagram for icarus::trigger::BeamGateInfoFromTracks:

Classes
struct	Config

Public Types
using	nanoseconds = util::quantities::intervals::nanoseconds

using	Parameters = art::SharedProducer::Table< Config >

Public Member Functions
	BeamGateInfoFromTracks (Parameters const &config, art::ProcessingFrame const &)

virtual void	produce (art::Event &event, art::ProcessingFrame const &) override
	Fills the plots. Also extracts the information to fill them with. More...

Private Attributes
art::InputTag const	fT0selProducer
	Input particles. More...

art::InputTag const	fT0Producer
	Input particle/time associations. More...

nanoseconds const	fGateStartOffset
	Offset of gate start from particle time. More...

nanoseconds const	fGateDuration
	Width of the gate being created. More...

sim::BeamType_t const	fBeamGateType
	Type of gate saved. More...

std::string const	fLogCategory
	Message facility stream category for output. More...

Detailed Description

Writes a set collection of beam gates into each event.

This module writes a list of sim::BeamGateInfo based on the time associated to a selection of reconstructed tracks.

It may be used as input to modules which require to operate on beam gates, to select time(s) around the reconstructed (and selected) tracks.

Input data products

This module acts on a selection of tracks, which implies that the input is a set of pointers to tracks rather than to an actual track collection. For each track, an associated time is required.

std::vector<art::Ptr<recob::PFParticle>> (tag from T0selProducer): list of the selected particles to be considered
art::Assns<anab::T0, recob::PFParticle> (tag from T0Producer): association between particles and their time, which must include all pointers to the tracks listed in T0selProducer: each of those particles must be associated with exactly one anab::T0. The time convention is described in its own section.

Output data products

std::vector<sim::BeamGateInfo>: a collection of as many sim::BeamGateInfo as the BeamGates configuration parameter entries, with the content from them.
art::Assns<sim::BeamGateInfo, recob::PFParticle>: courtesy association between the selected particle and its gate, in the same order as the gates in their data product.
art::Assns<sim::BeamGateInfo, anab::T0>: courtesy association between the particle time and its gate, in the same order as the gates in their data product.

Configuration parameters

A terse online description of the parameters is printed by running lar --print-description BeamGateInfoFromTracks.

T0selProducer (input tag, mandatory): the list of pointers to the particles to be considered.
T0Producer (input tag, mandatory): the association of particles with their times.
GateStartOffset (time string, mandatory): the time of the opening of the gate with respect to the time of the particle; a positive offset means that the gate starts after the time of the particle.
GateEndOffset (time string, mandatory): the time of the closing of the gate with respect to the time of the particle.
GateType (string, default: "unknown"): type of the gates being written; see online description for the configuration keys representing the values of sim::GateType.
LogCategory (string, default: BeamGateInfoFromTracks): name of the output stream category for console messages (managed by MessageFacility library).

Note: Time strings are strings with a value and its mandatory unit. For example, 5.5 microseconds are expressed as "5.5 us" or "5500 ns".

Time scales

This module was introduced as a mean to determine the proper time intervals when to apply a trigger simulation. It is evident that for this use case a precise result requires the timing of the gates carefully aligned with the timing of the PMT. (the convention is that the PMT waveforms have a timestamp in the electronics time reference).

The time of the gates created by this module is offered as sim::BeamGateInfo; LArSoft prescribes it to be be specified in nanoseconds and in simulation time reference). Designed for simulation, this time scale refers to the opening of the beam gate (or its surrogate definition in samples with no beam to be gated). Or so is my understanding of it.

The input anab::T0, on the other end, as produced by the Pandora pattern recognition algorithm, and ultimately relative to the trigger time. In a perfectly aligned setup, this is equivalent to the trigger time in real data.

The output of this module attempts to adhere to that convention, and it defines the gate boundaries with respect to the beam gate time.

Definition at line 138 of file BeamGateInfoFromTracks_module.cc.

Member Typedef Documentation

using icarus::trigger::BeamGateInfoFromTracks::nanoseconds = util::quantities::intervals::nanoseconds

Definition at line 142 of file BeamGateInfoFromTracks_module.cc.

using icarus::trigger::BeamGateInfoFromTracks::Parameters = art::SharedProducer::Table<Config>

Definition at line 216 of file BeamGateInfoFromTracks_module.cc.

Constructor & Destructor Documentation

icarus::trigger::BeamGateInfoFromTracks::BeamGateInfoFromTracks	(	Parameters const &	config,
		art::ProcessingFrame const &
	)

explicit

Definition at line 287 of file BeamGateInfoFromTracks_module.cc.

   : art::SharedProducer(config)
   // configuration
   , fT0selProducer(config().T0selProducer())
   , fT0Producer(config().T0Producer())
   , fGateStartOffset(config().GateStartOffset())
   , fGateDuration(config().GateEndOffset() - fGateStartOffset)
   , fBeamGateType(config().getGateType())
   , fLogCategory(config().LogCategory())
 {
   
   async<art::InEvent>();
   
   //
   // output data declaration
   //
   produces<std::vector<sim::BeamGateInfo>>();
   produces<art::Assns<sim::BeamGateInfo, recob::PFParticle>>();
   produces<art::Assns<sim::BeamGateInfo, anab::T0>>();
   
   //
   // configuration report (short)
   //
   auto const& beamType
     = Config::GateTypeSelector.get(Config::GateType_t(fBeamGateType));
   
   mf::LogInfo{ fLogCategory }
     << "Configuration:"
     << "\n - particle selection: '" << fT0selProducer.encode() << '\''
     << "\n - associated times: '" << fT0Producer.encode() << '\''
     << "\n - gate around particle time: " << fGateStartOffset
     << " -- " << (fGateStartOffset+fGateDuration)
     << " (" << fGateDuration << "; gate type: \"" << beamType.name()
     << "\" [#" << fBeamGateType << "])"
     ;
   
 } // icarus::trigger::BeamGateInfoFromTracks::BeamGateInfoFromTracks()

Member Function Documentation

void icarus::trigger::BeamGateInfoFromTracks::produce	(	art::Event &	event,
		art::ProcessingFrame const &
	)

overridevirtual

Fills the plots. Also extracts the information to fill them with.

Definition at line 328 of file BeamGateInfoFromTracks_module.cc.

 {
   
   //
   // fetch input
   //
   auto const& particles
     = event.getProduct<std::vector<art::Ptr<recob::PFParticle>>>(fT0selProducer);
 
   mf::LogDebug(fLogCategory)
     << "Writing gates for " << particles.size() << " particles.";
 
   art::FindOneP<anab::T0> const particleT0(particles, event, fT0Producer);
   
   detinfo::DetectorTimings const detTimings {
     art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event)
     };
   
   // add this offset to a time vs. trigger to make it vs. beam gate
   nanoseconds const triggerToBeamGate
     = detTimings.TriggerTime() - detTimings.BeamGateTime();
   
   //
   // create the content
   //
   std::vector<sim::BeamGateInfo> gates;
   art::Assns<sim::BeamGateInfo, recob::PFParticle> gateToParticle;
   art::Assns<sim::BeamGateInfo, anab::T0> gateToTime;
   
   art::PtrMaker<sim::BeamGateInfo> const makeGatePtr { event };
   
   for (auto const& [ iParticle, particlePtr ]: util::enumerate(particles)) {
     
     art::Ptr<anab::T0> const t0Ptr = particleT0.at(iParticle);
     if (t0Ptr.isNull()) {
       art::Exception e { art::errors::NotFound };
       e << "Selected track #" << iParticle << " (";
       if (particlePtr) e << "ID=" << particlePtr->Self() << ", ";
       e << "#" << particlePtr.key()
         << " in its collection) has no associated time."
         ;
       throw e << '\n';
     } // if no T0
     
     // t0 is stored in trigger time
     detinfo::timescales::trigger_time const t0
       { util::quantities::points::nanosecond(t0Ptr->Time()) };
     
     // 1DetectorTimings1 does not handle the beam gate time when converting to
     // simulation time, so I need to explicitly add the difference
     detinfo::timescales::simulation_time const gateStart
       = detTimings.toSimulationTime(t0 + triggerToBeamGate + fGateStartOffset);
     
     // time conversion is currently redundant here, left as documentation
     sim::BeamGateInfo gate {
         gateStart.value()                                 // start
       , fGateDuration.convertInto<nanoseconds>().value()  // width
       , fBeamGateType                                     // type
       };
     
     {
       mf::LogTrace log{ fLogCategory };
       log << "Gate for selected track #" << iParticle << " (";
       if (particlePtr) log << "ID=" << particlePtr->Self() << ", ";
       log << "#" << particlePtr.key()
         << " in its collection): time = " << t0 << " => "
         << gate.Start() << " -- " << (gate.Start() + gate.Width())
         << " ns (" << gate.Width() << " ns)"
         ;
     }
     
     gates.push_back(std::move(gate));
     
     art::Ptr<sim::BeamGateInfo> gatePtr { makeGatePtr(gates.size() - 1) };
     gateToParticle.addSingle(gatePtr, particlePtr);
     gateToTime.addSingle(gatePtr, t0Ptr);
     
   } // for
   
   //
   // store output
   //
   event.put(moveToUniquePtr(gates));
   event.put(moveToUniquePtr(gateToParticle));
   event.put(moveToUniquePtr(gateToTime));
   
 } // icarus::trigger::BeamGateInfoFromTracks::produce()