Inheritance diagram for detsim::SimDriftElectrons:

Classes
struct	ChannelBookKeeping_t

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

virtual	~SimDriftElectrons ()

void	produce (art::Event &evt)

void	beginJob ()

void	endJob ()

void	reconfigure (fhicl::ParameterSet const &p)

template<typename PROD , BranchType B = InEvent>
ProductID	getProductID (std::string const &instanceName={}) const

template<typename PROD , BranchType B>
ProductID	getProductID (ModuleDescription const &moduleDescription, std::string const &instanceName) const

bool	modifiesEvent () const

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Private Types
typedef std::map< raw::ChannelID_t, ChannelBookKeeping_t >	ChannelMap_t

Private Attributes
art::InputTag	fSimModuleLabel

const detinfo::DetectorClocks *	fTimeService

std::unique_ptr< 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< std::vector< ChannelMap_t > >	fChannelMaps

size_t	fNCryostats

std::vector< size_t >	fNTPCs

std::vector< double >	fXDiff

std::vector< double >	fYDiff

std::vector< double >	fZDiff

std::vector< double >	fnElDiff

std::vector< double >	fnEnDiff

double	fDriftClusterPos [3]

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

::detinfo::ElecClock	fClock
	TPC electronics clock. More...

larg4::ISCalculationSeparate	fISAlg

Detailed Description

Definition at line 95 of file SimDriftElectrons_module.cc.

Member Typedef Documentation

typedef std::map<raw::ChannelID_t, ChannelBookKeeping_t> detsim::SimDriftElectrons::ChannelMap_t

private

Definition at line 144 of file SimDriftElectrons_module.cc.

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 34 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::EDProducer::Table = ProducerBase::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 43 of file EDProducer.h.

using art::EDProducer::WorkerType = WorkerT<EDProducer>

inherited

Definition at line 35 of file EDProducer.h.

Constructor & Destructor Documentation

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

explicit

Sets the margin for recovery of charge drifted off-plane.

Parameters

margin the extent of the margin on each frame coordinate [cm]

This method sets the margin for the recovery of off-plane ionization charge. See RecoverOffPlaneDeposit() for a description of that feature.

Definition at line 179 of file SimDriftElectrons_module.cc.

References art::EngineCreator::createEngine(), fStoreDriftedElectronClusters, and reconfigure().

   {
     this->reconfigure(pset);
 
     produces< std::vector<sim::SimChannel> >();
     if(fStoreDriftedElectronClusters)produces< std::vector<sim::SimDriftedElectronCluster> >();
     //produces< art::Assns<sim::SimChannel, sim::SimEnergyDeposit> >();
 
     // create a default random engine; obtain the random seed from
     // NuRandomService, unless overridden in configuration with key
     // "Seed"
     art::ServiceHandle<rndm::NuRandomService>()
       ->createEngine(*this, pset, "Seed");
 
     //fOffPlaneMargin = pset.get< double >("ChargeRecoveryMargin",0.0);
     // Protection against a silly value.
     //fOffPlaneMargin = std::max(fOffPlaneMargin,0.0);
   }

virtual detsim::SimDriftElectrons::~SimDriftElectrons ( )

inlinevirtual

Definition at line 100 of file SimDriftElectrons_module.cc.

References beginJob(), endJob(), produce(), and reconfigure().

100 {};

Member Function Documentation

void detsim::SimDriftElectrons::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 219 of file SimDriftElectrons_module.cc.

References e, sim::LArG4Parameters::ElectronClusterSize(), fClock, fElectronClusterSize, fElectronLifetime, fGeometry, fISAlg, fLDiff_const, fLifetimeCorr_const, fLongitudinalDiffusion, fMinNumberOfElCluster, fNCryostats, fNTPCs, fRandGauss, fRecipDriftVel, fTDiff_const, fTimeService, fTransverseDiffusion, art::RandomNumberGenerator::getEngine(), larg4::ISCalculationSeparate::Initialize(), LOG_DEBUG, sim::LArG4Parameters::LongitudinalDiffusion(), sim::LArG4Parameters::MinNumberOfElCluster(), n, geo::GeometryCore::Ncryostats(), geo::GeometryCore::NTPC(), art::EngineCreator::rng(), detinfo::DetectorClocks::TPCClock(), and sim::LArG4Parameters::TransverseDiffusion().

Referenced by ~SimDriftElectrons().

   {
     fTimeService = lar::providerFrom<detinfo::DetectorClocksService>();
     fClock = fTimeService->TPCClock();
 
     // Set up the gaussian generator.
     art::ServiceHandle<art::RandomNumberGenerator> rng;
     CLHEP::HepRandomEngine& engine = rng->getEngine();
     fRandGauss = std::unique_ptr<CLHEP::RandGauss>(new CLHEP::RandGauss(engine));
 
     // Define the physical constants we'll use.
 
     auto const * detprop = lar::providerFrom<detinfo::DetectorPropertiesService>();
     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> paramHandle;
     fElectronClusterSize   = paramHandle->ElectronClusterSize();
     fMinNumberOfElCluster  = paramHandle->MinNumberOfElCluster();
     fLongitudinalDiffusion = paramHandle->LongitudinalDiffusion(); // cm^2/ns units
     fTransverseDiffusion   = paramHandle->TransverseDiffusion(); // cm^2/ns units
 
     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(n);
 
 
     fISAlg.Initialize(lar::providerFrom<detinfo::LArPropertiesService>(),
                       detprop,
                       &(*paramHandle),
                       lar::providerFrom<spacecharge::SpaceChargeService>());
 
 
     return;
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDProducer::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

   {
     return current_context_.get();
   }

void detsim::SimDriftElectrons::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 276 of file SimDriftElectrons_module.cc.

Referenced by ~SimDriftElectrons().

277 {

278 }

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

template<typename PROD , BranchType B>

ProductID art::EDProducer::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

   {
     return ProducerBase::getProductID<PROD, B>(moduleDescription_,
                                                instanceName);
   }

template<typename PROD , BranchType B>

ProductID art::ProducerBase::getProductID	(	ModuleDescription const &	moduleDescription,
		std::string const &	instanceName
	)		const

inherited

Definition at line 56 of file ProducerBase.h.

References B, and art::ModuleDescription::moduleLabel().

Referenced by art::ProducerBase::modifiesEvent().

   {
     auto const& pd =
       get_ProductDescription<PROD>(B, md.moduleLabel(), instanceName);
     return pd.productID();
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::ProducerBase::modifiesEvent ( ) const

inlineinherited

Definition at line 40 of file ProducerBase.h.

References art::ProducerBase::getProductID().

     {
       return true;
     }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

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

virtual

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 281 of file SimDriftElectrons_module.cc.

References sim::SimChannel::AddIonizationElectrons(), larg4::ISCalculationSeparate::CalculateIonizationAndScintillation(), detsim::SimDriftElectrons::ChannelBookKeeping_t::channelIndex, DEFINE_ART_MODULE, geo::TPCGeo::DriftDirection(), e, energy, fChannelMaps, fClock, fDriftClusterPos, fElectronClusterSize, fGeometry, fISAlg, fLDiff_const, fLifetimeCorr_const, fMinNumberOfElCluster, fNCryostats, fnElDiff, fnEnDiff, fNTPCs, fRandGauss, fRecipDriftVel, fSimModuleLabel, fStoreDriftedElectronClusters, fTDiff_const, fTimeService, fXDiff, fYDiff, fZDiff, detinfo::DetectorClocks::G4ToElecTime(), art::DataViewImpl::getByLabel(), geo::kNegX, geo::kPosX, LOG_DEBUG, geo::GeometryCore::NearestChannel(), geo::TPCGeo::Nplanes(), larg4::ISCalculationSeparate::NumberIonizationElectrons(), geo::TPCGeo::Plane0Pitch(), geo::TPCGeo::PlaneLocation(), geo::TPCGeo::PlanePitch(), geo::GeometryCore::PositionToCryostat(), geo::GeometryCore::PositionToTPC(), larg4::ISCalculationSeparate::Reset(), detsim::SimDriftElectrons::ChannelBookKeeping_t::stepList, detinfo::ElecClock::Ticks(), geo::GeometryCore::TPC(), and xx.

Referenced by ~SimDriftElectrons().

   {
     // 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.resize(fNTPCs[cryo++]);
       for (auto& channelsMap: cryoData) channelsMap.clear(); // each, a map
     }
 
     // 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
     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();
         double const xyz[3] = { mp.X(), mp.Y(), mp.Z() };
 
         // 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;
         try {
           fGeometry->PositionToCryostat(xyz, cryostat);
         }
         catch(cet::exception &e){
           mf::LogWarning("SimDriftElectrons") << "step "// << energyDeposit << "\n"
                                               << "cannot be found in a cryostat\n"
                                               << e;
           continue;
         }
 
         unsigned int tpc = 0;
         try {
           fGeometry->PositionToTPC(xyz, tpc, cryostat);
         }
         catch(cet::exception &e){
           mf::LogWarning("SimDriftElectrons") << "step "// << energyDeposit << "\n"
                                               << "cannot be found in a TPC\n"
                                               << e;
           continue;
         }
 
         const geo::TPCGeo& tpcGeo = fGeometry->TPC(tpc, cryostat);
 
         // X drift distance - the drift direction can be either in
         // the positive or negative direction, so use std::abs
 
 
         if(tpcGeo.DriftDirection()==geo::kNegX && tpcGeo.PlaneLocation(0)[0]>xyz[0])
           continue;
         if(tpcGeo.DriftDirection()==geo::kPosX && tpcGeo.PlaneLocation(0)[0]<xyz[0])
           continue;
 
         // Center of plane is also returned in cm units
         double XDrift = std::abs(xyz[0] - tpcGeo.PlaneLocation(0)[0]);
         //std::cout<<tpcGeo.DriftDirection()<<std::endl;
         if (tpcGeo.DriftDirection() == geo::kNegX)
           XDrift = xyz[0] - tpcGeo.PlaneLocation(0)[0];
         else if (tpcGeo.DriftDirection() == geo::kPosX)
           XDrift = tpcGeo.PlaneLocation(0)[0] - xyz[0];
 
         if(XDrift < 0.) continue;
 
         // 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};
         auto const* SCE = lar::providerFrom<spacecharge::SpaceChargeService>();
         if (SCE->EnableSimSpatialSCE() == true)
           {
             posOffsets = SCE->GetPosOffsets(mp);
           }
         XDrift += -1.*posOffsets.X();
         
         // 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 (XDrift < 0.) XDrift = 0.;
 
         // Drift time in ns
         double TDrift = XDrift * fRecipDriftVel[0];
         if (tpcGeo.Nplanes() == 2){// special case for ArgoNeuT (plane 0 is the second wire plane)
           TDrift = ((XDrift - tpcGeo.PlanePitch(0,1)) * fRecipDriftVel[0]
                     + tpcGeo.PlanePitch(0,1) * fRecipDriftVel[1]);
         }
 
         fISAlg.Reset();
         fISAlg.CalculateIonizationAndScintillation(energyDeposit);
         //std::cout << "Got " << fISAlg.NumberIonizationElectrons() << "." << std::endl;
 
         const double lifetimecorrection = TMath::Exp(TDrift / fLifetimeCorr_const);
         const int    nIonizedElectrons  = fISAlg.NumberIonizationElectrons();
         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) {
           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;
         //std::cout << "After lifetime, " << nElectrons << " electrons." << std::endl;
 
         // 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.
         fXDiff.clear();
         fYDiff.clear();
         fZDiff.clear();
         fnElDiff.clear();
         fnEnDiff.clear();
         fXDiff.resize(nClus);
         fYDiff.resize(nClus);
         fZDiff.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.;
         }
 
         //std::cout << "Split into, " << nClus << " clusters." << std::endl;
         
         double const avegageYtransversePos
           = xyz[1] + posOffsets.Y();
         double const avegageZtransversePos
           = xyz[2] + posOffsets.Z();
 
         // Smear drift times by x position and drift time
         if (LDiffSig > 0.0)
           fRandGauss->fireArray( nClus, &fXDiff[0], 0., LDiffSig);
         else
           fXDiff.assign(nClus, 0.0);
 
         if (TDiffSig > 0.0) {
           // Smear the Y,Z position by the transverse diffusion
           fRandGauss->fireArray( nClus, &fYDiff[0], avegageYtransversePos, TDiffSig);
           fRandGauss->fireArray( nClus, &fZDiff[0], avegageZtransversePos, TDiffSig);
         }
         else {
           fYDiff.assign(nClus, avegageYtransversePos);
           fZDiff.assign(nClus, avegageZtransversePos);
         }
 
         //std::cout << "Smeared the " << nClus << " clusters." << std::endl;
         
         // make a collection of electrons for each plane
         for(size_t p = 0; p < tpcGeo.Nplanes(); ++p){
         
           //std::cout << "Doing plane " << p << std::endl;
 
           //geo::PlaneGeo const& plane = tpcGeo.Plane(p); // unused
 
           double Plane0Pitch = tpcGeo.Plane0Pitch(p);
 
           // "-" sign is because Plane0Pitch output is positive. Andrzej
           fDriftClusterPos[0] = tpcGeo.PlaneLocation(0)[0] - Plane0Pitch;
 
           // Drift nClus electron clusters to the induction plane
           for(int k = 0; k < nClus; ++k){
 
             //std::cout << "\tCluster " << k << " diffs are "
             //        << fXDiff[k] << " " << fYDiff[k] << " " << fZDiff[k]
            //         << std::endl;
 
             // Correct drift time for longitudinal diffusion and plane
             double TDiff = TDrift + fXDiff[k] * fRecipDriftVel[0];
             // Take into account different Efields between planes
             // Also take into account special case for ArgoNeuT where Nplanes = 2.
             for (size_t ip = 0; ip<p; ++ip){
               TDiff += tpcGeo.PlanePitch(ip,ip+1) * fRecipDriftVel[tpcGeo.Nplanes()==3?ip+1:ip+2];
             }
             fDriftClusterPos[1] = fYDiff[k];
             fDriftClusterPos[2] = fZDiff[k];
 
 
             // grab the nearest channel to the fDriftClusterPos position
             try{
               /*
               if (fOffPlaneMargin != 0) {
                 // get the effective position where to consider the charge landed;
                 //
                 // Some optimisations are possible; in particular, this method
                 // could be extended to inform us if the point was too far.
                 // Currently, if that is the case the code will proceed, find the
                 // point is off plane, emit a warning and skip the deposition.
                 //
                 auto const landingPos
                   = RecoverOffPlaneDeposit({ fDriftClusterPos[0], fDriftClusterPos[1], fDriftClusterPos[2] }, plane);
                 fDriftClusterPos[0] = landingPos.X();
                 fDriftClusterPos[1] = landingPos.Y();
                 fDriftClusterPos[2] = landingPos.Z();
 
               } // if charge lands off plane
               */
               raw::ChannelID_t channel = fGeometry->NearestChannel(fDriftClusterPos, p, tpc, cryostat);
 
               //std::cout << "\tgot channel " << channel << " for cluster " << k << std::endl;
 
               // Add potential decay/capture/etc delay effect, simTime.
               auto const simTime = energyDeposit.Time();
               unsigned int tdc = fClock.Ticks(fTimeService->G4ToElecTime(TDiff + simTime));
 
               // Find whether we already have this channel in our map.
               ChannelMap_t& channelDataMap = fChannelMaps[cryostat][tpc];
               auto search = channelDataMap.find(channel);
         
               // We will find (or create) the pointer to a
               // sim::SimChannel.
               //sim::SimChannel* channelPtr = NULL;
               size_t channelIndex=0;
 
               // Have we created the sim::SimChannel corresponding to
               // channel ID?
               if (search == channelDataMap.end())
                 {
                   //std::cout << "\tHaven't done this channel before." << std::endl;
 
                   // We haven't. Initialize the bookkeeping information
                   // for this channel.
                   ChannelBookKeeping_t 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;
 
                   // Save the pointer to the newly-created
                   // sim::SimChannel.
                   //channelPtr = &(channels->back());
                   //bookKeeping.channelPtr = channelPtr;
                 
                   // 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.
 
                 //std::cout << "\tHave seen this channel before." << std::endl;
 
                 auto& bookKeeping = search->second;
                 channelIndex = bookKeeping.channelIndex;
                 //channelPtr = bookKeeping.channelPtr;
                 
                 // Has this step contributed to this channel before?
                 auto& stepList = bookKeeping.stepList;
                 auto stepSearch = std::find(stepList.begin(), stepList.end(), edIndex );
                 if ( stepSearch == stepList.end() ) {
                   // No, so add this step's index to the list.
                   stepList.push_back( edIndex );
                 }
               }
               sim::SimChannel* channelPtr = &(channels->at(channelIndex));
 
               //std::cout << "\tAdding electrons to SimChannel" << std::endl;
               //std::cout << "\t\t"
               //        << energyDeposit.TrackID() << " " << tdc
               //        << " " << xyz[0] << " " << xyz[1] << " " << xyz[2]
               //        << " " << fnEnDiff[k] << " " << fnElDiff[k]
               //        << std::endl;
 
               //if(!channelPtr) std::cout << "\tUmm...ptr is NULL?" << std::endl;
               //else std::cout << "\tChannel is " << channelPtr->Channel() << std::endl;
               // Add the electron clusters and energy to the
               // sim::SimChannel
               channelPtr->AddIonizationElectrons(energyDeposit.TrackID(),
                                                  tdc,
                                                  fnElDiff[k],
                                                  xyz,
                                                  fnEnDiff[k]);
 
               if(fStoreDriftedElectronClusters)
                 SimDriftedElectronClusterCollection->push_back(sim::SimDriftedElectronCluster(          
                                                                                               fnElDiff[k],
                                                                                               TDiff + simTime,          // timing
                                                                                               {mp.X(),mp.Y(),mp.Z()}, // mean position of the deposited energy
                                                                                               {fDriftClusterPos[0],fDriftClusterPos[1],fDriftClusterPos[2]}, // final position of the drifted cluster
                                                                                               {LDiffSig,TDiffSig,TDiffSig}, // Longitudinal (X) and transverse (Y,Z) diffusion
                                                                                               fnEnDiff[k], //deposited energy that originated this cluster
                                                                                               energyDeposit.TrackID()) );
 
               //std::cout << "\tAdded the electrons." << std::endl;
 
             }
             catch(cet::exception &e) {
               mf::LogWarning("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
     /*
     // Now that we've processed the information for all the
     // sim::SimEnergyDeposit objects into sim::SimChannel objects,
     // create the associations between them.
 
     // Define the container for the associations between the channels
     // and the energy deposits (steps). Note it's possible for an
     // energy deposit to be associated with more than one channel (if
     // its electrons drift to multiple wires), and a channel will
     // almost certainly have multiple energy deposits.
     std::unique_ptr< art::Assns<sim::SimEnergyDeposit, sim::SimChannel> >
       step2channel (new art::Assns<sim::SimEnergyDeposit, sim::SimChannel>);
 
     // For every element in the 3-D fChannelMaps array...
     for ( auto i = fChannelMaps.begin(); i != fChannelMaps.end(); ++i ) {
       for ( auto j = i->begin(); j != i->end(); ++j ) {
         for ( auto k = j->begin(); k != j->end(); ++k ) {
           const ChannelBookKeeping_t& bookKeeping = (*k).second;
           const size_t channelIndex = bookKeeping.channelIndex;
 
           // Create a one-to-one association between each channel and
           // each step that created it.
           for ( size_t m = 0; m < bookKeeping.stepList.size(); ++m)
             {
               const size_t edIndex = bookKeeping.stepList[m];
               // Props to me for figuring out the following two
               // statements. You have to look deeply in the
               // documentation for art::Ptr and util::Associations to
               // put this together.
               art::Ptr<sim::SimEnergyDeposit> energyDepositPtr( energyDepositHandle, edIndex );
               util::CreateAssn(*this, event, *channels, energyDepositPtr, *step2channel, channelIndex);
             }
         }
       }
     }
     */
     // Write the sim::SimChannel collection.
     event.put(std::move(channels));
     if (fStoreDriftedElectronClusters) event.put(std::move(SimDriftedElectronClusterCollection));
 
     // ... and its associations.
     //event.put(std::move(step2channel));
 
     return;
   }

void detsim::SimDriftElectrons::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 207 of file SimDriftElectrons_module.cc.

References fSimModuleLabel, fStoreDriftedElectronClusters, fhicl::ParameterSet::get(), and label.

Referenced by SimDriftElectrons(), and ~SimDriftElectrons().

   {
     std::string label= p.get< std::string >("SimulationLabel");
     fSimModuleLabel = art::InputTag(label);
 
     fStoreDriftedElectronClusters = p.get< bool >("StoreDriftedElectronClusters", false);
 
 
     return;
   }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }