gar::rosim::ElectronDriftStandardAlg Class Reference

#include <ElectronDriftStandardAlg.h>

Inheritance diagram for gar::rosim::ElectronDriftStandardAlg:

Public Member Functions
	ElectronDriftStandardAlg (CLHEP::HepRandomEngine &engine, fhicl::ParameterSet const &pset)
virtual	~ElectronDriftStandardAlg ()
void	DriftElectronsToReadout (gar::sdp::EnergyDeposit const &dep, gar::rosim::ElectronDriftInfo &driftInfo)
Public Member Functions inherited from gar::rosim::ElectronDriftAlg
	ElectronDriftAlg (CLHEP::HepRandomEngine &engine, fhicl::ParameterSet const &pset)
virtual	~ElectronDriftAlg ()

Private Attributes
int	fElectronsPerCluster
	Number of electrons to drift in a cluster. More...
size_t	fMinClusters
	Minimum number of clusters for diffusion integral. More...
gar::detinfo::ElecClock	fClock
	electronics clock More...
const gar::detinfo::DetectorClocks *	fTime
	electronics clock More...
const gar::geo::GeometryCore *	fGeo
	Geometry. More...

Additional Inherited Members
Protected Attributes inherited from gar::rosim::ElectronDriftAlg
double	fDriftVelocity
	electron drift velocity More...
double	fInverseVelocity
	stored for computational convenience More...
double	fLifetimeCorrection
	electron lifetime correction in negative ms More...
double	fLongitudinalDiffusion
	diffusion along the drift in microns/sqrt(cm) More...
double	fLongDiffConst
	stored for computational convenience in sqrt(cm) More...
double	fTransverseDiffusion
	diffusion transverse to the drift in microns/sqrt(cm) More...
double	fTransDiffConst
	stored for computational convenience in sqrt(cm) More...
double	fFanoFactor
	Fano factor. More...
CLHEP::HepRandomEngine &	fEngine
	random number engine More...

Detailed Description

Definition at line 27 of file ElectronDriftStandardAlg.h.

Constructor & Destructor Documentation

gar::rosim::ElectronDriftStandardAlg::ElectronDriftStandardAlg	(	CLHEP::HepRandomEngine &	engine,
		fhicl::ParameterSet const &	pset
	)

Definition at line 21 of file ElectronDriftStandardAlg.cxx.

    : ElectronDriftAlg(engine, pset)
    {
      fElectronsPerCluster = pset.get<int>("ElectronsPerCluster");
      fMinClusters         = pset.get<size_t>("MinClusters");

      // get service providers
      fGeo   = gar::providerFrom<geo::GeometryGAr>();
      fTime  = gar::providerFrom<detinfo::DetectorClocksServiceGAr>();
      fClock = fTime->TPCClock();
      
    }

gar::rosim::ElectronDriftStandardAlg::~ElectronDriftStandardAlg ( )

virtual

Definition at line 36 of file ElectronDriftStandardAlg.cxx.

    {
    }

Member Function Documentation

void gar::rosim::ElectronDriftStandardAlg::DriftElectronsToReadout ( gar::sdp::EnergyDeposit const &  dep, gar::rosim::ElectronDriftInfo &  driftInfo  )

virtual

Implements gar::rosim::ElectronDriftAlg.

Definition at line 41 of file ElectronDriftStandardAlg.cxx.

    {
      // Reset the Ionization and Scintillation calculator for this step
      gar::rosim::IonizationAndScintillation::Instance()->Reset(&dep);

      // figure out how many electrons were ionized in the step
      // if none, just return the empty vector
      const int electrons = gar::rosim::IonizationAndScintillation::Instance()->NumberIonizationElectrons();

      if (electrons <= 0) return;

      // We need a random number thrower for the diffusion, etc
      CLHEP::RandGauss GaussRand(fEngine);
      
      double g4time = dep.Time();
      
      // the XYZ position of the midpoint has to be drifted to the readout,
      // use the diffusion coefficients to decide where the electrons end up
      float xyz[3] = {dep.X(),
                      dep.Y(),
                      dep.Z()};

      MF_LOG_DEBUG("ElectronDriftStandardAlg::DriftElectronsToReadout") << "energy deposition: " 
        << dep.X() << " " << dep.Y() << " " << dep.Z() << std::endl;

      // The geometry has x = TPCXCent() at the cathode plane. Compute the drift time for a two-drift-volume
      // TPC.  If we only have one drift volume, need to get that information here.

      double driftD       = std::abs(std::abs(xyz[0] - fGeo->TPCXCent()) - fGeo->TPCLength()/2.0);  // assume cathode is at x=TPXCent
      if (fGeo->TPCNumDriftVols() == 1)
        {
          driftD = std::max(0.0, fGeo->TPCLength()/2.0 - (xyz[0] - fGeo->TPCXCent()));
        }
      double driftT       = driftD * fInverseVelocity;  // in cm
      double sqrtDriftD   = std::sqrt(driftD);
      double lifetimeCorr = std::exp(driftT / fLifetimeCorrection);
      
      // how many electrons do we expect to make it to the readout?
      float  nElectrons = electrons * lifetimeCorr;
      size_t nClusters  = (size_t)std::ceil(nElectrons / fElectronsPerCluster);
      nClusters = std::min( (size_t) std::ceil(nElectrons),std::max(nClusters,fMinClusters));
      int ourelectronspercluster = nearbyint(nElectrons/nClusters);

      // drift them in sets.  The X(Y)(Z)Diff vectors contain the additional
      // distance to add to the step midpoint to account for diffusion.
      std::vector<double> XDiff(nClusters, 0.);
      std::vector<double> YDiff(nClusters, 0.);
      std::vector<double> ZDiff(nClusters, 0.);
      std::vector<double> TDiff(nClusters, 0.);
      std::vector<int   > nElec(nClusters, ourelectronspercluster);
      
      // the last cluster may have fewer electrons than the configured amount
      nElec.back() = nearbyint(nElectrons - (nClusters - 1) * ourelectronspercluster);
     
      double longDiffSigma = sqrtDriftD * fLongDiffConst;
      double transDiffSigma = sqrtDriftD * fTransDiffConst;

      GaussRand.fireArray(nClusters, &XDiff[0], 0., longDiffSigma);
      GaussRand.fireArray(nClusters, &YDiff[0], 0., transDiffSigma);
      GaussRand.fireArray(nClusters, &ZDiff[0], 0., transDiffSigma);
      
      // set the times and the positions of each cluster
      for(size_t c = 0; c < nClusters; ++c){
        TDiff[c]  = g4time + driftT + XDiff[c] * fInverseVelocity;
        XDiff[c]  = xyz[0];
        YDiff[c] += xyz[1];
        ZDiff[c] += xyz[2];

          MF_LOG_DEBUG("ElectronDriftStandardAlg::DriftElectronsToReadout")
        << "g4 time: "
        << g4time
        << " drift time "
        << driftT
        << " diffusion  x:"
        << XDiff[c]
        << " y "
        << YDiff[c]
        << " z "
        << ZDiff[c]
        << " t "
        << TDiff[c]
        << " tick period "
        << fTime->TPCClock().TickPeriod();

      }
      
      // reset the ElectronDriftInfo object with this information
      driftInfo.Reset(XDiff, YDiff, ZDiff, TDiff, nElec);
      
      return;
    }

Member Data Documentation

gar::detinfo::ElecClock gar::rosim::ElectronDriftStandardAlg::fClock

private

electronics clock

Definition at line 42 of file ElectronDriftStandardAlg.h.

int gar::rosim::ElectronDriftStandardAlg::fElectronsPerCluster

private

Number of electrons to drift in a cluster.

Definition at line 40 of file ElectronDriftStandardAlg.h.

const gar::geo::GeometryCore* gar::rosim::ElectronDriftStandardAlg::fGeo

private

Geometry.

Definition at line 44 of file ElectronDriftStandardAlg.h.

size_t gar::rosim::ElectronDriftStandardAlg::fMinClusters

private

Minimum number of clusters for diffusion integral.

Definition at line 41 of file ElectronDriftStandardAlg.h.

const gar::detinfo::DetectorClocks* gar::rosim::ElectronDriftStandardAlg::fTime

private

electronics clock

Definition at line 43 of file ElectronDriftStandardAlg.h.

---

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

• garsoft/ReadoutSimulation/ElectronDriftStandardAlg.h
• garsoft/ReadoutSimulation/ElectronDriftStandardAlg.cxx