Geant4 interface. More...

Classes
class	CheckAuxDetHit

class	CheckMCParticle

class	CheckSimEnergyDeposit

class	larg4Main

class	MCTruthEventActionService

class	UpdateDaughterInformation

class	ParticleListActionService

class	AuxDetSD

class	LArG4DetectorService

class	SimEnergyDepositSD

class	IonAndScint

struct	ISCalcData

class	ISCalc

class	ISCalcAna

class	ISCalcCorrelated

class	ISCalcNESTLAr

class	ISCalcSeparate

class	ISTPC

class	AllPhysicsLists

class	AuxDetReadout

class	AuxDetReadoutGeometry

class	TConfigurablePhysicsList

class	CustomPhysicsFactoryBase

class	CustomPhysicsFactory

class	CustomPhysicsFactory< OpticalPhysics >

class	CustomPhysicsTable

class	FastOpticalPhysics

class	G4BadIdeaAction

class	IonizationAndScintillation

class	IonizationAndScintillationAction

class	ISCalculation

class	ISCalculationCorrelated

class	ISCalculationNEST

class	ISCalculationSeparate

class	LArG4
	Runs Geant4 simulation and propagation of electrons and photons to readout. More...

class	LArG4Ana

struct	TPCID_t
	Simple structure holding a TPC and cryostat number. More...

class	G4PVPlacementWithID
	A G4PVPlacement with an additional identificator. More...

class	LArVoxelReadout
	Transports energy depositions from GEANT4 to TPC channels. More...

class	LArVoxelReadoutGeometry

class	MaterialPropertyLoader
	Stores material properties and sends them to GEANT4 geometry. More...

class	MuNuclearSplittingProcess

class	MuNuclearSplittingProcessXSecBias

class	OpBoundaryProcessSimple
	Discrete process for reflection and diffusion at optical interfaces. More...

class	OpDetLookup

class	OpDetPhotonTable

class	OpDetReadoutGeometry

class	OpDetSensitiveDetector

class	OpFastScintillation

class	OpParamAction

class	TransparentPlaneAction

class	SimpleWireplaneAction

class	OverlaidWireplanesAction

class	OpParamSD

class	OpticalPhysics

class	ParticleListAction

class	ModularPhysicsList

class	VisualizationAction

Typedefs
using	ConfigurablePhysicsList = TConfigurablePhysicsList< G4VModularPhysicsList >

typedef G4PVPlacementWithID < TPCID_t >	G4PVPlacementInTPC
	A physical volume with a TPC ID. More...

using	PhysicsList = TConfigurablePhysicsList< ModularPhysicsList >

Enumerations
enum	OpBoundaryProcessSimpleStatus { Undefined, NotAtBoundary, SimpleAbsorbedNoRefl, SimpleAbsorbed, SimpleDiffuse, SimpleSpecular, StepTooSmall, NoRINDEX }

Functions
	fKeepEMShowerDaughters (p.get< bool >("keepEMShowerDaughters", true))

	fNotStoredPhysics (p.get< std::vector< std::string >>("NotStoredPhysics",{}))

	fkeepOnlyPrimaryFullTraj (p.get< bool >("keepOnlyPrimaryFullTrajectories", false))

	fSparsifyTrajectories (p.get< bool >("SparsifyTrajectories", false))

	fSparsifyMargin (p.get< double >("SparsifyMargin", 0.015))

	fKeepTransportation (p.get< bool >("KeepTransportation", false))

	fKeepSecondToLast (p.get< bool >("KeepSecondToLast", false))

	fEngine (art::ServiceHandle< rndm::NuRandomService >() ->createEngine(*this,"HepJamesRandom","ISCalcAlg", pset,"SeedISCalcAlg"))

	fSparsifyTrajectories (pset.get< bool >("SparsifyTrajectories", false))

	fEngine (art::ServiceHandle< rndm::NuRandomService >{}->createEngine(*this,"HepJamesRandom","propagation", pset,"PropagationSeed"))

double	finter_d (double x, double par)

double	LandauPlusExpoFinal (double x, double par)

double	finter_r (double x, double par)

double	model_close (double x, double par)

double	model_far (double x, double par)

double	fast_acos (double x)

constexpr double	acos_table (const double x)

template<typename TReal >
constexpr double	dist (const TReal x, const TReal y, const unsigned int dimension)

template<typename TVector3 >
constexpr double	dist (const std::array< double, 3 > x, const TVector3 y, const unsigned int dimension, const unsigned int start)

	if (diff<=tolerance) return true

	if (diff< std::fmax(std::fabs(a), std::fabs(b))*tolerance) return true

	if (diff > tolerance) return true

	if (diff > std::fmax(std::fabs(a), std::fabs(b))*tolerance) return true

Variables
	Instances

static CustomPhysicsTable *	TheCustomPhysicsTable

static IonizationAndScintillation *	gInstance = 0

	fDetProp {art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob()}

OpDetLookup *	TheOpDetLookup

OpDetPhotonTable *	TheOpDetPhotonTable

static const size_t	acos_bins = 2000000

template<typename TReal >
static constexpr	bool

return	false

Detailed Description

Geant4 interface.

Framework includes.

Author: bjpjo.nosp@m.nes@.nosp@m.mit.e.nosp@m.du; selig.nosp@m.man@.nosp@m.nevis.nosp@m..col.nosp@m.umbia.nosp@m..edu

This a module. It has the following functions:

Initialize Geant4 physics, detector geometry, and other processing.
Accept sim::MCTruth objects from the MC branch of the FMWK Event structure.
Pass the primary particles to the Geant4 simulation to calculate "truth" information for the detector response.
Pass the truth information to the DetSim branch of the FMWK event.

Geant4 interface

Author: selig.nosp@m.man@.nosp@m.nevis.nosp@m..col.nosp@m.umbia.nosp@m..edu VisualizationAction.cc 19-Mar-2002 Bill Seligman

Use UserAction to implement the standard visualization control for a typical Geant4 job. Everything in this class comes from the Geant4 examples; the only difference is that it's put into an UserAction class.

25-Feb-2009 WGS: Revised for FMWK/LArSoft

Typedef Documentation

using larg4::ConfigurablePhysicsList = typedef TConfigurablePhysicsList<G4VModularPhysicsList>

Definition at line 47 of file ConfigurablePhysicsList.hh.

typedef G4PVPlacementWithID<TPCID_t> larg4::G4PVPlacementInTPC

A physical volume with a TPC ID.

Definition at line 130 of file LArVoxelReadout.h.

using larg4::PhysicsList = typedef TConfigurablePhysicsList<ModularPhysicsList>

This type alias is what defines the name "larg4::PhysicsList" in any class that includes this header.

Definition at line 89 of file PhysicsList.h.

Enumeration Type Documentation

enum larg4::OpBoundaryProcessSimpleStatus

Enumerator
Undefined
NotAtBoundary
SimpleAbsorbedNoRefl
SimpleAbsorbed
SimpleDiffuse
SimpleSpecular
StepTooSmall
NoRINDEX

Definition at line 63 of file OpBoundaryProcessSimple.hh.

                                      {
     Undefined,
     NotAtBoundary,
     SimpleAbsorbedNoRefl,
     SimpleAbsorbed,
     SimpleDiffuse,
     SimpleSpecular,
     StepTooSmall,
     NoRINDEX
   };

Function Documentation

constexpr double larg4::acos_table ( const double x )

template<typename TReal >

constexpr double larg4::dist	(	const TReal *	x,
		const TReal *	y,
		const unsigned int	dimension
	)

inline

Definition at line 563 of file OpFastScintillation.hh.

   {
     double d = 0.;
     for (unsigned int p = 0; p < dimension; ++p) {
       d += (*(x + p) - *(y + p)) * (*(x + p) - *(y + p));
     }
     return std::sqrt(d);
   }

template<typename TVector3 >

constexpr double larg4::dist	(	const std::array< double, 3 >	x,
		const TVector3	y,
		const unsigned int	dimension,
		const unsigned int	start
	)

inline

Definition at line 574 of file OpFastScintillation.hh.

   {
     double d = 0.;
     for (unsigned int p = start; p < dimension; ++p) {
       d += (x[p] - y[p]) * (x[p] - y[p]);
     }
     return std::sqrt(d);
   }

double larg4::fast_acos ( double x )

Definition at line 2196 of file OpFastScintillation.cxx.

   {
     double negate = double(x < 0);
     x = std::abs(x);
     x -= double(x > 1.0) * (x - 1.0); // <- equivalent to min(1.0,x), but faster
     double ret = -0.0187293;
     ret = ret * x;
     ret = ret + 0.0742610;
     ret = ret * x;
     ret = ret - 0.2121144;
     ret = ret * x;
     ret = ret + 1.5707288;
     ret = ret * std::sqrt(1.0 - x);
     ret = ret - 2. * negate * ret;
     return negate * 3.14159265358979 + ret;
   }

larg4::fEngine ( art::ServiceHandle< rndm::NuRandomService >() ->createEngine *,"","",,"" SeedISCalcAlg )

larg4::fEngine ( art::ServiceHandle< rndm::NuRandomService >{}->createEngine *,"","",,"" PropagationSeed )

double larg4::finter_d	(	double *	x,
		double *	par
	)

Definition at line 1868 of file OpFastScintillation.cxx.

   {
     double y1 = par[2] * TMath::Landau(x[0], par[0], par[1]);
     double y2 = TMath::Exp(par[3] + x[0] * par[4]);
     return TMath::Abs(y1 - y2);
   }

double larg4::finter_r	(	double *	x,
		double *	par
	)

Definition at line 1892 of file OpFastScintillation.cxx.

   {
     double y1 = par[2] * TMath::Landau(x[0], par[0], par[1]);
     double y2 = par[5] * TMath::Landau(x[0], par[3], par[4]);
     return TMath::Abs(y1 - y2);
   }

larg4::fKeepEMShowerDaughters ( p.get< bool > "keepEMShowerDaughters", true )

larg4::fkeepOnlyPrimaryFullTraj ( p.get< bool > "keepOnlyPrimaryFullTrajectories", false )

larg4::fKeepSecondToLast ( p.get< bool > "KeepSecondToLast", false )

Definition at line 79 of file ParticleListAction.cc.

   {
     // -- D.R. If a custom list of not storable physics is provided, use it, otherwise
     //    use the default list. This preserves the behavior of the keepEmShowerDaughters
     //    parameter
     bool customNotStored = not fNotStoredPhysics.empty();
     if (!fKeepEMShowerDaughters) {
       // -- Don't keep all processes
       if (!customNotStored) // -- Don't keep but haven't provided a list
       {                     // -- default list of not stored physics
         fNotStoredPhysics = {"conv",
                              "LowEnConversion",
                              "Pair",
                              "compt",
                              "Compt",
                              "Brem",
                              "phot",
                              "Photo",
                              "Ion",
                              "annihil"};
       }
 
       std::stringstream sstored;
       sstored << "The full tracking information will not be stored for particles"
               << " resulting from the following processes: \n{ ";
       for (auto const& i : fNotStoredPhysics) {
         sstored << "\"" << i << "\" ";
         fNotStoredCounterUMap.emplace(i, 0); // -- initialize counter
       }
       mf::LogInfo("ParticleListActionService") << sstored.str() << "}\n";
     }
     else { // -- Keep all processes
       mf::LogInfo("ParticleListActionService")
         << "Storing full tracking information for all processes. \n";
       if (customNotStored) // -- custom list will be ignored
       {
         mf::LogWarning("StoredPhysics")
           << "NotStoredPhysics provided, but will be ignored."
           << " To use NotStoredPhysics, set keepEMShowerDaughters to false";
       }
     }
 
     // -- sparsify info
     if (fSparsifyTrajectories)
       mf::LogInfo("ParticleListActionService")
         << "Trajectory sparsification enabled with SparsifyMargin : " << fSparsifyMargin << "\n";
   }

larg4::fKeepTransportation ( p.get< bool > "KeepTransportation", false )

larg4::fNotStoredPhysics ( p.get< std::vector< std::string >> "NotStoredPhysics",{} )

larg4::fSparsifyMargin ( p.get< double > "SparsifyMargin", 0.015 )

larg4::fSparsifyTrajectories ( p.get< bool > "SparsifyTrajectories", false )

larg4::fSparsifyTrajectories ( pset.get< bool > "SparsifyTrajectories", false )

larg4::if ( diff<= tolerance )

larg4::if ( )

Definition at line 5 of file fix_log_debug_art211.pl.

                  {
     print "\n";
     print "USAGE: fix_log_debug_art211.pl <input-file>\n";
     print "\n";
     exit 1;
 }

larg4::if	(	diff	,
		tolerance
	)

larg4::if	(	diff	,
		std::fmax(std::fabs(a), std::fabs(b))*	tolerance
	)

double larg4::LandauPlusExpoFinal	(	double *	x,
		double *	par
	)

Definition at line 1876 of file OpFastScintillation.cxx.

   {
     // par0 = joining point
     // par1 = Landau MPV
     // par2 = Landau widt
     // par3 = normalization
     // par4 = Expo cte
     // par5 = Expo tau
     double y1 = par[3] * TMath::Landau(x[0], par[1], par[2]);
     double y2 = TMath::Exp(par[4] + x[0] * par[5]);
     if (x[0] > par[0]) y1 = 0.;
     if (x[0] < par[0]) y2 = 0.;
     return (y1 + y2);
   }

double larg4::model_close	(	double *	x,
		double *	par
	)

Definition at line 1900 of file OpFastScintillation.cxx.

   {
     // par0 = joining point
     // par1 = Landau MPV
     // par2 = Landau width
     // par3 = normalization
     // par4 = Expo cte
     // par5 = Expo tau
     // par6 = t_min
     double y1 = par[3] * TMath::Landau(x[0], par[1], par[2]);
     double y2 = TMath::Exp(par[4] + x[0] * par[5]);
     if (x[0] <= par[6] || x[0] > par[0]) y1 = 0.;
     if (x[0] < par[0]) y2 = 0.;
     return (y1 + y2);
   }

double larg4::model_far	(	double *	x,
		double *	par
	)

Definition at line 1917 of file OpFastScintillation.cxx.

   {
     // par1 = Landau MPV
     // par2 = Landau width
     // par3 = normalization
     // par0 = t_min
     double y = par[3] * TMath::Landau(x[0], par[1], par[2]);
     if (x[0] <= par[0]) y = 0.;
     return y;
   }

Variable Documentation

const size_t larg4::acos_bins = 2000000

static

Definition at line 464 of file OpFastScintillation.hh.

template<typename TReal >

static constexpr larg4::bool

inlinestatic

Initial value:

{

TReal diff = std::fabs(a - b)

a

process_name gaushit a

Definition: decode_signalprocess_icarus.fcl:37

Definition at line 588 of file OpFastScintillation.hh.

return larg4::false

Definition at line 592 of file OpFastScintillation.hh.

larg4::fDetProp {art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob()}

Definition at line 420 of file LArG4_module.cc.

IonizationAndScintillation* larg4::gInstance = 0

static

Definition at line 31 of file IonizationAndScintillation.cxx.

larg4::Instances

Initial value:

{
        pset.get<string>("Instances", "LArG4DetectorServicevolTPCActive"),
      }

Definition at line 93 of file IonAndScint_module.cc.

CustomPhysicsTable* larg4::TheCustomPhysicsTable

static

Definition at line 15 of file CustomPhysicsTable.cxx.

OpDetLookup* larg4::TheOpDetLookup

Definition at line 24 of file OpDetLookup.cxx.

OpDetPhotonTable* larg4::TheOpDetPhotonTable

Definition at line 20 of file OpDetPhotonTable.cxx.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation