Inheritance diagram for detsim::SimDriftElectrons:

Classes
struct	ChannelBookKeeping

Public Types
using	ModuleType = EDProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	SimDriftElectrons (fhicl::ParameterSet const &pset)

void	produce (art::Event &evt) override

void	beginJob () override

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)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

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)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Protected Member Functions
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 ()

Private Types
typedef std::unordered_map< raw::ChannelID_t, ChannelBookKeeping >	ChannelMap_t

Private Attributes
art::InputTag	fSimModuleLabel

CLHEP::RandGauss	fRandGauss

double	fElectronLifetime

double	fElectronClusterSize

int	fMinNumberOfElCluster

double	fLongitudinalDiffusion

double	fTransverseDiffusion

double	fLifetimeCorr_const

double	fLDiff_const

double	fTDiff_const

double	fRecipDriftVel [3]

bool	fStoreDriftedElectronClusters

std::vector< ChannelMap_t >	fChannelMaps

size_t	fNCryostats

std::vector< size_t >	fNTPCs

std::vector< double >	fLongDiff

std::vector< double >	fTransDiff1

std::vector< double >	fTransDiff2

std::vector< double >	fnElDiff

std::vector< double >	fnEnDiff

double	fDriftClusterPos [3]

art::ServiceHandle< geo::Geometry const >	fGeometry
	Handle to the Geometry service. More...

Detailed Description

Definition at line 89 of file SimDriftElectrons_module.cc.

Member Typedef Documentation

typedef std::unordered_map<raw::ChannelID_t, ChannelBookKeeping> detsim::SimDriftElectrons::ChannelMap_t

private

Definition at line 125 of file SimDriftElectrons_module.cc.

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

detsim::SimDriftElectrons::SimDriftElectrons ( fhicl::ParameterSet const & pset )

explicit

Definition at line 150 of file SimDriftElectrons_module.cc.

References art::detail::EngineCreator::createEngine(), fRandGauss, fSimModuleLabel, and fStoreDriftedElectronClusters.

     : art::EDProducer{pset}
     , fSimModuleLabel{pset.get<art::InputTag>("SimulationLabel")}
     // create a default random engine; obtain the random seed from
     // NuRandomService, unless overridden in configuration with key
     // "Seed"
     , fRandGauss{art::ServiceHandle<rndm::NuRandomService>{}
                  -> registerAndSeedEngine(createEngine(0), pset, "Seed")}
     , fStoreDriftedElectronClusters{pset.get<bool>("StoreDriftedElectronClusters", false)}
   {
     produces<std::vector<sim::SimChannel>>();
     if (fStoreDriftedElectronClusters) { produces<std::vector<sim::SimDriftedElectronCluster>>(); }
   }

Member Function Documentation

void detsim::SimDriftElectrons::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 165 of file SimDriftElectrons_module.cc.

References e, sim::LArG4Parameters::ElectronClusterSize(), fElectronClusterSize, fElectronLifetime, fGeometry, fLDiff_const, fLifetimeCorr_const, fLongitudinalDiffusion, fMinNumberOfElCluster, fNCryostats, fNTPCs, fRecipDriftVel, fTDiff_const, fTransverseDiffusion, sim::LArG4Parameters::LongitudinalDiffusion(), MF_LOG_DEBUG, sim::LArG4Parameters::MinNumberOfElCluster(), n, geo::GeometryCore::Ncryostats(), geo::GeometryCore::NTPC(), and sim::LArG4Parameters::TransverseDiffusion().

   {
     // Define the physical constants we'll use.
 
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob();
     fElectronLifetime = detProp.ElectronLifetime(); // Electron lifetime as returned by the
       // DetectorProperties service assumed to be in us;
     for (int i = 0; i < 3; ++i) {
       double driftVelocity = detProp.DriftVelocity(detProp.Efield(i),
                                                    detProp.Temperature()) *
                              1.e-3; //  Drift velocity as returned by the DetectorProperties service
                                     //  assumed to be in cm/us. Multiply by 1.e-3 to convert into
                                     //  LArSoft standard velocity units, cm/ns;
 
       fRecipDriftVel[i] = 1. / driftVelocity;
     }
 
     // To-do: Move the parameters we fetch from "LArG4" to detector properties.
     art::ServiceHandle<sim::LArG4Parameters const> paramHandle;
     fElectronClusterSize = paramHandle->ElectronClusterSize();
     fMinNumberOfElCluster = paramHandle->MinNumberOfElCluster();
     fLongitudinalDiffusion = paramHandle->LongitudinalDiffusion(); // cm^2/ns units
     fTransverseDiffusion = paramHandle->TransverseDiffusion();     // cm^2/ns units
 
     MF_LOG_DEBUG("SimDriftElectrons")
       << " e lifetime (ns): " << fElectronLifetime
       << "\n Temperature (K): " << detProp.Temperature()
       << "\n Drift velocity (cm/ns): " << 1. / fRecipDriftVel[0] << " " << 1. / fRecipDriftVel[1]
       << " " << 1. / fRecipDriftVel[2];
 
     // Opposite of lifetime. Convert from us to standard LArSoft time units, ns;
     fLifetimeCorr_const = -1000. * fElectronLifetime;
     fLDiff_const = std::sqrt(2. * fLongitudinalDiffusion);
     fTDiff_const = std::sqrt(2. * fTransverseDiffusion);
 
     // For this detector's geometry, save the number of cryostats and the number of TPCs
     // within each cryostat.
     fNCryostats = fGeometry->Ncryostats();
     fNTPCs.resize(fNCryostats);
     for (size_t n = 0; n < fNCryostats; ++n)
       fNTPCs[n] = fGeometry->NTPC(geo::CryostatID(n));
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::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
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

void detsim::SimDriftElectrons::produce ( art::Event & evt )

overridevirtual

Todo:: think about effects of drift between planes.

Todo:: think about effects of drift between planes

Todo:: check on what happens if we allow the tdc value to be

Todo:: beyond the end of the expected number of ticks

Implements art::EDProducer.

Definition at line 210 of file SimDriftElectrons_module.cc.

References util::abs(), sim::SimChannel::AddIonizationElectrons(), detsim::SimDriftElectrons::ChannelBookKeeping::channelIndex, geo::vect::coord(), geo::CryostatID::Cryostat, DEFINE_ART_MODULE, geo::TPCGeo::DriftAxisWithSign(), e, energy, fChannelMaps, fDriftClusterPos, fElectronClusterSize, fGeometry, fLDiff_const, fLifetimeCorr_const, fLongDiff, fMinNumberOfElCluster, fNCryostats, fnElDiff, fnEnDiff, fRandGauss, fRecipDriftVel, fSimModuleLabel, fStoreDriftedElectronClusters, fTDiff_const, fTransDiff1, fTransDiff2, Get, art::ProductRetriever::getByLabel(), geo::CryostatID::getInvalidID(), geo::TPCID::getInvalidID(), MF_LOG_DEBUG, larsim::Utils::SCE::out_of_bounds(), geo::GeometryCore::PositionToCryostatID(), geo::GeometryCore::PositionToTPCID(), pmtana::sign(), detsim::SimDriftElectrons::ChannelBookKeeping::stepList, geo::to_int(), geo::vect::toPoint(), geo::TPCID::TPC, geo::GeometryCore::TPC(), xx, geo::Y, and geo::Z.

   {
     // Fetch the SimEnergyDeposit objects for this event.
     typedef art::Handle<std::vector<sim::SimEnergyDeposit>> energyDepositHandle_t;
     energyDepositHandle_t energyDepositHandle;
     // If there aren't any energy deposits for this event, don't panic. It's possible
     // someone is doing a study with events outside the TPC, or where there are only
     // non-ionizing particles, or something like that.
     if (!event.getByLabel(fSimModuleLabel, energyDepositHandle)) return;
 
     // Define the container for the SimChannel objects that will be transferred to the
     // art::Event after the put statement below.
     std::unique_ptr<std::vector<sim::SimChannel>> channels(new std::vector<sim::SimChannel>);
     // Container for the SimDriftedElectronCluster objects
     std::unique_ptr<std::vector<sim::SimDriftedElectronCluster>>
       SimDriftedElectronClusterCollection(new std::vector<sim::SimDriftedElectronCluster>);
 
     // Clear the channel maps from the last event. Remember, fChannelMaps is an
     // array[cryo][tpc] of maps.
     size_t cryo = 0;
     fChannelMaps.resize(fNCryostats);
     for (auto& cryoData : fChannelMaps) { // each, a vector of maps
       cryoData.clear();
     }
 
     auto const clockData =
       art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const& tpcClock = clockData.TPCClock();
 
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
     // We're going through the input vector by index, rather than by iterator, because we
     // need the index number to compute the associations near the end of this method.
     auto const& energyDeposits = *energyDepositHandle;
     auto energyDepositsSize = energyDeposits.size();
 
     // For each energy deposit in this event
     auto const& wireReadoutGeom = art::ServiceHandle<geo::WireReadout const>()->Get();
     for (size_t edIndex = 0; edIndex < energyDepositsSize; ++edIndex) {
       auto const& energyDeposit = energyDeposits[edIndex];
 
       // "xyz" is the position of the energy deposit in world coordinates. Note that the
       // units of distance in sim::SimEnergyDeposit are supposed to be cm.
       auto const mp = energyDeposit.MidPoint();
       std::array<double, 3> xyz;
       mp.GetCoordinates(data(xyz));
 
       // From the position in world coordinates, determine the cryostat and tpc. If
       // somehow the step is outside a tpc (e.g., cosmic rays in rock) just move on to the
       // next one.
       unsigned int cryostat = 0;
       cryostat = fGeometry->PositionToCryostatID(mp).Cryostat;
       if (cryostat == geo::CryostatID::getInvalidID()) {
         mf::LogWarning("SimDriftElectrons") << "step " // << energyDeposit << "\n"
                                             << "cannot be found in a cryostat\n";
         continue;
       }
 
       geo::TPCID tpcid;
       tpcid = fGeometry->PositionToTPCID(mp);
       if (tpcid.TPC == geo::TPCID::getInvalidID()) {
         mf::LogWarning("SimDriftElectrons") << "step " // << energyDeposit << "\n"
                                             << "cannot be found in a TPC\n";
         continue;
       }
 
       geo::TPCGeo const& tpcGeo = fGeometry->TPC(tpcid);
       unsigned int const nplanes = wireReadoutGeom.Nplanes(tpcid);
 
       // The drift direction can be either in the positive or negative direction in any
       // coordinate x, y or z.
 
       // Define charge drift direction: driftcoordinate (x, y or z) and driftsign
       // (positive or negative). Also define coordinates perpendicular to drift direction.
 
       auto const [axis, sign] = tpcGeo.DriftAxisWithSign();
 
       // For axis == geo::Coordinate::X
       int driftcoordinate = 0;
       int transversecoordinate1 = 1;
       int transversecoordinate2 = 2;
       if (axis == geo::Coordinate::Y) {
         transversecoordinate1 = 0;
         driftcoordinate = 1;
         transversecoordinate2 = 2;
       }
       else if (axis == geo::Coordinate::Z) {
         transversecoordinate1 = 0;
         transversecoordinate2 = 1;
         driftcoordinate = 2;
       }
 
       int const driftsign = to_int(sign); // 1: +x, +y or +z, -1: -x, -y or -z
 
       // Check for charge deposits behind charge readout planes
       auto const& plane_location = wireReadoutGeom.FirstPlane(tpcid).GetCenter();
       auto const plane_location_coord = geo::vect::coord(plane_location, driftcoordinate);
       if (driftsign == 1 && plane_location_coord < xyz[driftcoordinate]) continue;
       if (driftsign == -1 && plane_location_coord > xyz[driftcoordinate]) continue;
 
       // Center of plane is also returned in cm units
       double DriftDistance = std::abs(xyz[driftcoordinate] - plane_location_coord);
 
       // Space-charge effect (SCE): Get SCE {x,y,z} offsets for particular location in TPC
       geo::Vector_t posOffsets{0.0, 0.0, 0.0};
       double posOffsetxyz[3] = {0.0, 0.0, 0.0}; // need this array for the driftcoordinate and
                                                 // transversecoordinates
       auto const* SCE = lar::providerFrom<spacecharge::SpaceChargeService>();
       if (SCE->EnableSimSpatialSCE() == true) {
         posOffsets = SCE->GetPosOffsets(mp);
         if (larsim::Utils::SCE::out_of_bounds(posOffsets)) { continue; }
         posOffsetxyz[0] = posOffsets.X();
         posOffsetxyz[1] = posOffsets.Y();
         posOffsetxyz[2] = posOffsets.Z();
       }
 
       double avegagetransversePos1 = 0.;
       double avegagetransversePos2 = 0.;
 
       DriftDistance += -1. * posOffsetxyz[driftcoordinate];
       avegagetransversePos1 = xyz[transversecoordinate1] + posOffsetxyz[transversecoordinate1];
       avegagetransversePos2 = xyz[transversecoordinate2] + posOffsetxyz[transversecoordinate2];
 
       // Space charge distortion could push the energy deposit beyond the wire plane (see
       // issue #15131). Given that we don't have any subtlety in the simulation of this
       // region, bringing the deposit exactly on the plane should be enough for the time
       // being.
       if (DriftDistance < 0.) DriftDistance = 0.;
 
       // Drift time in ns
       double TDrift = DriftDistance * fRecipDriftVel[0];
 
       if (nplanes == 2 &&
           driftcoordinate == 0) { // special case for ArgoNeuT (Nplanes = 2 and drift direction =
                                   // x): plane 0 is the second wire plane
         double const pitch = wireReadoutGeom.PlanePitch(tpcid, 0, 1);
         TDrift = ((DriftDistance - pitch) * fRecipDriftVel[0] + pitch * fRecipDriftVel[1]);
       }
 
       const int nIonizedElectrons = energyDeposit.NumElectrons();
       const double lifetimecorrection = TMath::Exp(TDrift / fLifetimeCorr_const);
       const double energy = energyDeposit.Energy();
 
       // if we have no electrons (too small energy or too large recombination)
       // we are done already here
       if (nIonizedElectrons <= 0) {
         MF_LOG_DEBUG("SimDriftElectrons")
           << "step " // << energyDeposit << "\n"
           << "No electrons drifted to readout, " << energy << " MeV lost.";
         continue;
       }
 
       // includes the effect of lifetime: lifetimecorrection = exp[-tdrift/tau]
       const double nElectrons = nIonizedElectrons * lifetimecorrection;
 
       // Longitudinal & transverse diffusion sigma (cm)
       double SqrtT = std::sqrt(TDrift);
       double LDiffSig = SqrtT * fLDiff_const;
       double TDiffSig = SqrtT * fTDiff_const;
       double electronclsize = fElectronClusterSize;
 
       // Number of electron clusters.
       int nClus = (int)std::ceil(nElectrons / electronclsize);
       if (nClus < fMinNumberOfElCluster) {
         electronclsize = nElectrons / fMinNumberOfElCluster;
         if (electronclsize < 1.0) { electronclsize = 1.0; }
         nClus = (int)std::ceil(nElectrons / electronclsize);
       }
 
       // Empty and resize the electron-cluster vectors.
       fLongDiff.clear();
       fTransDiff1.clear();
       fTransDiff2.clear();
       fnElDiff.clear();
       fnEnDiff.clear();
       fLongDiff.resize(nClus);
       fTransDiff1.resize(nClus);
       fTransDiff2.resize(nClus);
       fnElDiff.resize(nClus, electronclsize);
       fnEnDiff.resize(nClus);
 
       // fix the number of electrons in the last cluster, that has a smaller size
       fnElDiff.back() = nElectrons - (nClus - 1) * electronclsize;
 
       for (size_t xx = 0; xx < fnElDiff.size(); ++xx) {
         if (nElectrons > 0)
           fnEnDiff[xx] = energy / nElectrons * fnElDiff[xx];
         else
           fnEnDiff[xx] = 0.;
       }
 
       // Smear drift times by longitudinal diffusion
       if (LDiffSig > 0.0)
         fRandGauss.fireArray(nClus, &fLongDiff[0], 0., LDiffSig);
       else
         fLongDiff.assign(nClus, 0.0);
 
       if (TDiffSig > 0.0) {
         // Smear the coordinates in plane perpendicular to drift direction by the transverse diffusion
         fRandGauss.fireArray(nClus, &fTransDiff1[0], avegagetransversePos1, TDiffSig);
         fRandGauss.fireArray(nClus, &fTransDiff2[0], avegagetransversePos2, TDiffSig);
       }
       else {
         fTransDiff1.assign(nClus, avegagetransversePos1);
         fTransDiff2.assign(nClus, avegagetransversePos2);
       }
 
       // make a collection of electrons for each plane
       for (unsigned int p = 0; p < nplanes; ++p) {
         // FIXME (KJK): Shouldn't this be the location for each plane we're iterating
         // through?  Right now it uses whatever value of plane_location_coord was set
         // above.
         fDriftClusterPos[driftcoordinate] = plane_location_coord;
 
         // Drift nClus electron clusters to the induction plane
         for (int k = 0; k < nClus; ++k) {
 
           // Correct drift time for longitudinal diffusion and plane
           double TDiff = TDrift + fLongDiff[k] * fRecipDriftVel[0];
 
           // Take into account different Efields between planes.  Also take into account
           // special case for ArgoNeuT (Nplanes = 2 and drift direction = x): plane 0 is
           // the second wire plane
           for (unsigned int ip = 0; ip < p; ++ip) {
             TDiff += wireReadoutGeom.PlanePitch(tpcid, ip + 1, ip) *
                      fRecipDriftVel[(nplanes == 2 && driftcoordinate == 0) ? ip + 2 : ip + 1];
           }
 
           fDriftClusterPos[transversecoordinate1] = fTransDiff1[k];
           fDriftClusterPos[transversecoordinate2] = fTransDiff2[k];
 
 
           // grab the nearest channel to the fDriftClusterPos position
           try {
             raw::ChannelID_t channel = wireReadoutGeom.NearestChannel(
               geo::vect::toPoint(fDriftClusterPos), geo::PlaneID{tpcid, p});
 
             // Add potential decay/capture/etc delay effect, simTime.
             auto const simTime = energyDeposit.Time();
             unsigned int tdc = tpcClock.Ticks(clockData.G4ToElecTime(TDiff + simTime));
 
             // Find whether we already have this channel in our map.
             ChannelMap_t& channelDataMap = fChannelMaps[cryostat];
             auto search = channelDataMap.find(channel);
 
             // We will find (or create) the pointer to a sim::SimChannel.
             size_t channelIndex = 0;
 
             // Have we created the sim::SimChannel corresponding to channel ID?
             if (search == channelDataMap.end()) {
               // We haven't. Initialize the bookkeeping information for this channel.
               ChannelBookKeeping bookKeeping;
 
               // Add a new channel to the end of the list we'll write out after we've
               // processed this event.
               bookKeeping.channelIndex = channels->size();
               channels->emplace_back(channel);
               channelIndex = bookKeeping.channelIndex;
 
               // Initialize a vector with the index of the step that created this channel.
               bookKeeping.stepList.push_back(edIndex);
 
               // Save the bookkeeping information for this channel.
               channelDataMap[channel] = bookKeeping;
             }
             else {
               // We've created this SimChannel for a previous energy deposit. Get its
               // address.
 
               auto& bookKeeping = search->second;
               channelIndex = bookKeeping.channelIndex;
 
               // Has this step contributed to this channel before?
               auto& stepList = bookKeeping.stepList;
               if (!std::binary_search(stepList.begin(), stepList.end(), edIndex)) {
                 // No, so add this step's index to the list.
                 stepList.push_back(edIndex);
               }
             }
 
             sim::SimChannel* channelPtr = &(channels->at(channelIndex));
 
             // Add the electron clusters and energy to the
             // sim::SimChannel
             channelPtr->AddIonizationElectrons(energyDeposit.TrackID(),
                                                tdc,
                                                fnElDiff[k],
                                                data(xyz),
                                                fnEnDiff[k],
                                                energyDeposit.OrigTrackID());
             if (fStoreDriftedElectronClusters)
               SimDriftedElectronClusterCollection->emplace_back(
                 fnElDiff[k],
                 TDiff + simTime,                      // timing
                 geo::Point_t{mp.X(), mp.Y(), mp.Z()}, // mean position of the deposited energy
                 geo::Point_t{fDriftClusterPos[0],
                              fDriftClusterPos[1],
                              fDriftClusterPos[2]}, // final position of the drifted cluster
                 geo::Point_t{
                   LDiffSig, TDiffSig, TDiffSig}, // Longitudinal (X) and transverse (Y,Z) diffusion
                 fnEnDiff[k],                     // deposited energy that originated this cluster
                 energyDeposit.TrackID());
           }
           catch (cet::exception& e) {
             mf::LogDebug("SimDriftElectrons")
               << "unable to drift electrons from point (" << xyz[0] << "," << xyz[1] << ","
               << xyz[2] << ") with exception " << e;
           } // end try to determine channel
         }   // end loop over clusters
       }     // end loop over planes
     }       // for each sim::SimEnergyDeposit
 
     // Write the sim::SimChannel collection.
     event.put(std::move(channels));
     if (fStoreDriftedElectronClusters) event.put(std::move(SimDriftedElectronClusterCollection));
   }

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }