Garfield::MediumMagboltz Class Reference

#include <MediumMagboltz.hh>

Inheritance diagram for Garfield::MediumMagboltz:

Public Member Functions
	MediumMagboltz ()
	Default constructor.
	MediumMagboltz (const std::string &gas1, const double f1=1., const std::string &gas2="", const double f2=0., const std::string &gas3="", const double f3=0., const std::string &gas4="", const double f4=0., const std::string &gas5="", const double f5=0., const std::string &gas6="", const double f6=0.)
	Constructor.
virtual	~MediumMagboltz ()
	Destructor.
bool	SetMaxElectronEnergy (const double e)
double	GetMaxElectronEnergy () const
	Get the highest electron energy in the table of scattering rates.
bool	SetMaxPhotonEnergy (const double e)
double	GetMaxPhotonEnergy () const
	Get the highest photon energy in the table of scattering rates.
void	EnableAnisotropicScattering (const bool on=true)
	Switch on/off anisotropic scattering (enabled by default)
void	SetSplittingFunctionOpalBeaty ()
	Sample the secondary electron energy according to the Opal-Beaty model.
void	SetSplittingFunctionGreenSawada ()
	Sample the secondary electron energy according to the Green-Sawada model.
void	SetSplittingFunctionFlat ()
	Sample the secondary electron energy from a flat distribution.
void	EnableDeexcitation ()
	Switch on (microscopic) de-excitation handling.
void	DisableDeexcitation ()
	Switch off (microscopic) de-excitation handling.
void	EnableRadiationTrapping ()
	Switch on discrete photoabsorption levels.
void	DisableRadiationTrapping ()
	Switch off discrete photoabsorption levels.
bool	EnablePenningTransfer () override
bool	EnablePenningTransfer (const double r, const double lambda) override
bool	EnablePenningTransfer (const double r, const double lambda, std::string gasname) override
void	DisablePenningTransfer () override
	Switch the simulation of Penning transfers off globally.
bool	DisablePenningTransfer (std::string gasname) override
	Switch the simulation of Penning transfers off for a given component.
void	EnableCrossSectionOutput (const bool on=true)
	Write the gas cross-section table to a file during the initialisation.
void	SetExcitationScaling (const double r, std::string gasname)
	Multiply all excitation cross-sections by a uniform scaling factor.
bool	Initialise (const bool verbose=false)
void	PrintGas () override
	Print information about the present gas mixture and available data.
double	GetElectronNullCollisionRate (const int band) override
	Get the overall null-collision rate [ns-1].
double	GetElectronCollisionRate (const double e, const int band) override
	Get the (real) collision rate [ns-1] at a given electron energy e [eV].
double	GetElectronCollisionRate (const double e, const unsigned int level, const int band)
	Get the collision rate [ns-1] for a specific level.
bool	ElectronCollision (const double e, int &type, int &level, double &e1, double &dx, double &dy, double &dz, std::vector< std::pair< Particle, double > > &secondaries, int &ndxc, int &band) override
	Sample the collision type.
void	ComputeDeexcitation (int iLevel, int &fLevel)
unsigned int	GetNumberOfDeexcitationProducts () const override
bool	GetDeexcitationProduct (const unsigned int i, double &t, double &s, int &type, double &energy) const override
double	GetPhotonCollisionRate (const double e) override
bool	GetPhotonCollision (const double e, int &type, int &level, double &e1, double &ctheta, int &nsec, double &esec) override
void	ResetCollisionCounters ()
	Reset the collision counters.
unsigned int	GetNumberOfElectronCollisions () const
	Get the total number of electron collisions.
unsigned int	GetNumberOfElectronCollisions (unsigned int &nElastic, unsigned int &nIonising, unsigned int &nAttachment, unsigned int &nInelastic, unsigned int &nExcitation, unsigned int &nSuperelastic) const
	Get the number of collisions broken down by cross-section type.
unsigned int	GetNumberOfLevels ()
	Get the number of cross-section terms.
bool	GetLevel (const unsigned int i, int &ngas, int &type, std::string &descr, double &e)
	Get detailed information about a given cross-section term i.
bool	GetPenningTransfer (const unsigned int i, double &r, double &lambda)
	Get the Penning transfer probability and distance of a specific level.
unsigned int	GetNumberOfElectronCollisions (const unsigned int level) const
	Get the number of collisions for a specific cross-section term.
unsigned int	GetNumberOfPenningTransfers () const
	Get the number of Penning transfers that occured since the last reset.
unsigned int	GetNumberOfPhotonCollisions () const
	Get the total number of photon collisions.
unsigned int	GetNumberOfPhotonCollisions (unsigned int &nElastic, unsigned int &nIonising, unsigned int &nInelastic) const
	Get number of photon collisions by collision type.
void	EnableThermalMotion (const bool on=true)
void	EnableAutoEnergyLimit (const bool on=true)
void	RunMagboltz (const double e, const double b, const double btheta, const int ncoll, bool verbose, double &vx, double &vy, double &vz, double &dl, double &dt, double &alpha, double &eta, double &lor, double &vxerr, double &vyerr, double &vzerr, double &dlerr, double &dterr, double &alphaerr, double &etaerr, double &lorerr, double &alphatof, std::array< double, 6 > &difftens)
void	GenerateGasTable (const int numCollisions=10, const bool verbose=true)
void	PlotElectronCrossSections ()
Public Member Functions inherited from Garfield::MediumGas
	MediumGas ()
	Constructor.
virtual	~MediumGas ()
	Destructor.
bool	SetComposition (const std::string &gas1, const double f1=1., const std::string &gas2="", const double f2=0., const std::string &gas3="", const double f3=0., const std::string &gas4="", const double f4=0., const std::string &gas5="", const double f5=0., const std::string &gas6="", const double f6=0.)
	Set the gas mixture.
void	GetComposition (std::string &gas1, double &f1, std::string &gas2, double &f2, std::string &gas3, double &f3, std::string &gas4, double &f4, std::string &gas5, double &f5, std::string &gas6, double &f6) const
	Retrieve the gas mixture.
bool	LoadGasFile (const std::string &filename, const bool quiet=false)
	Read table of gas properties (transport parameters) from file.
bool	WriteGasFile (const std::string &filename)
	Save the present table of gas properties (transport parameters) to a file.
bool	MergeGasFile (const std::string &filename, const bool replaceOld)
	Read table of gas properties from and merge with the existing dataset.
bool	GetPenningTransfer (const std::string &gasname, double &r, double &lambda)
bool	LoadIonMobility (const std::string &filename, const bool quiet=false)
	Read a table of (positive) ion mobilities vs. electric field from file.
bool	LoadNegativeIonMobility (const std::string &filename, const bool quiet=false)
	Read a table of negative ion mobilities vs. electric field from file.
bool	AdjustTownsendCoefficient ()
size_t	GetNumberOfIonisationLevels () const
	Return the number of ionisation levels in the table.
size_t	GetNumberOfExcitationLevels () const
	Return the number of excitation levels in the table.
void	GetIonisationLevel (const size_t level, std::string &label, double &energy) const
	Return the identifier and threshold of an ionisation level.
void	GetExcitationLevel (const size_t level, std::string &label, double &energy) const
	Return the identifier and energy of an excitation level.
bool	GetElectronIonisationRate (const size_t level, const size_t ie, const size_t ib, const size_t ia, double &f) const
	Get an entry in the table of ionisation rates.
bool	GetElectronExcitationRate (const size_t level, const size_t ie, const size_t ib, const size_t ia, double &f) const
	Get an entry in the table of excitation rates.
bool	IsGas () const override
	Is this medium a gas?
void	GetComponent (const unsigned int i, std::string &label, double &f) override
	Get the name and fraction of a given component.
void	SetAtomicNumber (const double z) override
	Set the effective atomic number.
double	GetAtomicNumber () const override
	Get the effective atomic number.
void	SetAtomicWeight (const double a) override
	Set the effective atomic weight.
double	GetAtomicWeight () const override
	Get the effective atomic weight.
void	SetNumberDensity (const double n) override
	Set the number density [cm-3].
double	GetNumberDensity () const override
	Get the number density [cm-3].
void	SetMassDensity (const double rho) override
	Set the mass density [g/cm3].
double	GetMassDensity () const override
	Get the mass density [g/cm3].
void	ResetTables () override
	Reset all tables of transport parameters.
void	SetExtrapolationMethodExcitationRates (const std::string &low, const std::string &high)
void	SetExtrapolationMethodIonisationRates (const std::string &low, const std::string &high)
void	SetInterpolationMethodExcitationRates (const unsigned int intrp)
void	SetInterpolationMethodIonisationRates (const unsigned int intrp)
double	ScaleElectricField (const double e) const override
double	UnScaleElectricField (const double e) const override
double	ScaleDiffusion (const double d) const override
double	ScaleDiffusionTensor (const double d) const override
double	ScaleTownsend (const double alpha) const override
double	ScaleAttachment (const double eta) const override
double	ScaleLorentzAngle (const double lor) const override
bool	GetPhotoAbsorptionCrossSection (const double e, double &sigma, const unsigned int i) override
Public Member Functions inherited from Garfield::Medium
	Medium ()
	Constructor.
virtual	~Medium ()
	Destructor.
int	GetId () const
	Return the id number of the class instance.
const std::string &	GetName () const
	Get the medium name/identifier.
virtual bool	IsSemiconductor () const
	Is this medium a semiconductor?
virtual bool	IsConductor () const
	Is this medium a conductor?
void	SetTemperature (const double t)
	Set the temperature [K].
double	GetTemperature () const
	Get the temperature [K].
void	SetPressure (const double p)
double	GetPressure () const
void	SetDielectricConstant (const double eps)
	Set the relative static dielectric constant.
double	GetDielectricConstant () const
	Get the relative static dielectric constant.
unsigned int	GetNumberOfComponents () const
	Get number of components of the medium.
virtual void	EnableDrift (const bool on=true)
	Switch electron/ion/hole transport on/off.
virtual void	EnablePrimaryIonisation (const bool on=true)
	Make the medium ionisable or non-ionisable.
bool	IsDriftable () const
	Is charge carrier transport enabled in this medium?
bool	IsMicroscopic () const
	Does the medium have electron scattering rates?
bool	IsIonisable () const
	Is charge deposition by charged particles/photon enabled in this medium?
void	SetW (const double w)
	Set the W value (average energy to produce an electron/ion or e/h pair).
double	GetW () const
	Get the W value.
void	SetFanoFactor (const double f)
	Set the Fano factor.
double	GetFanoFactor () const
	Get the Fano factor.
void	PlotVelocity (const std::string &carriers, TPad *pad)
	Plot the drift velocity as function of the electric field.
void	PlotDiffusion (const std::string &carriers, TPad *pad)
	Plot the diffusion coefficients as function of the electric field.
void	PlotTownsend (const std::string &carriers, TPad *pad)
	Plot the Townsend coefficient(s) as function of the electric field.
void	PlotAttachment (const std::string &carriers, TPad *pad)
	Plot the attachment coefficient(s) as function of the electric field.
void	PlotAlphaEta (const std::string &carriers, TPad *pad)
	Plot Townsend and attachment coefficients.
virtual bool	ElectronVelocity (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &vx, double &vy, double &vz)
	Drift velocity [cm / ns].
virtual bool	ElectronDiffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &dl, double &dt)
	Longitudinal and transverse diffusion coefficients [cm1/2].
virtual bool	ElectronDiffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double cov[3][3])
virtual bool	ElectronTownsend (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &alpha)
	Ionisation coefficient [cm-1].
virtual bool	ElectronAttachment (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &eta)
	Attachment coefficient [cm-1].
virtual bool	ElectronLorentzAngle (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &lor)
	Lorentz angle.
virtual double	ElectronMobility ()
	Low-field mobility [cm2 V-1 ns-1].
virtual double	GetElectronEnergy (const double px, const double py, const double pz, double &vx, double &vy, double &vz, const int band=0)
	Dispersion relation (energy vs. wave vector)
virtual void	GetElectronMomentum (const double e, double &px, double &py, double &pz, int &band)
virtual bool	HoleVelocity (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &vx, double &vy, double &vz)
	Drift velocity [cm / ns].
virtual bool	HoleDiffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &dl, double &dt)
	Longitudinal and transverse diffusion coefficients [cm1/2].
virtual bool	HoleDiffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double cov[3][3])
	Diffusion tensor.
virtual bool	HoleTownsend (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &alpha)
	Ionisation coefficient [cm-1].
virtual bool	HoleAttachment (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &eta)
	Attachment coefficient [cm-1].
virtual double	HoleMobility ()
	Low-field mobility [cm2 V-1 ns-1].
virtual bool	IonVelocity (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &vx, double &vy, double &vz)
	Ion drift velocity [cm / ns].
virtual bool	IonDiffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &dl, double &dt)
	Longitudinal and transverse diffusion coefficients [cm1/2].
virtual bool	IonDissociation (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &diss)
	Dissociation coefficient.
virtual double	IonMobility ()
	Low-field ion mobility [cm2 V-1 ns-1].
virtual bool	NegativeIonVelocity (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, double &vx, double &vy, double &vz)
	Negative ion drift velocity [cm / ns].
virtual double	NegativeIonMobility ()
	Low-field negative ion mobility [cm2 V-1 ns-1].
void	SetFieldGrid (double emin, double emax, const size_t ne, bool logE, double bmin=0., double bmax=0., const size_t nb=1, double amin=HalfPi, double amax=HalfPi, const size_t na=1)
	Set the range of fields to be covered by the transport tables.
void	SetFieldGrid (const std::vector< double > &efields, const std::vector< double > &bfields, const std::vector< double > &angles)
	Set the fields and E-B angles to be used in the transport tables.
void	GetFieldGrid (std::vector< double > &efields, std::vector< double > &bfields, std::vector< double > &angles)
	Get the fields and E-B angles used in the transport tables.
bool	SetElectronVelocityE (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along E.
bool	GetElectronVelocityE (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along E.
bool	SetElectronVelocityExB (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along ExB.
bool	GetElectronVelocityExB (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along ExB.
bool	SetElectronVelocityB (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along Btrans.
bool	GetElectronVelocityB (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along Btrans.
bool	SetElectronLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dl)
	Set an entry in the table of longitudinal diffusion coefficients.
bool	GetElectronLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dl)
	Get an entry in the table of longitudinal diffusion coefficients.
bool	SetElectronTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dt)
	Set an entry in the table of transverse diffusion coefficients.
bool	GetElectronTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dt)
	Get an entry in the table of transverse diffusion coefficients.
bool	SetElectronTownsend (const size_t ie, const size_t ib, const size_t ia, const double alpha)
	Set an entry in the table of Townsend coefficients.
bool	GetElectronTownsend (const size_t ie, const size_t ib, const size_t ia, double &alpha)
	Get an entry in the table of Townsend coefficients.
bool	SetElectronAttachment (const size_t ie, const size_t ib, const size_t ia, const double eta)
	Set an entry in the table of attachment coefficients.
bool	GetElectronAttachment (const size_t ie, const size_t ib, const size_t ia, double &eta)
	Get an entry in the table of attachment coefficients.
bool	SetElectronLorentzAngle (const size_t ie, const size_t ib, const size_t ia, const double lor)
	Set an entry in the table of Lorentz angles.
bool	GetElectronLorentzAngle (const size_t ie, const size_t ib, const size_t ia, double &lor)
	Get an entry in the table of Lorentz angles.
bool	SetHoleVelocityE (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along E.
bool	GetHoleVelocityE (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along E.
bool	SetHoleVelocityExB (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along ExB.
bool	GetHoleVelocityExB (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along ExB.
bool	SetHoleVelocityB (const size_t ie, const size_t ib, const size_t ia, const double v)
	Set an entry in the table of drift speeds along Btrans.
bool	GetHoleVelocityB (const size_t ie, const size_t ib, const size_t ia, double &v)
	Get an entry in the table of drift speeds along Btrans.
bool	SetHoleLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dl)
	Set an entry in the table of longitudinal diffusion coefficients.
bool	GetHoleLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dl)
	Get an entry in the table of longitudinal diffusion coefficients.
bool	SetHoleTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dt)
	Set an entry in the table of transverse diffusion coefficients.
bool	GetHoleTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dt)
	Get an entry in the table of transverse diffusion coefficients.
bool	SetHoleTownsend (const size_t ie, const size_t ib, const size_t ia, const double alpha)
	Set an entry in the table of Townsend coefficients.
bool	GetHoleTownsend (const size_t ie, const size_t ib, const size_t ia, double &alpha)
	Get an entry in the table of Townsend coefficients.
bool	SetHoleAttachment (const size_t ie, const size_t ib, const size_t ia, const double eta)
	Set an entry in the table of attachment coefficients.
bool	GetHoleAttachment (const size_t ie, const size_t ib, const size_t ia, double &eta)
	Get an entry in the table of attachment coefficients.
bool	SetIonMobility (const std::vector< double > &fields, const std::vector< double > &mobilities, const bool negativeIons=false)
bool	SetIonMobility (const size_t ie, const size_t ib, const size_t ia, const double mu)
	Set an entry in the table of ion mobilities.
bool	GetIonMobility (const size_t ie, const size_t ib, const size_t ia, double &mu)
	Get an entry in the table of ion mobilities.
bool	SetIonLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dl)
	Set an entry in the table of longitudinal diffusion coefficients.
bool	GetIonLongitudinalDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dl)
	Get an entry in the table of longitudinal diffusion coefficients.
bool	SetIonTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, const double dt)
	Set an entry in the table of transverse diffusion coefficients.
bool	GetIonTransverseDiffusion (const size_t ie, const size_t ib, const size_t ia, double &dt)
	Get an entry in the table of transverse diffusion coefficients.
bool	SetIonDissociation (const size_t ie, const size_t ib, const size_t ia, const double diss)
	Set an entry in the table of dissociation coefficients.
bool	GetIonDissociation (const size_t ie, const size_t ib, const size_t ia, double &diss)
	Get an entry in the table of dissociation coefficients.
bool	SetNegativeIonMobility (const size_t ie, const size_t ib, const size_t ia, const double mu)
	Set an entry in the table of negative ion mobilities.
bool	GetNegativeIonMobility (const size_t ie, const size_t ib, const size_t ia, double &mu)
	Get an entry in the table of negative ion mobilities.
void	ResetElectronVelocity ()
void	ResetElectronDiffusion ()
void	ResetElectronTownsend ()
void	ResetElectronAttachment ()
void	ResetElectronLorentzAngle ()
void	ResetHoleVelocity ()
void	ResetHoleDiffusion ()
void	ResetHoleTownsend ()
void	ResetHoleAttachment ()
void	ResetIonMobility ()
void	ResetIonDiffusion ()
void	ResetIonDissociation ()
void	ResetNegativeIonMobility ()
void	SetExtrapolationMethodVelocity (const std::string &extrLow, const std::string &extrHigh)
void	SetExtrapolationMethodDiffusion (const std::string &extrLow, const std::string &extrHigh)
void	SetExtrapolationMethodTownsend (const std::string &extrLow, const std::string &extrHigh)
void	SetExtrapolationMethodAttachment (const std::string &extrLow, const std::string &extrHigh)
void	SetExtrapolationMethodIonMobility (const std::string &extrLow, const std::string &extrHigh)
void	SetExtrapolationMethodIonDissociation (const std::string &extrLow, const std::string &extrHigh)
void	SetInterpolationMethodVelocity (const unsigned int intrp)
	Set the degree of polynomial interpolation (usually 2).
void	SetInterpolationMethodDiffusion (const unsigned int intrp)
void	SetInterpolationMethodTownsend (const unsigned int intrp)
void	SetInterpolationMethodAttachment (const unsigned int intrp)
void	SetInterpolationMethodIonMobility (const unsigned int intrp)
void	SetInterpolationMethodIonDissociation (const unsigned int intrp)
virtual double	ScaleVelocity (const double v) const
virtual double	ScaleDissociation (const double diss) const
virtual bool	GetOpticalDataRange (double &emin, double &emax, const unsigned int i=0)
	Get the energy range [eV] of the available optical data.
virtual bool	GetDielectricFunction (const double e, double &eps1, double &eps2, const unsigned int i=0)
	Get the complex dielectric function at a given energy.
void	EnableDebugging ()
	Switch on/off debugging messages.
void	DisableDebugging ()

Static Public Member Functions
static int	GetGasNumberMagboltz (const std::string &input)
Static Public Member Functions inherited from Garfield::MediumGas
static void	PrintGases ()
	Print a list of all available gases.

Additional Inherited Members
Protected Member Functions inherited from Garfield::MediumGas
bool	LoadMobility (const std::string &filename, const bool quiet, const bool negative)
bool	ReadHeader (std::ifstream &gasfile, int &version, std::bitset< 20 > &gasok, bool &is3d, std::vector< double > &mixture, std::vector< double > &efields, std::vector< double > &bfields, std::vector< double > &angles, std::vector< ExcLevel > &excLevels, std::vector< IonLevel > &ionLevels)
void	ReadFooter (std::ifstream &gasfile, std::array< unsigned int, 13 > &extrapH, std::array< unsigned int, 13 > &extrapL, std::array< unsigned int, 13 > &interp, unsigned int &thrAlp, unsigned int &thrAtt, unsigned int &thrDis, double &ionDiffL, double &ionDiffT, double &pgas, double &tgas)
void	ReadRecord3D (std::ifstream &gasfile, double &ve, double &vb, double &vx, double &dl, double &dt, double &alpha, double &alpha0, double &eta, double &mu, double &lor, double &dis, std::array< double, 6 > &dif, std::vector< double > &rexc, std::vector< double > &rion)
void	ReadRecord1D (std::ifstream &gasfile, double &ve, double &vb, double &vx, double &dl, double &dt, double &alpha, double &alpha0, double &eta, double &mu, double &lor, double &dis, std::array< double, 6 > &dif, std::vector< double > &rexc, std::vector< double > &rion)
void	InsertE (const int ie, const int ne, const int nb, const int na)
void	InsertB (const int ib, const int ne, const int nb, const int na)
void	InsertA (const int ia, const int ne, const int nb, const int na)
void	ZeroRowE (const int ie, const int nb, const int na)
void	ZeroRowB (const int ib, const int ne, const int na)
void	ZeroRowA (const int ia, const int ne, const int nb)
bool	GetMixture (const std::vector< double > &mixture, const int version, std::vector< std::string > &gasnames, std::vector< double > &percentages) const
void	GetGasBits (std::bitset< 20 > &gasok) const
Protected Member Functions inherited from Garfield::Medium
bool	Velocity (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, const std::vector< std::vector< std::vector< double > > > &velE, const std::vector< std::vector< std::vector< double > > > &velB, const std::vector< std::vector< std::vector< double > > > &velX, const double q, double &vx, double &vy, double &vz) const
bool	Diffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, const std::vector< std::vector< std::vector< double > > > &difL, const std::vector< std::vector< std::vector< double > > > &difT, double &dl, double &dt) const
bool	Diffusion (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, const std::vector< std::vector< std::vector< std::vector< double > > > > &diff, double cov[3][3]) const
bool	Alpha (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, const std::vector< std::vector< std::vector< double > > > &tab, unsigned int intp, const unsigned int thr, const std::pair< unsigned int, unsigned int > &extr, double &alpha) const
double	GetAngle (const double ex, const double ey, const double ez, const double bx, const double by, const double bz, const double e, const double b) const
bool	Interpolate (const double e, const double b, const double a, const std::vector< std::vector< std::vector< double > > > &table, double &y, const unsigned int intp, const std::pair< unsigned int, unsigned int > &extr) const
double	Interpolate1D (const double e, const std::vector< double > &table, const std::vector< double > &fields, const unsigned int intpMeth, const std::pair< unsigned int, unsigned int > &extr) const
bool	SetEntry (const size_t i, const size_t j, const size_t k, const std::string &fcn, std::vector< std::vector< std::vector< double > > > &tab, const double val)
bool	GetEntry (const size_t i, const size_t j, const size_t k, const std::string &fcn, const std::vector< std::vector< std::vector< double > > > &tab, double &val) const
void	SetExtrapolationMethod (const std::string &low, const std::string &high, std::pair< unsigned int, unsigned int > &extr, const std::string &fcn)
bool	GetExtrapolationIndex (std::string str, unsigned int &nb) const
size_t	SetThreshold (const std::vector< std::vector< std::vector< double > > > &tab) const
void	Clone (std::vector< std::vector< std::vector< double > > > &tab, const std::vector< double > &efields, const std::vector< double > &bfields, const std::vector< double > &angles, const unsigned int intp, const std::pair< unsigned int, unsigned int > &extr, const double init, const std::string &label)
void	Clone (std::vector< std::vector< std::vector< std::vector< double > > > > &tab, const size_t n, const std::vector< double > &efields, const std::vector< double > &bfields, const std::vector< double > &angles, const unsigned int intp, const std::pair< unsigned int, unsigned int > &extr, const double init, const std::string &label)
void	Init (const size_t nE, const size_t nB, const size_t nA, std::vector< std::vector< std::vector< double > > > &tab, const double val)
void	Init (const size_t nE, const size_t nB, const size_t nA, const size_t nT, std::vector< std::vector< std::vector< std::vector< double > > > > &tab, const double val)
Static Protected Member Functions inherited from Garfield::MediumGas
static bool	GetGasInfo (const std::string &gasname, double &a, double &z, double &w, double &f)
static std::string	GetGasName (const int gasnumber, const int version)
static std::string	GetGasName (std::string input)
static int	GetGasNumberGasFile (const std::string &input)
static const std::vector< std::string >	GetAliases (const std::string &gas)
Static Protected Member Functions inherited from Garfield::Medium
static void	Langevin (const double ex, const double ey, const double ez, double bx, double by, double bz, const double mu, double &vx, double &vy, double &vz)
static void	Langevin (const double ex, const double ey, const double ez, double bx, double by, double bz, const double mu, const double muH, double &vx, double &vy, double &vz)
Protected Attributes inherited from Garfield::MediumGas
std::array< std::string, m_nMaxGases >	m_gas
std::array< double, m_nMaxGases >	m_fraction
std::array< double, m_nMaxGases >	m_atWeight
std::array< double, m_nMaxGases >	m_atNum
bool	m_usePenning = false
double	m_rPenningGlobal = 0.
double	m_lambdaPenningGlobal = 0.
std::array< double, m_nMaxGases >	m_rPenningGas
std::array< double, m_nMaxGases >	m_lambdaPenningGas
double	m_pressureTable
double	m_temperatureTable
std::vector< std::vector< std::vector< double > > >	m_eAlp0
std::vector< std::vector< std::vector< std::vector< double > > > >	m_excRates
std::vector< std::vector< std::vector< std::vector< double > > > >	m_ionRates
std::vector< ExcLevel >	m_excLevels
std::vector< IonLevel >	m_ionLevels
std::pair< unsigned int, unsigned int >	m_extrExc = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrIon = {0, 1}
unsigned int	m_intpExc = 2
unsigned int	m_intpIon = 2
Protected Attributes inherited from Garfield::Medium
std::string	m_className = "Medium"
int	m_id
unsigned int	m_nComponents = 1
std::string	m_name = ""
double	m_temperature = 293.15
double	m_pressure = 760.
double	m_epsilon = 1.
double	m_z = 1.
double	m_a = 0.
double	m_density = 0.
double	m_w = 0.
double	m_fano = 0.
bool	m_driftable = false
bool	m_microscopic = false
bool	m_ionisable = false
bool	m_isChanged = true
bool	m_debug = false
bool	m_tab2d = false
std::vector< double >	m_eFields
std::vector< double >	m_bFields
std::vector< double >	m_bAngles
std::vector< std::vector< std::vector< double > > >	m_eVelE
std::vector< std::vector< std::vector< double > > >	m_eVelX
std::vector< std::vector< std::vector< double > > >	m_eVelB
std::vector< std::vector< std::vector< double > > >	m_eDifL
std::vector< std::vector< std::vector< double > > >	m_eDifT
std::vector< std::vector< std::vector< double > > >	m_eAlp
std::vector< std::vector< std::vector< double > > >	m_eAtt
std::vector< std::vector< std::vector< double > > >	m_eLor
std::vector< std::vector< std::vector< std::vector< double > > > >	m_eDifM
std::vector< std::vector< std::vector< double > > >	m_hVelE
std::vector< std::vector< std::vector< double > > >	m_hVelX
std::vector< std::vector< std::vector< double > > >	m_hVelB
std::vector< std::vector< std::vector< double > > >	m_hDifL
std::vector< std::vector< std::vector< double > > >	m_hDifT
std::vector< std::vector< std::vector< double > > >	m_hAlp
std::vector< std::vector< std::vector< double > > >	m_hAtt
std::vector< std::vector< std::vector< std::vector< double > > > >	m_hDifM
std::vector< std::vector< std::vector< double > > >	m_iMob
std::vector< std::vector< std::vector< double > > >	m_iDifL
std::vector< std::vector< std::vector< double > > >	m_iDifT
std::vector< std::vector< std::vector< double > > >	m_iDis
std::vector< std::vector< std::vector< double > > >	m_nMob
unsigned int	m_eThrAlp = 0
unsigned int	m_eThrAtt = 0
unsigned int	m_hThrAlp = 0
unsigned int	m_hThrAtt = 0
unsigned int	m_iThrDis = 0
std::pair< unsigned int, unsigned int >	m_extrVel = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrDif = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrAlp = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrAtt = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrLor = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrMob = {0, 1}
std::pair< unsigned int, unsigned int >	m_extrDis = {0, 1}
unsigned int	m_intpVel = 2
unsigned int	m_intpDif = 2
unsigned int	m_intpAlp = 2
unsigned int	m_intpAtt = 2
unsigned int	m_intpLor = 2
unsigned int	m_intpMob = 2
unsigned int	m_intpDis = 2
Static Protected Attributes inherited from Garfield::MediumGas
static constexpr unsigned int	m_nMaxGases = 6
Static Protected Attributes inherited from Garfield::Medium
static int	m_idCounter = -1

Detailed Description

Interface to Magboltz (version 11).

• http://magboltz.web.cern.ch/magboltz/

Definition at line 15 of file MediumMagboltz.hh.

Constructor & Destructor Documentation

MediumMagboltz() [1/2]

Garfield::MediumMagboltz::MediumMagboltz

(

)

Default constructor.

Definition at line 79 of file MediumMagboltz.cc.

    : MediumGas(),
      m_eMax(40.),
      m_eStep(m_eMax / Magboltz::nEnergySteps),
      m_eStepInv(1. / m_eStep),
      m_eHigh(400.),
      m_eHighLog(log(m_eHigh)),
      m_lnStep(1.),
      m_eFinalGamma(20.),
      m_eStepGamma(m_eFinalGamma / nEnergyStepsGamma) {
  m_className = "MediumMagboltz";
 
  // Set physical constants in Magboltz common blocks.
  Magboltz::cnsts_.echarg = ElementaryCharge * 1.e-15;
  Magboltz::cnsts_.emass = ElectronMassGramme;
  Magboltz::cnsts_.amu = AtomicMassUnit;
  Magboltz::cnsts_.pir2 = BohrRadius * BohrRadius * Pi;
  Magboltz::inpt_.ary = RydbergEnergy;
 
  // Set parameters in Magboltz common blocks.
  Magboltz::inpt_.nGas = m_nComponents;
  Magboltz::inpt_.nStep = Magboltz::nEnergySteps;
  // Select the scattering model.
  Magboltz::inpt_.nAniso = 2;
  // Max. energy [eV]
  Magboltz::inpt_.efinal = m_eMax;
  // Energy step size [eV]
  Magboltz::inpt_.estep = m_eStep;
  // Temperature and pressure
  Magboltz::inpt_.akt = BoltzmannConstant * m_temperature;
  Magboltz::inpt_.tempc = m_temperature - ZeroCelsius;
  Magboltz::inpt_.torr = m_pressure;
  // Disable Penning transfer.
  Magboltz::inpt_.ipen = 0;
 
  m_description.assign(Magboltz::nMaxLevels,
                       std::string(Magboltz::nCharDescr, ' '));
 
  m_cfTot.assign(Magboltz::nEnergySteps, 0.);
  m_cfTotLog.assign(nEnergyStepsLog, 0.);
  m_cf.assign(Magboltz::nEnergySteps,
              std::vector<double>(Magboltz::nMaxLevels, 0.));
  m_cfLog.assign(nEnergyStepsLog,
                 std::vector<double>(Magboltz::nMaxLevels, 0.));
 
  m_isChanged = true;
 
  m_driftable = true;
  m_ionisable = true;
  m_microscopic = true;
 
  m_scaleExc.fill(1.);
}

Referenced by MediumMagboltz().

MediumMagboltz() [2/2]

Garfield::MediumMagboltz::MediumMagboltz	(	const std::string &	gas1,
		const double	f1 = 1.,
		const std::string &	gas2 = "",
		const double	f2 = 0.,
		const std::string &	gas3 = "",
		const double	f3 = 0.,
		const std::string &	gas4 = "",
		const double	f4 = 0.,
		const std::string &	gas5 = "",
		const double	f5 = 0.,
		const std::string &	gas6 = "",
		const double	f6 = 0. )

Constructor.

Definition at line 132 of file MediumMagboltz.cc.

    : MediumMagboltz() {
  SetComposition(gas1, f1, gas2, f2, gas3, f3, 
                 gas4, f4, gas5, f5, gas6, f6);
}

~MediumMagboltz()

virtual Garfield::MediumMagboltz::~MediumMagboltz ( )

inlinevirtual

Destructor.

Definition at line 27 of file MediumMagboltz.hh.

{}

Member Function Documentation

ComputeDeexcitation()

void Garfield::MediumMagboltz::ComputeDeexcitation	(	int	iLevel,
		int &	fLevel )

Definition at line 2403 of file MediumMagboltz.cc.

                                                                {
  if (!m_useDeexcitation) {
    std::cerr << m_className << "::ComputeDeexcitation: Not enabled.\n";
    return;
  }
 
  // Make sure that the tables are updated.
  if (!Update()) return;
 
  if (iLevel < 0 || iLevel >= (int)m_nTerms) {
    std::cerr << m_className << "::ComputeDeexcitation: Index out of range.\n";
    return;
  }
 
  iLevel = m_iDeexcitation[iLevel];
  if (iLevel < 0 || iLevel >= (int)m_deexcitations.size()) {
    std::cerr << m_className << "::ComputeDeexcitation:\n"
              << "    Level is not deexcitable.\n";
    return;
  }
 
  ComputeDeexcitationInternal(iLevel, fLevel);
  if (fLevel >= 0 && fLevel < (int)m_deexcitations.size()) {
    fLevel = m_deexcitations[fLevel].level;
  }
}

DisableDeexcitation()

void Garfield::MediumMagboltz::DisableDeexcitation ( )

inline

Switch off (microscopic) de-excitation handling.

Definition at line 57 of file MediumMagboltz.hh.

{ m_useDeexcitation = false; }

DisablePenningTransfer() [1/2]

void Garfield::MediumMagboltz::DisablePenningTransfer ( )

overridevirtual

Switch the simulation of Penning transfers off globally.

Reimplemented from Garfield::MediumGas.

Definition at line 335 of file MediumMagboltz.cc.

                                            {
 
  MediumGas::DisablePenningTransfer();
  m_rPenning.fill(0.);
  m_lambdaPenning.fill(0.);
 
  m_usePenning = false;
}

DisablePenningTransfer() [2/2]

bool Garfield::MediumMagboltz::DisablePenningTransfer ( std::string gasname )

overridevirtual

Switch the simulation of Penning transfers off for a given component.

Reimplemented from Garfield::MediumGas.

Definition at line 344 of file MediumMagboltz.cc.

                                                             {
 
  if (!MediumGas::DisablePenningTransfer(gasname)) return false;
  // Get the "standard" name of this gas.
  gasname = GetGasName(gasname);
  if (gasname.empty()) return false;
 
  // Look (again) for this gas in the present gas mixture.
  int iGas = -1;
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    if (m_gas[i] == gasname) {
      iGas = i;
      break;
    }
  }
 
  if (iGas < 0) return false;
 
  unsigned int nLevelsFound = 0;
  for (unsigned int i = 0; i < m_nTerms; ++i) {
    if (int(m_csType[i] / nCsTypes) == iGas) {
      m_rPenning[i] = 0.;
      m_lambdaPenning[i] = 0.;
    } else {
      if (m_csType[i] % nCsTypes == ElectronCollisionTypeExcitation &&
          m_rPenning[i] > Small) {
        ++nLevelsFound;
      }
    }
  }
 
  if (nLevelsFound == 0) {
    // There are no more excitation levels with r > 0.
    std::cout << m_className << "::DisablePenningTransfer:\n"
              << "    Penning transfer switched off for all excitations.\n";
    m_usePenning = false;
  }
  return true;
}

DisableRadiationTrapping()

void Garfield::MediumMagboltz::DisableRadiationTrapping ( )

inline

Switch off discrete photoabsorption levels.

Definition at line 61 of file MediumMagboltz.hh.

{ m_useRadTrap = false; }

ElectronCollision()

bool Garfield::MediumMagboltz::ElectronCollision ( const double e, int & type, int & level, double & e1, double & dx, double & dy, double & dz, std::vector< std::pair< Particle, double > > & secondaries, int & ndxc, int & band )

overridevirtual

Sample the collision type.

Reimplemented from Garfield::Medium.

Definition at line 589 of file MediumMagboltz.cc.

               {
  band = 0;
  ndxc = 0;
  if (e <= 0.) {
    std::cerr << m_className << "::ElectronCollision: Invalid energy.\n";
    return false;
  }
  // Check if the electron energy is within the currently set range.
  if (e > m_eMax) {
    std::cerr << m_className << "::ElectronCollision:\n    Requested energy ("
              << e << " eV) exceeds current energy range.\n"
              << "    Increasing energy range to " << 1.05 * e << " eV.\n";
    SetMaxElectronEnergy(1.05 * e);
  }
 
  // If necessary, update the collision rates table.
  if (!Update()) return false;
 
  double angCut = 1.;
  double angPar = 0.5;
 
  if (e < m_eHigh) {
    // Linear binning
    // Get the energy interval.
    const int iE = int(e * m_eStepInv);
 
    // Sample the scattering process.
    const double r = RndmUniform();
    level = 0;
    if (r > m_cf[iE][0]) {
      int iLow = 0;
      int iUp = m_nTerms - 1;
      while (iUp - iLow > 1) {
        int iMid = (iLow + iUp) >> 1;
        if (r < m_cf[iE][iMid]) {
          iUp = iMid;
        } else {
          iLow = iMid;
        }
      } 
      level = iUp;
    }
    // Get the angular distribution parameters.
    angCut = m_scatCut[iE][level];
    angPar = m_scatPar[iE][level];
  } else {
    // Logarithmic binning
    // Get the energy interval.
    const int iE = std::min(std::max(int(log(e / m_eHigh) / m_lnStep), 0),
                            nEnergyStepsLog - 1);
    // Sample the scattering process.
    const double r = RndmUniform();
    level = 0;
    if (r > m_cfLog[iE][0]) {
      int iLow = 0;
      int iUp = m_nTerms - 1;
      while (iUp - iLow > 1) {
        int iMid = (iLow + iUp) >> 1;
        if (r < m_cfLog[iE][iMid]) {
          iUp = iMid;
        } else {
          iLow = iMid;
        }
      }
      level = iUp;
    }
    // Get the angular distribution parameters.
    angCut = m_scatCutLog[iE][level];
    angPar = m_scatParLog[iE][level];
  }
 
  // Extract the collision type.
  type = m_csType[level] % nCsTypes;
  const int igas = int(m_csType[level] / nCsTypes);
  // Increase the collision counters.
  ++m_nCollisions[type];
  ++m_nCollisionsDetailed[level];
 
  // Get the energy loss for this process.
  double loss = m_energyLoss[level];
 
  if (type == ElectronCollisionTypeVirtual) return true;
 
  if (type == ElectronCollisionTypeIonisation) {
    // Sample the secondary electron energy according to
    // the Opal-Beaty-Peterson parameterisation.
    double esec = 0.;
    if (e < loss) loss = e - 0.0001;
    if (m_useOpalBeaty) {
      // Get the splitting parameter.
      const double w = m_wOpalBeaty[level];
      esec = w * tan(RndmUniform() * atan(0.5 * (e - loss) / w));
      // Rescaling (SST)
      // esec = w * pow(esec / w, 0.9524);
    } else if (m_useGreenSawada) {
      const double gs = m_parGreenSawada[igas][0];
      const double gb = m_parGreenSawada[igas][1];
      const double w = gs * e / (e + gb);
      const double ts = m_parGreenSawada[igas][2];
      const double ta = m_parGreenSawada[igas][3];
      const double tb = m_parGreenSawada[igas][4];
      const double esec0 = ts - ta / (e + tb);
      const double r = RndmUniform();
      esec = esec0 +
             w * tan((r - 1.) * atan(esec0 / w) +
                     r * atan((0.5 * (e - loss) - esec0) / w));
    } else {
      esec = RndmUniform() * (e - loss);
    }
    if (esec <= 0) esec = Small;
    loss += esec;
    // Add the secondary electron.
    secondaries.emplace_back(std::make_pair(Particle::Electron, esec));
    // Add the ion.
    secondaries.emplace_back(std::make_pair(Particle::Ion, 0.));
    bool fluorescence = false;
    if (m_yFluorescence[level] > Small) {
      if (RndmUniform() < m_yFluorescence[level]) fluorescence = true;
    } 
    // Add Auger and photo electrons (if any).
    if (fluorescence) {
      if (m_nAuger2[level] > 0) {
        const double eav = m_eAuger2[level] / m_nAuger2[level];
        for (unsigned int i = 0; i < m_nAuger2[level]; ++i) {
          secondaries.emplace_back(std::make_pair(Particle::Electron, eav));
        }
      }
      if (m_nFluorescence[level] > 0) {
        const double eav = m_eFluorescence[level] / m_nFluorescence[level];
        for (unsigned int i = 0; i < m_nFluorescence[level]; ++i) {
          secondaries.emplace_back(std::make_pair(Particle::Electron, eav));
        }
      }
    } else if (m_nAuger1[level] > 0) {
      const double eav = m_eAuger1[level] / m_nAuger1[level];
      for (unsigned int i = 0; i < m_nAuger1[level]; ++i) {
        secondaries.emplace_back(std::make_pair(Particle::Electron, eav));
      }
    } 
  } else if (type == ElectronCollisionTypeExcitation) {
    // Follow the de-excitation cascade (if switched on).
    if (m_useDeexcitation && m_iDeexcitation[level] >= 0) {
      int fLevel = 0;
      ComputeDeexcitationInternal(m_iDeexcitation[level], fLevel);
      ndxc = m_dxcProducts.size();
    } else if (m_usePenning) {
      m_dxcProducts.clear();
      // Simplified treatment of Penning ionisation.
      // If the energy threshold of this level exceeds the
      // ionisation potential of one of the gases,
      // create a new electron (with probability rPenning).
      if (m_debug) {
        std::cout << m_className << "::ElectronCollision:\n"
                  << "    Level: " << level << "\n"
                  << "    Ionization potential: " << m_minIonPot << "\n"
                  << "    Excitation energy: " << loss * m_rgas[igas] << "\n"
                  << "    Penning probability: " << m_rPenning[level] << "\n"; 
      }
      if (loss * m_rgas[igas] > m_minIonPot &&
          RndmUniform() < m_rPenning[level]) {
        // The energy of the secondary electron is assumed to be given by
        // the difference of excitation and ionisation threshold.
        double esec = loss * m_rgas[igas] - m_minIonPot;
        if (esec <= 0) esec = Small;
        // Add the secondary electron to the list.
        dxcProd newDxcProd;
        newDxcProd.t = 0.;
        newDxcProd.s = 0.;
        if (m_lambdaPenning[level] > Small) {
          // Uniform distribution within a sphere of radius lambda
          newDxcProd.s = m_lambdaPenning[level] * std::cbrt(RndmUniformPos());
        }
        newDxcProd.energy = esec;
        newDxcProd.type = DxcProdTypeElectron;
        m_dxcProducts.push_back(std::move(newDxcProd));
        ndxc = 1;
        ++m_nPenning;
      }
    }
  }
 
  if (e < loss) loss = e - 0.0001;
 
  // Determine the scattering angle.
  double ctheta0 = 1. - 2. * RndmUniform();
  if (m_useAnisotropic) {
    switch (m_scatModel[level]) {
      case 0:
        break;
      case 1:
        ctheta0 = 1. - RndmUniform() * angCut;
        if (RndmUniform() > angPar) ctheta0 = -ctheta0;
        break;
      case 2:
        ctheta0 = (ctheta0 + angPar) / (1. + angPar * ctheta0);
        break;
      default:
        std::cerr << m_className << "::ElectronCollision:\n"
                  << "    Unknown scattering model.\n"
                  << "    Using isotropic distribution.\n";
        break;
    }
  }
 
  const double s1 = m_rgas[igas];
  const double theta0 = acos(ctheta0);
  const double arg = std::max(1. - s1 * loss / e, Small);
  const double d = 1. - ctheta0 * sqrt(arg);
 
  // Update the energy.
  e1 = std::max(e * (1. - loss / (s1 * e) - 2. * d * m_s2[igas]), Small);
  double q = std::min(sqrt((e / e1) * arg) / s1, 1.);
  const double theta = asin(q * sin(theta0));
  double ctheta = cos(theta);
  if (ctheta0 < 0.) {
    const double u = (s1 - 1.) * (s1 - 1.) / arg;
    if (ctheta0 * ctheta0 > u) ctheta = -ctheta;
  }
  const double stheta = sin(theta);
  // Calculate the direction after the collision.
  dz = std::min(dz, 1.);
  const double argZ = sqrt(dx * dx + dy * dy);
 
  // Azimuth is chosen at random.
  const double phi = TwoPi * RndmUniform();
  const double cphi = cos(phi);
  const double sphi = sin(phi);
  if (argZ > 0.) {
    const double a = stheta / argZ;
    const double dz1 = dz * ctheta + argZ * stheta * sphi;
    const double dy1 = dy * ctheta + a * (dx * cphi - dy * dz * sphi);
    const double dx1 = dx * ctheta - a * (dy * cphi + dx * dz * sphi);
    dz = dz1;
    dy = dy1;
    dx = dx1;
  } else {
    dz = ctheta;
    dx = cphi * stheta;
    dy = sphi * stheta;
  }
  return true;
}

EnableAnisotropicScattering()

void Garfield::MediumMagboltz::EnableAnisotropicScattering ( const bool on = true )

inline

Switch on/off anisotropic scattering (enabled by default)

Definition at line 42 of file MediumMagboltz.hh.

                                                         {
    m_useAnisotropic = on;
    m_isChanged = true;
  }

EnableAutoEnergyLimit()

void Garfield::MediumMagboltz::EnableAutoEnergyLimit ( const bool on = true )

inline

Let Magboltz determine the upper energy limit (this is the default) or use the energy limit specified using SetMaxElectronEnergy).

Definition at line 144 of file MediumMagboltz.hh.

{ m_autoEnergyLimit = on; }

EnableCrossSectionOutput()

void Garfield::MediumMagboltz::EnableCrossSectionOutput ( const bool on = true )

inline

Write the gas cross-section table to a file during the initialisation.

Definition at line 71 of file MediumMagboltz.hh.

{ m_useCsOutput = on; }

EnableDeexcitation()

void Garfield::MediumMagboltz::EnableDeexcitation

(

)

Switch on (microscopic) de-excitation handling.

Definition at line 205 of file MediumMagboltz.cc.

                                        {
  if (m_usePenning) {
    std::cout << m_className << "::EnableDeexcitation:\n"
              << "    Penning transfer will be switched off.\n";
  }
  // if (m_useRadTrap) {
  //   std::cout << "    Radiation trapping is switched on.\n";
  // } else {
  //   std::cout << "    Radiation trapping is switched off.\n";
  // }
  m_usePenning = false;
  m_useDeexcitation = true;
  m_isChanged = true;
  m_dxcProducts.clear();
}

EnablePenningTransfer() [1/3]

bool Garfield::MediumMagboltz::EnablePenningTransfer ( )

overridevirtual

Switch on simulation of Penning transfers, using pre-implemented parameterisations of the transfer probability (if available).

Reimplemented from Garfield::MediumGas.

Definition at line 231 of file MediumMagboltz.cc.

                                           {
  m_rPenning.fill(0.);
  m_lambdaPenning.fill(0.);
  if (!MediumGas::EnablePenningTransfer()) return false;
 
  m_usePenning = true;
  return true;
}   

EnablePenningTransfer() [2/3]

bool Garfield::MediumMagboltz::EnablePenningTransfer ( const double r, const double lambda )

overridevirtual

Switch on simulation of Penning transfers by means of transfer probabilities, for all excitation levels in the mixture.

Parameters

r	transfer probability [0, 1]
lambda	parameter for sampling the distance of the Penning electron with respect to the excitation.

Reimplemented from Garfield::MediumGas.

Definition at line 240 of file MediumMagboltz.cc.

                                                                {
   
  if (!MediumGas::EnablePenningTransfer(r, lambda)) return false;
 
  m_rPenning.fill(0.);
  m_lambdaPenning.fill(0.);
 
  // Make sure that the collision rate table is up to date.
  if (!Update()) return false;
  unsigned int nLevelsFound = 0;
  for (unsigned int i = 0; i < m_nTerms; ++i) {
    if (m_csType[i] % nCsTypes == ElectronCollisionTypeExcitation) {
      ++nLevelsFound;
    }
    m_rPenning[i] = m_rPenningGlobal;
    m_lambdaPenning[i] = m_lambdaPenningGlobal;
  }
 
  if (nLevelsFound > 0) {
    std::cout << m_className << "::EnablePenningTransfer:\n    "
              << "Updated Penning transfer parameters for " << nLevelsFound
              << " excitation cross-sections.\n";
    if (nLevelsFound != m_excLevels.size() && !m_excLevels.empty()) {
      std::cerr << m_className << "::EnablePenningTransfer:\n    Warning: "
                << "mismatch between number of excitation cross-sections ("
                << nLevelsFound << ")\n    and number of excitation rates in "
                << "the gas table (" << m_excLevels.size() << ").\n    "
                << "The gas table was probably calculated using a different "
                << "version of Magboltz.\n";
    }
  } else {
    std::cerr << m_className << "::EnablePenningTransfer:\n    "
              << "No excitation cross-sections in the present energy range.\n";
  }
 
  if (m_useDeexcitation) {
    std::cout << m_className << "::EnablePenningTransfer:\n    "
              << "Deexcitation handling will be switched off.\n";
  }
  m_usePenning = true;
  return true;
}

EnablePenningTransfer() [3/3]

bool Garfield::MediumMagboltz::EnablePenningTransfer ( const double r, const double lambda, std::string gasname )

overridevirtual

Switch on simulation of Penning transfers by means of transfer probabilities, for all excitations of a given component.

Reimplemented from Garfield::MediumGas.

Definition at line 284 of file MediumMagboltz.cc.

                                                              {
 
  if (!MediumGas::EnablePenningTransfer(r, lambda, gasname)) return false;
 
  // Get (again) the "standard" name of this gas.
  gasname = GetGasName(gasname);
  if (gasname.empty()) return false;
 
  // Look (again) for this gas in the present mixture.
  int iGas = -1;
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    if (m_gas[i] == gasname) {
      iGas = i;
      break;
    }
  }
 
  // Make sure that the collision rate table is up to date.
  if (!Update()) return false;
  unsigned int nLevelsFound = 0;
  for (unsigned int i = 0; i < m_nTerms; ++i) {
    if (int(m_csType[i] / nCsTypes) != iGas) continue;
    if (m_csType[i] % nCsTypes == ElectronCollisionTypeExcitation) {
      ++nLevelsFound;
    }
    m_rPenning[i] = m_rPenningGas[iGas];
    m_lambdaPenning[i] = m_lambdaPenningGas[iGas];
  }
 
  if (nLevelsFound > 0) {
    std::cout << m_className << "::EnablePenningTransfer:\n";
    if (m_lambdaPenningGas[iGas] > 0.) {
      std::cout << "    Penning transfer parameters for " << nLevelsFound
                << " " << gasname << " excitation levels set to:\n"
                << "      r = " << m_rPenningGas[iGas] << ", lambda = "
                << m_lambdaPenningGas[iGas] << " cm\n";
    } else {
      std::cout << "    Penning transfer probability for " << nLevelsFound
                << " " << gasname << " excitation levels set to r = "
                << m_rPenningGas[iGas] << "\n";
    }
  } else {
    std::cerr << m_className << "::EnablePenningTransfer:\n    " << gasname
              << " has no excitation levels in the present energy range.\n";
  }
 
  m_usePenning = true;
  return true;
}

EnableRadiationTrapping()

void Garfield::MediumMagboltz::EnableRadiationTrapping

(

)

Switch on discrete photoabsorption levels.

Definition at line 221 of file MediumMagboltz.cc.

                                             {
  m_useRadTrap = true;
  if (!m_useDeexcitation) {
    std::cout << m_className << "::EnableRadiationTrapping:\n    "
              << "Radiation trapping is enabled but de-excitation is not.\n";
  } else {
    m_isChanged = true;
  }
}

EnableThermalMotion()

void Garfield::MediumMagboltz::EnableThermalMotion ( const bool on = true )

inline

Take the thermal motion of the gas at the selected temperature into account in the calculations done by Magboltz. By the default, this feature is off (static gas at 0 K).

Definition at line 141 of file MediumMagboltz.hh.

{ m_useGasMotion = on; }

GenerateGasTable()

void Garfield::MediumMagboltz::GenerateGasTable	(	const int	numCollisions = 10,
		const bool	verbose = true )

Generate a new gas table (can later be saved to file) by running Magboltz for all electric fields, magnetic fields, and angles in the currently set grid.

Definition at line 2787 of file MediumMagboltz.cc.

                                                                           {
  // Set the reference pressure and temperature.
  m_pressureTable = m_pressure;
  m_temperatureTable = m_temperature;
 
  // Initialize the parameter arrays.
  const unsigned int nEfields = m_eFields.size();
  const unsigned int nBfields = m_bFields.size();
  const unsigned int nAngles = m_bAngles.size();
  Init(nEfields, nBfields, nAngles, m_eVelE, 0.);
  Init(nEfields, nBfields, nAngles, m_eVelB, 0.);
  Init(nEfields, nBfields, nAngles, m_eVelX, 0.);
  Init(nEfields, nBfields, nAngles, m_eDifL, 0.);
  Init(nEfields, nBfields, nAngles, m_eDifT, 0.);
  Init(nEfields, nBfields, nAngles, m_eLor, 0.);
  Init(nEfields, nBfields, nAngles, m_eAlp, -30.);
  Init(nEfields, nBfields, nAngles, m_eAlp0, -30.);
  Init(nEfields, nBfields, nAngles, m_eAtt, -30.);
  Init(nEfields, nBfields, nAngles, 6, m_eDifM, 0.);
 
  m_excRates.clear();
  m_ionRates.clear();
  // Retrieve the excitation and ionisation cross-sections in the gas mixture.
  GetExcitationIonisationLevels();
  std::cout << m_className << "::GenerateGasTable: Found "
            << m_excLevels.size() << " excitations and "
            << m_ionLevels.size() << " ionisations.\n";
  for (const auto& exc : m_excLevels) {
    std::cout << "    " << exc.label << ", energy = " << exc.energy << " eV.\n";
  }
  for (const auto& ion : m_ionLevels) {
    std::cout << "    " << ion.label << ", energy = " << ion.energy << " eV.\n";
  }
  if (!m_excLevels.empty()) {
    Init(nEfields, nBfields, nAngles, m_excLevels.size(), m_excRates, 0.);
  }
  if (!m_ionLevels.empty()) {
    Init(nEfields, nBfields, nAngles, m_ionLevels.size(), m_ionRates, 0.);
  }
  double vx = 0., vy = 0., vz = 0.;
  double difl = 0., dift = 0.;
  double alpha = 0., eta = 0.;
  double lor = 0.;
  double vxerr = 0., vyerr = 0., vzerr = 0.;
  double diflerr = 0., difterr = 0.;
  double alphaerr = 0., etaerr = 0.;
  double alphatof = 0.;
  double lorerr = 0.;
  std::array<double, 6> difftens;
 
  // Run through the grid of E- and B-fields and angles.
  for (unsigned int i = 0; i < nEfields; ++i) {
    const double e = m_eFields[i];
    for (unsigned int j = 0; j < nAngles; ++j) {
      const double a = m_bAngles[j];
      for (unsigned int k = 0; k < nBfields; ++k) {
        const double b = m_bFields[k];
        std::cout << m_className << "::GenerateGasTable: E = " << e
                  << " V/cm, B = " << b << " T, angle: " << a << " rad\n";
        RunMagboltz(e, b, a, numColl, verbose, vx, vy, vz, difl, dift, alpha,
                    eta, lor, vxerr, vyerr, vzerr, diflerr, difterr, alphaerr,
                    etaerr, lorerr, alphatof, difftens);
        m_eVelE[j][k][i] = vz;
        m_eVelX[j][k][i] = vy;
        m_eVelB[j][k][i] = vx;
        m_eDifL[j][k][i] = difl;
        m_eDifT[j][k][i] = dift;
        m_eLor[j][k][i] = lor;
        m_eAlp[j][k][i] = alpha > 0. ? log(alpha) : -30.;
        m_eAlp0[j][k][i] = m_eAlp[j][k][i];
        m_eAtt[j][k][i] = eta > 0. ? log(eta) : -30.;
        for (unsigned int l = 0; l < 6; ++l) {
          m_eDifM[l][j][k][i] = difftens[l];
        }
        // Retrieve the excitation and ionisation rates.
        unsigned int nNonZero = 0;
        if (m_useGasMotion) {
          // Retrieve the total collision frequency and number of collisions.
          double ftot = 0., fel = 0., fion = 0., fatt = 0., fin = 0.;
          std::int64_t ntotal = 0;
          Magboltz::colft_(&ftot, &fel, &fion, &fatt, &fin, &ntotal);
          if (ntotal == 0) continue;
          // Convert from ps-1 to ns-1.
          const double scale = 1.e3 * ftot / ntotal;
          for (unsigned int ig = 0; ig < m_nComponents; ++ig) {
            const auto nL = Magboltz::larget_.last[ig];
            for (std::int64_t il = 0; il < nL; ++il) {
              if (Magboltz::larget_.iarry[il][ig] <= 0) break;
              // Skip levels that are not ionisations or inelastic collisions.
              const int cstype = (Magboltz::larget_.iarry[il][ig] - 1) % 5;
              if (cstype != 1 && cstype != 3) continue;
              // const int igas = int((Magboltz::larget_.iarry[il][ig] - 1) / 5);
              auto descr = GetDescription(il, ig, Magboltz::script_.dscrpt);
              descr = m_gas[ig] + descr;
              if (cstype == 3) {
                const unsigned int nExc = m_excLevels.size();
                for (unsigned int ie = 0; ie < nExc; ++ie) {
                  if (descr != m_excLevels[ie].label) continue;
                  const auto ncoll = Magboltz::outptt_.icoln[il][ig];
                  m_excRates[ie][j][k][i] = scale * ncoll;
                  if (ncoll > 0) ++nNonZero;
                  break;
                }
              } else if (cstype == 1) {
                const unsigned int nIon = m_ionLevels.size();
                for (unsigned int ii = 0; ii < nIon; ++ii) {
                  if (descr != m_ionLevels[ii].label) continue;
                  const auto ncoll = Magboltz::outptt_.icoln[il][ig];
                  m_ionRates[ii][j][k][i] = scale * ncoll;
                  if (ncoll > 0) ++nNonZero;
                  break;
                }
              }
            }
          }
        } else {
          // Retrieve the total collision frequency and number of collisions.
          double ftot = 0., fel = 0., fion = 0., fatt = 0., fin = 0.;
          std::int64_t ntotal = 0;
          Magboltz::colf_(&ftot, &fel, &fion, &fatt, &fin, &ntotal);
          if (ntotal == 0) continue;
          // Convert from ps-1 to ns-1.
          const double scale = 1.e3 * ftot / ntotal;
          for (std::int64_t il = 0; il < Magboltz::nMaxLevels; ++il) {
            if (Magboltz::large_.iarry[il] <= 0) break;
            // Skip levels that are not ionisations or inelastic collisions.
            const int cstype = (Magboltz::large_.iarry[il] - 1) % 5;
            if (cstype != 1 && cstype != 3) continue;
            const int igas = int((Magboltz::large_.iarry[il] - 1) / 5);
            std::string descr = GetDescription(il, Magboltz::scrip_.dscrpt);
            descr = m_gas[igas] + descr;
            if (cstype == 3) {
              const unsigned int nExc = m_excLevels.size();
              for (unsigned int ie = 0; ie < nExc; ++ie) {
                if (descr != m_excLevels[ie].label) continue;
                m_excRates[ie][j][k][i] = scale * Magboltz::outpt_.icoln[il];
                if (Magboltz::outpt_.icoln[il] > 0) ++nNonZero;
                break;
              }
            } else if (cstype == 1) {
              const unsigned int nIon = m_ionLevels.size();
              for (unsigned int ii = 0; ii < nIon; ++ii) {
                if (descr != m_ionLevels[ii].label) continue;
                m_ionRates[ii][j][k][i] = scale * Magboltz::outpt_.icoln[il];
                if (Magboltz::outpt_.icoln[il] > 0) ++nNonZero;
                break;
              }
            }
          }
        }
        if (nNonZero > 0) {
          std::cout << "    Excitation and ionisation rates:\n";
          std::cout << "                         Level                         "
                    << "          Rate [ns-1]\n";
          const unsigned int nExc = m_excLevels.size();
          for (unsigned int ie = 0; ie < nExc; ++ie) {
            if (m_excRates[ie][j][k][i] <= 0) continue;
            std::cout << std::setw(60) << m_excLevels[ie].label;
            std::printf(" %15.8f\n", m_excRates[ie][j][k][i]);
          }
          const unsigned int nIon = m_ionLevels.size();
          for (unsigned int ii = 0; ii < nIon; ++ii) {
            if (m_ionRates[ii][j][k][i] <= 0) continue;
            std::cout << std::setw(60) << m_ionLevels[ii].label;
            std::printf(" %15.8f\n", m_ionRates[ii][j][k][i]);
          }
        }
      }
    }
  }
  // Set the threshold indices.
  SetThreshold(m_eAlp);
  SetThreshold(m_eAtt);
}

GetDeexcitationProduct()

bool Garfield::MediumMagboltz::GetDeexcitationProduct ( const unsigned int i, double & t, double & s, int & type, double & energy ) const

overridevirtual

Reimplemented from Garfield::Medium.

Definition at line 835 of file MediumMagboltz.cc.

                                                                  {
  if (i >= m_dxcProducts.size() || !(m_useDeexcitation || m_usePenning)) {
    return false;
  }
  t = m_dxcProducts[i].t;
  s = m_dxcProducts[i].s;
  type = m_dxcProducts[i].type;
  energy = m_dxcProducts[i].energy;
  return true;
}

GetElectronCollisionRate() [1/2]

double Garfield::MediumMagboltz::GetElectronCollisionRate ( const double e, const int band )

overridevirtual

Get the (real) collision rate [ns-1] at a given electron energy e [eV].

Reimplemented from Garfield::Medium.

Definition at line 517 of file MediumMagboltz.cc.

                                                             {
  // Check if the electron energy is within the currently set range.
  if (e <= 0.) {
    std::cerr << m_className << "::GetElectronCollisionRate: Invalid energy.\n";
    return m_cfTot[0];
  }
  if (e > m_eMax) {
    std::cerr << m_className << "::GetElectronCollisionRate:\n    Rate at " << e
              << " eV is not included in the current table.\n    "
              << "Increasing energy range to " << 1.05 * e << " eV.\n";
    SetMaxElectronEnergy(1.05 * e);
  }
 
  // If necessary, update the collision rates table.
  if (!Update()) return 0.;
 
  // Get the energy interval.
  if (e < m_eHigh) {
    // Linear binning
    return m_cfTot[int(e * m_eStepInv)];
  }
 
  // Logarithmic binning
  const double eLog = log(e);
  int iE = int((eLog - m_eHighLog) / m_lnStep);
  // Calculate the collision rate by log-log interpolation.
  const double fmax = m_cfTotLog[iE];
  const double fmin = iE == 0 ? log(m_cfTot.back()) : m_cfTotLog[iE - 1];
  const double emin = m_eHighLog + iE * m_lnStep;
  const double f = fmin + (eLog - emin) * (fmax - fmin) / m_lnStep;
  return exp(f);
}

Referenced by GetElectronCollisionRate().

GetElectronCollisionRate() [2/2]

double Garfield::MediumMagboltz::GetElectronCollisionRate	(	const double	e,
		const unsigned int	level,
		const int	band )

Get the collision rate [ns-1] for a specific level.

Definition at line 551 of file MediumMagboltz.cc.

                                                                {
  // Check if the electron energy is within the currently set range.
  if (e <= 0.) {
    std::cerr << m_className << "::GetElectronCollisionRate: Invalid energy.\n";
    return 0.;
  }
 
  // Check if the level exists.
  if (level >= m_nTerms) {
    std::cerr << m_className << "::GetElectronCollisionRate: Invalid level.\n";
    return 0.;
  }
 
  // Get the total scattering rate.
  double rate = GetElectronCollisionRate(e, band);
  // Get the energy interval.
  if (e < m_eHigh) {
    // Linear binning
    const int iE = int(e * m_eStepInv);
    if (level == 0) {
      rate *= m_cf[iE][0];
    } else {
      rate *= m_cf[iE][level] - m_cf[iE][level - 1];
    }
  } else {
    // Logarithmic binning
    const int iE = int((log(e) - m_eHighLog) / m_lnStep);
    if (level == 0) {
      rate *= m_cfLog[iE][0];
    } else {
      rate *= m_cfLog[iE][level] - m_cfLog[iE][level - 1];
    }
  }
  return rate;
}

GetElectronNullCollisionRate()

double Garfield::MediumMagboltz::GetElectronNullCollisionRate ( const int band )

overridevirtual

Get the overall null-collision rate [ns-1].

Reimplemented from Garfield::Medium.

Definition at line 511 of file MediumMagboltz.cc.

                                                               {
  // If necessary, update the collision rates table.
  if (!Update()) return 0.;
  return m_cfNull;
}

GetGasNumberMagboltz()

int Garfield::MediumMagboltz::GetGasNumberMagboltz ( const std::string & input )

static

Definition at line 1099 of file MediumMagboltz.cc.

                                                               {
 
  if (input.empty()) return 0;
 
  if (input == "CF4") {
    return 1;
  } else if (input == "Ar") {
    return 2;
  } else if (input == "He" || input == "He-4") {
    // Helium 4
    return 3;
  } else if (input == "He-3") {
    // Helium 3
    return 4;
  } else if (input == "Ne") {
    return 5;
  } else if (input == "Kr") {
    return 6;
  } else if (input == "Xe") {
    return 7;
  } else if (input == "CH4") {
    // Methane
    return 8;
  } else if (input == "C2H6") {
    // Ethane
    return 9;
  } else if (input == "C3H8") {
    // Propane
    return 10;
  } else if (input == "iC4H10") {
    // Isobutane
    return 11;
  } else if (input == "CO2") {
    return 12;
  } else if (input == "neoC5H12") {
    // Neopentane
    return 13;
  } else if (input == "H2O") {
    return 14;
  } else if (input == "O2") {
    return 15;
  } else if (input == "N2") {
    return 16;
  } else if (input == "NO") {
    // Nitric oxide (NO)
    return 17;
  } else if (input == "N2O") {
    // Nitrous oxide (N2O)
    return 18;
  } else if (input == "C2H4") {
    // Ethene (C2H4)
    return 19;
  } else if (input == "C2H2") {
    // Acetylene (C2H2)
    return 20;
  } else if (input == "H2") {
    // Hydrogen
    return 21;
  } else if (input == "D2") {
    // Deuterium
    return 22;
  } else if (input == "CO") {
    // Carbon monoxide (CO)
    return 23;
  } else if (input == "Methylal") {
    // Methylal (dimethoxymethane, CH3-O-CH2-O-CH3, "hot" version)
    return 24;
  } else if (input == "DME") {
    return 25;
  } else if (input == "Reid-Step") {
    return 26;
  } else if (input == "Maxwell-Model") {
    return 27;
  } else if (input == "Reid-Ramp") {
    return 28;
  } else if (input == "C2F6") {
    return 29;
  } else if (input == "SF6") {
    return 30;
  } else if (input == "NH3") {
    return 31;
  } else if (input == "C3H6") {
    // Propene
    return 32;
  } else if (input == "cC3H6") {
    // Cyclopropane
    return 33;
  } else if (input == "CH3OH") {
    // Methanol
    return 34;
  } else if (input == "C2H5OH") {
    // Ethanol
    return 35;
  } else if (input == "C3H7OH") {
    // Propanol
    return 36;
  } else if (input == "Cs") {
    return 37;
  } else if (input == "F2") {
    // Fluorine
    return 38;
  } else if (input == "CS2") {
    return 39;
  } else if (input == "COS") {
    return 40;
  } else if (input == "CD4") {
    // Deuterated methane
    return 41;
  } else if (input == "BF3") {
    return 42;
  } else if (input == "C2HF5" || input == "C2H2F4") {
    return 43;
  } else if (input == "TMA") {
    return 44;
  } else if (input == "nC3H7OH") {
    // n-propanol
    return 46;
  } else if (input == "paraH2") {
    // Para hydrogen
    return 47;
  } else if (input == "orthoD2") {
    // Ortho deuterium
    return 48;
  } else if (input == "CHF3") {
    return 50;
  } else if (input == "CF3Br") {
    return 51;
  } else if (input == "C3F8") {
    return 52;
  } else if (input == "O3") {
    // Ozone
    return 53;
  } else if (input == "Hg") {
    // Mercury
    return 54;
  } else if (input == "H2S") {
    return 55;
  } else if (input == "nC4H10") {
    // n-Butane
    return 56;
  } else if (input == "nC5H12") {
    // n-Pentane
    return 57;
  } else if (input == "N2 (Phelps)") {
    return 58;
  } else if (input == "GeH4") {
    // Germane, GeH4
    return 59;
  } else if (input == "SiH4") {
    // Silane, SiH4
    return 60;
  } else if (input == "CCl4") {
    return 61;
  }
 
  std::cerr << "MediumMagboltz::GetGasNumberMagboltz:\n"
            << "    Gas " << input << " is not defined.\n";
  return 0;
}

Referenced by Garfield::TrackDegrade::Initialise(), and RunMagboltz().

GetLevel()

bool Garfield::MediumMagboltz::GetLevel	(	const unsigned int	i,
		int &	ngas,
		int &	type,
		std::string &	descr,
		double &	e )

Get detailed information about a given cross-section term i.

Definition at line 996 of file MediumMagboltz.cc.

                                                           {
  if (!Update()) return false;
 
  if (i >= m_nTerms) {
    std::cerr << m_className << "::GetLevel: Index out of range.\n";
    return false;
  }
 
  // Collision type
  type = m_csType[i] % nCsTypes;
  ngas = int(m_csType[i] / nCsTypes);
  // Description (from Magboltz)
  descr = m_description[i];
  // Threshold energy
  e = m_rgas[ngas] * m_energyLoss[i];
  if (m_debug) {
    std::cout << m_className << "::GetLevel:\n"
              << "    Level " << i << ": " << descr << "\n"
              << "    Type " << type << "\n"
              << "    Threshold energy: " << e << " eV\n";
    if (type == ElectronCollisionTypeExcitation && m_usePenning &&
        e > m_minIonPot) {
      std::cout << "    Penning transfer coefficient: " << m_rPenning[i]
                << "\n";
    } else if (type == ElectronCollisionTypeExcitation && m_useDeexcitation) {
      const int idxc = m_iDeexcitation[i];
      if (idxc < 0 || idxc >= (int)m_deexcitations.size()) {
        std::cout << "    Deexcitation cascade not implemented.\n";
        return true;
      }
      const auto& dxc = m_deexcitations[idxc];
      if (dxc.osc > 0.) {
        std::cout << "    Oscillator strength: " << dxc.osc << "\n";
      }
      std::cout << "    Decay channels:\n";
      const int nChannels = dxc.type.size();
      for (int j = 0; j < nChannels; ++j) {
        if (dxc.type[j] == DxcTypeRad) {
          std::cout << "      Radiative decay to ";
          if (dxc.final[j] < 0) {
            std::cout << "ground state: ";
          } else {
            std::cout << m_deexcitations[dxc.final[j]].label << ": ";
          }
        } else if (dxc.type[j] == DxcTypeCollIon) {
          if (dxc.final[j] < 0) {
            std::cout << "      Penning ionisation: ";
          } else {
            std::cout << "      Associative ionisation: ";
          }
        } else if (dxc.type[j] == DxcTypeCollNonIon) {
          if (dxc.final[j] >= 0) {
            std::cout << "      Collision-induced transition to "
                      << m_deexcitations[dxc.final[j]].label << ": ";
          } else {
            std::cout << "      Loss: ";
          }
        }
        const double br = j == 0 ? dxc.p[j] : dxc.p[j] - dxc.p[j - 1];
        std::cout << std::setprecision(5) << br * 100. << "%\n";
      }
    }
  }
 
  return true;
}

GetMaxElectronEnergy()

double Garfield::MediumMagboltz::GetMaxElectronEnergy ( ) const

inline

Get the highest electron energy in the table of scattering rates.

Definition at line 33 of file MediumMagboltz.hh.

{ return m_eMax; }

GetMaxPhotonEnergy()

double Garfield::MediumMagboltz::GetMaxPhotonEnergy ( ) const

inline

Get the highest photon energy in the table of scattering rates.

Definition at line 39 of file MediumMagboltz.hh.

{ return m_eFinalGamma; }

GetNumberOfDeexcitationProducts()

unsigned int Garfield::MediumMagboltz::GetNumberOfDeexcitationProducts ( ) const

inlineoverridevirtual

Reimplemented from Garfield::Medium.

Definition at line 96 of file MediumMagboltz.hh.

                                                                {
    return m_dxcProducts.size();
  }

GetNumberOfElectronCollisions() [1/3]

unsigned int Garfield::MediumMagboltz::GetNumberOfElectronCollisions

(

)

const

Get the total number of electron collisions.

Definition at line 973 of file MediumMagboltz.cc.

                                                                 {
  return std::accumulate(std::begin(m_nCollisions), std::end(m_nCollisions), 0);
}

GetNumberOfElectronCollisions() [2/3]

unsigned int Garfield::MediumMagboltz::GetNumberOfElectronCollisions

(

const unsigned int

level

)

const

Get the number of collisions for a specific cross-section term.

Definition at line 1075 of file MediumMagboltz.cc.

                                    {
  if (level >= m_nTerms) {
    std::cerr << m_className << "::GetNumberOfElectronCollisions: "
              << "Level " << level << " does not exist.\n";
    return 0;
  }
  return m_nCollisionsDetailed[level];
}

GetNumberOfElectronCollisions() [3/3]

unsigned int Garfield::MediumMagboltz::GetNumberOfElectronCollisions	(	unsigned int &	nElastic,
		unsigned int &	nIonising,
		unsigned int &	nAttachment,
		unsigned int &	nInelastic,
		unsigned int &	nExcitation,
		unsigned int &	nSuperelastic ) const

Get the number of collisions broken down by cross-section type.

Definition at line 977 of file MediumMagboltz.cc.

                                                                  {
  nElastic = m_nCollisions[ElectronCollisionTypeElastic];
  nIonisation = m_nCollisions[ElectronCollisionTypeIonisation];
  nAttachment = m_nCollisions[ElectronCollisionTypeAttachment];
  nInelastic = m_nCollisions[ElectronCollisionTypeInelastic];
  nExcitation = m_nCollisions[ElectronCollisionTypeExcitation];
  nSuperelastic = m_nCollisions[ElectronCollisionTypeSuperelastic];
  return nElastic + nIonisation + nAttachment + nInelastic + nExcitation +
         nSuperelastic;
}

GetNumberOfLevels()

unsigned int Garfield::MediumMagboltz::GetNumberOfLevels

(

)

Get the number of cross-section terms.

Definition at line 991 of file MediumMagboltz.cc.

                                               {
  if (!Update()) return 0;
  return m_nTerms;
}

GetNumberOfPenningTransfers()

unsigned int Garfield::MediumMagboltz::GetNumberOfPenningTransfers ( ) const

inline

Get the number of Penning transfers that occured since the last reset.

Definition at line 129 of file MediumMagboltz.hh.

{ return m_nPenning; }

GetNumberOfPhotonCollisions() [1/2]

unsigned int Garfield::MediumMagboltz::GetNumberOfPhotonCollisions

(

)

const

Get the total number of photon collisions.

Definition at line 1085 of file MediumMagboltz.cc.

                                                               {
  return std::accumulate(std::begin(m_nPhotonCollisions),
                         std::end(m_nPhotonCollisions), 0);
}

GetNumberOfPhotonCollisions() [2/2]

unsigned int Garfield::MediumMagboltz::GetNumberOfPhotonCollisions	(	unsigned int &	nElastic,
		unsigned int &	nIonising,
		unsigned int &	nInelastic ) const

Get number of photon collisions by collision type.

Definition at line 1090 of file MediumMagboltz.cc.

                                    {
  nElastic = m_nPhotonCollisions[0];
  nIonising = m_nPhotonCollisions[1];
  nInelastic = m_nPhotonCollisions[2];
  return nElastic + nIonising + nInelastic;
}

GetPenningTransfer()

bool Garfield::MediumMagboltz::GetPenningTransfer	(	const unsigned int	i,
		double &	r,
		double &	lambda )

Get the Penning transfer probability and distance of a specific level.

Definition at line 1064 of file MediumMagboltz.cc.

                                                                   {
  r = 0.;
  lambda = 0.;
  if (!Update()) return false;
  if (i >= m_nTerms) return false;
  r = m_rPenning[i];
  lambda = m_lambdaPenning[i];
  return true; 
}

GetPhotonCollision()

bool Garfield::MediumMagboltz::GetPhotonCollision ( const double e, int & type, int & level, double & e1, double & ctheta, int & nsec, double & esec )

overridevirtual

Reimplemented from Garfield::Medium.

Definition at line 879 of file MediumMagboltz.cc.

                                                      {
  if (e <= 0.) {
    std::cerr << m_className << "::GetPhotonCollision: Invalid energy.\n";
    return false;
  }
  if (e > m_eFinalGamma) {
    std::cerr << m_className << "::GetPhotonCollision:\n    Provided energy ("
              << e << " eV) exceeds current energy range.\n"
              << "    Increasing energy range to " << 1.05 * e << " eV.\n";
    SetMaxPhotonEnergy(1.05 * e);
  }
 
  if (!Update()) return false;
 
  // Energy interval
  const int iE =
      std::min(std::max(int(e / m_eStepGamma), 0), nEnergyStepsGamma - 1);
 
  double r = m_cfTotGamma[iE];
  if (m_useDeexcitation && m_useRadTrap && !m_deexcitations.empty()) {
    int nLines = 0;
    std::vector<double> pLine(0);
    std::vector<int> iLine(0);
    // Loop over the excitations.
    const unsigned int nDeexcitations = m_deexcitations.size();
    for (unsigned int i = 0; i < nDeexcitations; ++i) {
      const auto& dxc = m_deexcitations[i];
      if (dxc.cf > 0. && fabs(e - dxc.energy) <= dxc.width) {
        r += dxc.cf *
             TMath::Voigt(e - dxc.energy, dxc.sDoppler, 2 * dxc.gPressure);
        pLine.push_back(r);
        iLine.push_back(i);
        ++nLines;
      }
    }
    r *= RndmUniform();
    if (nLines > 0 && r >= m_cfTotGamma[iE]) {
      // Photon is absorbed by a discrete line.
      for (int i = 0; i < nLines; ++i) {
        if (r <= pLine[i]) {
          ++m_nPhotonCollisions[PhotonCollisionTypeExcitation];
          int fLevel = 0;
          ComputeDeexcitationInternal(iLine[i], fLevel);
          type = PhotonCollisionTypeExcitation;
          nsec = m_dxcProducts.size();
          return true;
        }
      }
      std::cerr << m_className << "::GetPhotonCollision:\n";
      std::cerr << "    Random sampling of deexcitation line failed.\n";
      std::cerr << "    Program bug!\n";
      return false;
    }
  } else {
    r *= RndmUniform();
  }
 
  if (r <= m_cfGamma[iE][0]) {
    level = 0;
  } else if (r >= m_cfGamma[iE][m_nPhotonTerms - 1]) {
    level = m_nPhotonTerms - 1;
  } else {
    const auto begin = m_cfGamma[iE].cbegin();
    level = std::lower_bound(begin, begin + m_nPhotonTerms, r) - begin;
  }
 
  nsec = 0;
  esec = e1 = 0.;
  type = csTypeGamma[level];
  // Collision type
  type = type % nCsTypesGamma;
  int ngas = int(csTypeGamma[level] / nCsTypesGamma);
  ++m_nPhotonCollisions[type];
  // Ionising collision
  if (type == 1) {
    esec = std::max(e - m_ionPot[ngas], Small);
    nsec = 1;
  }
 
  // Determine the scattering angle
  ctheta = 2 * RndmUniform() - 1.;
 
  return true;
}

GetPhotonCollisionRate()

double Garfield::MediumMagboltz::GetPhotonCollisionRate ( const double e )

overridevirtual

Reimplemented from Garfield::Medium.

Definition at line 848 of file MediumMagboltz.cc.

                                                            {
  if (e <= 0.) {
    std::cerr << m_className << "::GetPhotonCollisionRate: Invalid energy.\n";
    return m_cfTotGamma[0];
  }
  if (e > m_eFinalGamma) {
    std::cerr << m_className << "::GetPhotonCollisionRate:\n    Rate at " << e
              << " eV is not included in the current table.\n"
              << "    Increasing energy range to " << 1.05 * e << " eV.\n";
    SetMaxPhotonEnergy(1.05 * e);
  }
 
  if (!Update()) return 0.;
 
  const int iE =
      std::min(std::max(int(e / m_eStepGamma), 0), nEnergyStepsGamma - 1);
 
  double cfSum = m_cfTotGamma[iE];
  if (m_useDeexcitation && m_useRadTrap && !m_deexcitations.empty()) {
    // Loop over the excitations.
    for (const auto& dxc : m_deexcitations) {
      if (dxc.cf > 0. && fabs(e - dxc.energy) <= dxc.width) {
        cfSum += dxc.cf *
                 TMath::Voigt(e - dxc.energy, dxc.sDoppler, 2 * dxc.gPressure);
      }
    }
  }
 
  return cfSum;
}

Initialise()

bool Garfield::MediumMagboltz::Initialise

(

const bool

verbose = false

)

Initialise the table of scattering rates (called internally when a collision rate is requested and the gas mixture or other parameters have changed).

Definition at line 418 of file MediumMagboltz.cc.

                                                  {
  if (!m_isChanged) {
    if (m_debug) {
      std::cerr << m_className << "::Initialise: Nothing changed.\n";
    }
    return true;
  }
  return Update(verbose);
}

Referenced by PrintGas().

PlotElectronCrossSections()

void Garfield::MediumMagboltz::PlotElectronCrossSections

(

)

Definition at line 1871 of file MediumMagboltz.cc.

                                               {
 
  if (!Update()) return;
 
  std::array<float, Magboltz::nEnergySteps> en;
  for (unsigned int k = 0; k < Magboltz::nEnergySteps; ++k) {
    en[k] = (k + 0.5) * m_eStep;
  } 
  std::array<std::array<float, Magboltz::nEnergySteps>, 5> cs;
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    for (size_t j = 0; j < 5; ++j) cs[j].fill(0.);
    const double density = GetNumberDensity() * m_fraction[i];
    const double scale = sqrt(0.5 * ElectronMass) / (density * SpeedOfLight);
    for (unsigned int j = 0; j < m_nTerms; ++j) {
      if (int(m_csType[j] / nCsTypes) != int(i)) continue;
      int cstype = m_csType[j] % nCsTypes;
      if (cstype >= ElectronCollisionTypeVirtual) continue;
      // Group inelastic and superelastic collisions.
      if (cstype == 5) cstype = 3;
      for (unsigned int k = 0; k < Magboltz::nEnergySteps; ++k) {
        double cf = m_cf[k][j];
        if (j > 0) cf -= m_cf[k][j - 1]; 
        cs[cstype][k] += cf * 1.e18 * scale;
      }
    }
    const std::string name = ViewBase::FindUnusedCanvasName("cCs");
    TCanvas* canvas = new TCanvas(name.c_str(), m_gas[i].c_str(), 800, 600);
    canvas->cd();
    canvas->SetLogx();
    canvas->SetLogy();
    canvas->SetGridx();
    canvas->SetGridy();
    canvas->DrawFrame(en[0], 0.01, en.back(), 100., 
                      ";energy [eV];#sigma [Mbarn]");
    TGraph gr(Magboltz::nEnergySteps);
    gr.SetLineWidth(3);
    const std::array<short, 5> cols = {kBlack, kCyan - 2, kRed + 2, 
                                       kGreen + 3, kMagenta + 3}; 
    for (size_t j = 0; j < 5; ++j) {
      if (*std::max_element(cs[j].begin(), cs[j].end()) < 1.e-10) continue;
      gr.SetLineColor(cols[j]);
      gr.DrawGraph(Magboltz::nEnergySteps, en.data(), cs[j].data(), "lsame");
    }
    canvas->Update();
  }
 
}

PrintGas()

void Garfield::MediumMagboltz::PrintGas ( )

overridevirtual

Print information about the present gas mixture and available data.

Reimplemented from Garfield::MediumGas.

Definition at line 428 of file MediumMagboltz.cc.

                              {
  MediumGas::PrintGas();
 
  if (m_isChanged) {
    if (!Initialise()) return;
  }
 
  std::cout << "    Electron cross-sections:\n";
  int igas = -1; 
  for (unsigned int i = 0; i < m_nTerms; ++i) {
    // Collision type
    int type = m_csType[i] % nCsTypes;
    if (igas != int(m_csType[i] / nCsTypes)) {
      igas = int(m_csType[i] / nCsTypes);
      std::cout << "      " << m_gas[igas] << "\n";
    }
    // Description (from Magboltz)
    // Threshold energy
    double e = m_rgas[igas] * m_energyLoss[i];
    std::cout << "        Level " << i << ": " << m_description[i] << "\n";
    std::cout << "          Type " << type;
    if (type == ElectronCollisionTypeElastic) {
      std::cout << " (elastic)\n";
    } else if (type == ElectronCollisionTypeIonisation) {
      std::cout << " (ionisation). Ionisation threshold: " << e << " eV.\n";
    } else if (type == ElectronCollisionTypeAttachment) {
      std::cout << " (attachment)\n";
    } else if (type == ElectronCollisionTypeInelastic) {
      std::cout << " (inelastic). Energy loss: " << e << " eV.\n";
    } else if (type == ElectronCollisionTypeExcitation) {
      std::cout << " (excitation). Excitation energy: " << e << " eV.\n";
    } else if (type == ElectronCollisionTypeSuperelastic) {
      std::cout << " (super-elastic). Energy gain: " << -e << " eV.\n";
    } else if (type == ElectronCollisionTypeVirtual) {
      std::cout << " (virtual)\n";
    } else {
      std::cout << " (unknown)\n";
    }
    if (type == ElectronCollisionTypeExcitation && m_usePenning &&
        e > m_minIonPot) {
      std::cout << "          Penning transfer coefficient: " 
                << m_rPenning[i] << "\n";
    } else if (type == ElectronCollisionTypeExcitation && m_useDeexcitation) {
      const int idxc = m_iDeexcitation[i];
      if (idxc < 0 || idxc >= (int)m_deexcitations.size()) {
        std::cout << "          Deexcitation cascade not implemented.\n";
        continue;
      }
      const auto& dxc = m_deexcitations[idxc];
      if (dxc.osc > 0.) {
        std::cout << "          Oscillator strength: " << dxc.osc << "\n";
      }
      std::cout << "          Decay channels:\n";
      const int nChannels = dxc.type.size();
      for (int j = 0; j < nChannels; ++j) {
        if (dxc.type[j] == DxcTypeRad) {
          std::cout << "          Radiative decay to ";
          if (dxc.final[j] < 0) {
            std::cout << "ground state: ";
          } else {
            std::cout << m_deexcitations[dxc.final[j]].label << ": ";
          }
        } else if (dxc.type[j] == DxcTypeCollIon) {
          if (dxc.final[j] < 0) {
            std::cout << "          Penning ionisation: ";
          } else {
            std::cout << "          Associative ionisation: ";
          }
        } else if (dxc.type[j] == DxcTypeCollNonIon) {
          if (dxc.final[j] >= 0) {
            std::cout << "          Collision-induced transition to "
                      << m_deexcitations[dxc.final[j]].label << ": ";
          } else {
            std::cout << "          Loss: ";
          }
        }
        const double br = j == 0 ? dxc.p[j] : dxc.p[j] - dxc.p[j - 1];
        std::cout << std::setprecision(5) << br * 100. << "%\n";
      }
    }
  }
}

ResetCollisionCounters()

void Garfield::MediumMagboltz::ResetCollisionCounters

(

)

Reset the collision counters.

Definition at line 966 of file MediumMagboltz.cc.

                                            {
  m_nCollisions.fill(0);
  m_nCollisionsDetailed.assign(m_nTerms, 0);
  m_nPenning = 0;
  m_nPhotonCollisions.fill(0);
}

RunMagboltz()

void Garfield::MediumMagboltz::RunMagboltz	(	const double	e,
		const double	b,
		const double	btheta,
		const int	ncoll,
		bool	verbose,
		double &	vx,
		double &	vy,
		double &	vz,
		double &	dl,
		double &	dt,
		double &	alpha,
		double &	eta,
		double &	lor,
		double &	vxerr,
		double &	vyerr,
		double &	vzerr,
		double &	dlerr,
		double &	dterr,
		double &	alphaerr,
		double &	etaerr,
		double &	lorerr,
		double &	alphatof,
		std::array< double, 6 > &	difftens )

Run Magboltz for a given electric field, magnetic field and angle.

Parameters

[in]	e	electric field
[in]	b	magnetic field
[in]	btheta	angle between electric and magnetic field
[in]	ncoll	number of collisions (in multiples of 107) to be simulated
[in]	verbose	verbosity flag
[out]	vx,vy,vz	drift velocity vector
[out]	dl,dt	diffusion cofficients
[out]	alpha	Townsend cofficient
[out]	eta	attachment cofficient
[out]	lor	Lorentz angle
[out]	vxerr,vyerr,vzerr	errors on drift velocity
[out]	dlerr,dterr	errors on diffusion coefficients
[out]	alphaerr,etaerr	errors on Townsend/attachment coefficients
[out]	lorerr	error on Lorentz angle
[out]	alphatof	effective Townsend coefficient calculated using time-of-flight method
[out]	difftens	components of the diffusion tensor (zz, xx, yy, xz, yz, xy)

Definition at line 2661 of file MediumMagboltz.cc.

                                   {
  // Initialize the values.
  vx = vy = vz = 0.;
  dl = dt = 0.;
  alpha = eta = alphatof = 0.;
  lor = 0.;
  vxerr = vyerr = vzerr = 0.;
  dlerr = dterr = 0.;
  alphaerr = etaerr = 0.;
  lorerr = 0.;
 
  // Set the input parameters in the Magboltz common blocks.
  Magboltz::inpt_.nGas = m_nComponents;
  Magboltz::inpt_.nAniso = 2;
  if (m_autoEnergyLimit) {
    Magboltz::inpt_.efinal = 0.;
  } else {
    Magboltz::inpt_.efinal = std::min(m_eMax, m_eHigh);
  }
  Magboltz::inpt_.tempc = m_temperature - ZeroCelsius;
  Magboltz::inpt_.torr = m_pressure;
  Magboltz::inpt_.ipen = 0;
  Magboltz::setp_.nmax = ncoll;
 
  Magboltz::thrm_.ithrm = m_useGasMotion ? 1 : 0;
 
  Magboltz::setp_.efield = emag;
  // Convert from Tesla to kGauss.
  Magboltz::bfld_.bmag = bmag * 10.;
  // Convert from radians to degree.
  Magboltz::bfld_.btheta = btheta * RadToDegree;
 
  // Set the gas composition in Magboltz.
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    const int ng = GetGasNumberMagboltz(m_gas[i]);
    if (ng <= 0) {
      std::cerr << m_className << "::RunMagboltz:\n    Gas " << m_gas[i]
                << " does not have a gas number in Magboltz.\n";
      return;
    }
    Magboltz::gasn_.ngasn[i] = ng;
    Magboltz::ratio_.frac[i] = 100 * m_fraction[i];
  }
 
  // Run Magboltz.
  Magboltz::magboltz_();
 
  // Velocities. Convert to cm / ns.
  vx = Magboltz::vel_.wx * 1.e-9;
  vxerr = Magboltz::velerr_.dwx;
  vy = Magboltz::vel_.wy * 1.e-9;
  vyerr = Magboltz::velerr_.dwy;
  vz = Magboltz::vel_.wz * 1.e-9;
  vzerr = Magboltz::velerr_.dwz;
 
  // Calculate the Lorentz angle.
  const double vt = sqrt(vx * vx + vy * vy);
  const double v2 = (vx * vx + vy * vy + vz * vz);
  lor = atan2(vt, vz);
  if (vt > 0. && v2 > 0. && fabs(lor) > 0.) {
    const double dvx = vx * vxerr;
    const double dvy = vy * vyerr;
    const double dvz = vz * vzerr;
    const double a = vz / vt;
    lorerr = sqrt(a * a * (vx * vx * dvx * dvx + vy * vy * dvy * dvy) +
                  vt * vt * dvz * dvz) /
             v2;
    lorerr /= lor;
  }
 
  // Diffusion coefficients.
  dt = sqrt(0.2 * 0.5 * (Magboltz::diflab_.difxx + Magboltz::diflab_.difyy) /
            vz) *
       1.e-4;
  dterr = 0.5 * sqrt(Magboltz::diferl_.dfter * Magboltz::diferl_.dfter +
                     vzerr * vzerr);
  dl = sqrt(0.2 * Magboltz::diflab_.difzz / vz) * 1.e-4;
  dlerr = 0.5 * sqrt(Magboltz::diferl_.dfler * Magboltz::diferl_.dfler +
                     vzerr * vzerr);
  // Diffusion tensor.
  difftens[0] = 0.2e-4 * Magboltz::diflab_.difzz / vz;
  difftens[1] = 0.2e-4 * Magboltz::diflab_.difxx / vz;
  difftens[2] = 0.2e-4 * Magboltz::diflab_.difyy / vz;
  difftens[3] = 0.2e-4 * Magboltz::diflab_.difxz / vz;
  difftens[4] = 0.2e-4 * Magboltz::diflab_.difyz / vz;
  difftens[5] = 0.2e-4 * Magboltz::diflab_.difxy / vz;
  // Townsend and attachment coefficients.
  alpha = Magboltz::ctowns_.alpha;
  alphaerr = Magboltz::ctwner_.alper;
  eta = Magboltz::ctowns_.att;
  etaerr = Magboltz::ctwner_.atter;
 
  // Calculate effective Townsend SST coefficient from TOF results. 
  if (fabs(Magboltz::tofout_.tofdl) > 0.) {
    const double wrzn = 1.e5 * Magboltz::tofout_.tofwr;
    const double fc1 = 0.5 * wrzn / Magboltz::tofout_.tofdl;
    const double fc2 = (Magboltz::tofout_.ralpha - 
                        Magboltz::tofout_.rattof) * 1.e12 / 
                       Magboltz::tofout_.tofdl;
    alphatof = fc1 - sqrt(fc1 * fc1 - fc2);
  }
  // Print the results.
  if (!(m_debug || verbose)) return;
  std::cout << m_className << "::RunMagboltz: Results:\n";
  printf("    Drift velocity along E:   %12.8f cm/ns +/- %5.2f%%\n", vz, vzerr);
  printf("    Drift velocity along Bt:  %12.8f cm/ns +/- %5.2f%%\n", vx, vxerr);
  printf("    Drift velocity along ExB: %12.8f cm/ns +/- %5.2f%%\n", vy, vyerr);
  printf("    Lorentz angle:            %12.3f degree\n", lor * RadToDegree);
  printf("    Longitudinal diffusion:   %12.8f cm1/2 +/- %5.2f%%\n", dl, dlerr);
  printf("    Transverse diffusion:     %12.8f cm1/2 +/- %5.2f%%\n", dt, dterr);
  printf("    Townsend coefficient:     %12.4f cm-1  +/- %5.2f%%\n", alpha,
         alphaerr);
  printf("    Attachment coefficient:   %12.4f cm-1  +/- %5.2f%%\n", eta,
         etaerr);
  if (alphatof > 0.) {
    printf("    TOF effective Townsend:   %12.4f cm-1 (alpha - eta)\n",
           alphatof);
  }
}

Referenced by GenerateGasTable().

SetExcitationScaling()

void Garfield::MediumMagboltz::SetExcitationScaling	(	const double	r,
		std::string	gasname )

Multiply all excitation cross-sections by a uniform scaling factor.

Definition at line 384 of file MediumMagboltz.cc.

                                                                           {
  if (r <= 0.) {
    std::cerr << m_className << "::SetExcitationScaling: Incorrect value.\n";
    return;
  }
 
  // Get the "standard" name of this gas.
  gasname = GetGasName(gasname);
  if (gasname.empty()) {
    std::cerr << m_className << "::SetExcitationScaling: Unknown gas name.\n";
    return;
  }
 
  // Look for this gas in the present gas mixture.
  bool found = false;
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    if (m_gas[i] == gasname) {
      m_scaleExc[i] = r;
      found = true;
      break;
    }
  }
 
  if (!found) {
    std::cerr << m_className << "::SetExcitationScaling:\n"
              << "    Specified gas (" << gasname
              << ") is not part of the present gas mixture.\n";
    return;
  }
 
  // Force re-calculation of the collision rate table.
  m_isChanged = true;
}

SetMaxElectronEnergy()

bool Garfield::MediumMagboltz::SetMaxElectronEnergy

(

const double

e

)

Set the highest electron energy to be included in the table of scattering rates.

Definition at line 143 of file MediumMagboltz.cc.

                                                        {
  if (e <= Small) {
    std::cerr << m_className << "::SetMaxElectronEnergy: Invalid energy.\n";
    return false;
  }
  m_eMax = e;
 
  std::lock_guard<std::mutex> guard(m_mutex);
  // Determine the energy interval size.
  m_eStep = std::min(m_eMax, m_eHigh) / Magboltz::nEnergySteps;
  m_eStepInv = 1. / m_eStep;
 
  // Force recalculation of the scattering rates table.
  m_isChanged = true;
 
  return true;
}

Referenced by ElectronCollision(), and GetElectronCollisionRate().

SetMaxPhotonEnergy()

bool Garfield::MediumMagboltz::SetMaxPhotonEnergy

(

const double

e

)

Set the highest photon energy to be included in the table of scattering rates.

Definition at line 161 of file MediumMagboltz.cc.

                                                      {
  if (e <= Small) {
    std::cerr << m_className << "::SetMaxPhotonEnergy: Invalid energy.\n";
    return false;
  }
  m_eFinalGamma = e;
 
  // Determine the energy interval size.
  m_eStepGamma = m_eFinalGamma / nEnergyStepsGamma;
 
  // Force recalculation of the scattering rates table.
  m_isChanged = true;
 
  return true;
}

Referenced by GetPhotonCollision(), and GetPhotonCollisionRate().

SetSplittingFunctionFlat()

void Garfield::MediumMagboltz::SetSplittingFunctionFlat

(

)

Sample the secondary electron energy from a flat distribution.

Definition at line 200 of file MediumMagboltz.cc.

                                              {
  m_useOpalBeaty = false;
  m_useGreenSawada = false;
}

SetSplittingFunctionGreenSawada()

void Garfield::MediumMagboltz::SetSplittingFunctionGreenSawada

(

)

Sample the secondary electron energy according to the Green-Sawada model.

Definition at line 182 of file MediumMagboltz.cc.

                                                     {
  m_useOpalBeaty = false;
  m_useGreenSawada = true;
  if (m_isChanged) return;
 
  bool allset = true;
  for (unsigned int i = 0; i < m_nComponents; ++i) {
    if (!m_hasGreenSawada[i]) {
      if (allset) {
        std::cout << m_className << "::SetSplittingFunctionGreenSawada:\n";
        allset = false;
      }
      std::cout << "    Fit parameters for " << m_gas[i] << " not available.\n"
                << "    Using Opal-Beaty formula instead.\n";
    }
  }
}

SetSplittingFunctionOpalBeaty()

void Garfield::MediumMagboltz::SetSplittingFunctionOpalBeaty

(

)

Sample the secondary electron energy according to the Opal-Beaty model.

Definition at line 177 of file MediumMagboltz.cc.

                                                   {
  m_useOpalBeaty = true;
  m_useGreenSawada = false;
}

---

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

• MediumMagboltz.hh
• MediumMagboltz.cc