allpix

Helper class to hold support layers for a detector model. More…

Namespaces

Name
allpix::physicslists Handler namespace for implementing additional PhysicsLists included in AllPix2 but not in the G4PhysListFactory.
allpix::tableau

Classes

	Name
class	allpix::Allpix Provides the link between the core framework and the executable.
class	allpix::ConfigManager Manager responsible for loading and providing access to the main configuration.
class	allpix::ConfigReader Reader of configuration files.
class	allpix::Configuration Generic configuration object storing keys.
class	allpix::ConfigurationError Base class for all configurations exceptions in the framework.
class	allpix::ConfigFileUnavailableError Notifies of a missing configuration file.
class	allpix::InvalidKeyError Indicates a problem converting the value of a configuration key to the value it should represent.
class	allpix::MissingKeyError Informs of a missing key that should have been defined.
class	allpix::KeyValueParseError Indicates an error while parsing a key / value pair.
class	allpix::ConfigParseError Indicates an error while parsing a configuration file.
class	allpix::InvalidValueError Indicates an error with the contents of value.
class	allpix::InvalidCombinationError Indicates an error with a combination of configuration keys.
class	allpix::ModuleIdentifierNotFoundError Indicates that a given ModuleIdentifier was not found in the module identifier list.
class	allpix::ModuleIdentifierAlreadyAddedError Indicates that a given ModuleIdentifier is already in the module identifier list.
class	allpix::OptionParser Option parser responsible for parsing and caching command line arguments.
class	allpix::Detector Instantiation of a detector model in the world.
class	allpix::DetectorAssembly Helper class to hold information on the detector assembly.
class	allpix::HybridAssembly
class	allpix::MonolithicAssembly
class	allpix::DetectorField Field instance of a detector.
class	allpix::DetectorModel Base of all detector models.
class	allpix::InvalidDetectorError Indicates an error with finding a detector by name.
class	allpix::InvalidDetectorModelError Indicates an error that the detector model is not found.
class	allpix::DetectorExistsError Indicates an attempt to add a detector that is already registered before.
class	allpix::PassiveElementExistsError Indicates an attempt to add a detector that is already registered before.
class	allpix::DetectorModelExistsError Indicates an attempt to add a detector model that is already registered before.
class	allpix::DetectorInvalidNameError Indicates an attempt to add a detector with an invalid name.
class	allpix::GeometryManager Manager responsible for the global geometry.
class	allpix::HexagonalPixelDetectorModel Detector model with hexagonal pixel grid.
class	allpix::PixelDetectorModel Model of a generic pixel detector. This model is further extended by specialized pixel detector models.
class	allpix::RadialStripDetectorModel Model of a radial strip detector. This is a model where the silicon sensor is a trapezoid and the strips fan out radially from a focal point.
class	allpix::SupportLayer
struct	allpix::DelegateTypes Container of the different delegate types.
class	allpix::BaseDelegate Base for all delegates.
class	allpix::ModuleDelegate Base for all delegates operating on modules.
class	allpix::StoreDelegate Delegate to store the message in memory for fetching the history.
class	allpix::FilterDelegate Delegate for filtering messages using a function.
class	allpix::FilterAllDelegate Delegate for invoking a filter listening to all messages also getting the name.
class	allpix::SingleBindDelegate Delegate for binding a single message.
class	allpix::VectorBindDelegate Delegate for binding multiple message to a vector.
class	allpix::UnexpectedMessageException Receive of a message that was not expected.
class	allpix::MessageWithoutObjectException Message does not contain an allpix::Object.
class	allpix::MessageNotFoundException Trying to fetch a message that wasn’t delivered.
class	allpix::BaseMessage Type-erased base class for all messages.
class	allpix::Message Generic class for all messages.
class	allpix::Messenger Manager responsible for setting up communication between modules and sending messages between them.
class	allpix::LocalMessenger Responsible for the actual handling of messages between Modules.
class	allpix::Event Holds the data required for running an event.
class	allpix::DynamicLibraryError Notifies of an error with dynamically loading a module.
class	allpix::AmbiguousInstantiationError Raised if ambiguous instantiation of two similar modules occurs.
class	allpix::InvalidModuleStateException Informs that a module is in a state it should never be.
class	allpix::InvalidEventStateException Informs that an event is in a state it should never be.
class	allpix::InvalidModuleActionException Informs that a module executes an action is it not allowed to do in particular state.
class	allpix::ModuleError General exception for modules if something goes wrong.
class	allpix::EndOfRunException Exception for modules to request an end of the event processing.
class	allpix::AbortEventException Exception for modules to request the abortion of the current event.
class	allpix::MissingDependenciesException Exception for modules to request an interrupt because dependencies are missing.
class	allpix::Module Base class for all modules.
class	allpix::SequentialModule A Module that always ensure to execute events in the order of event numbers. It implements buffering out of the box so interested modules can directly use it.
class	allpix::ModuleIdentifier Internal identifier for a module.
class	allpix::ModuleManager Manager responsible for dynamically loading all modules and running their event sequence.
class	allpix::ThreadPool Pool of threads where event tasks can be submitted to.
class	allpix::Exception Base class for all non-internal exceptions in framework.
class	allpix::RuntimeError Errors related to problems occurring at runtime.
class	allpix::LogicError Errors related to logical problems in the code structure.
class	allpix::DefaultLogger Logger of the framework to inform the user of process.
class	allpix::RandomNumberGenerator Wrapper around the STL’s Mersenne Twister.
struct	allpix::type_tag Tag for specific type.
struct	allpix::empty_tag Empty tag.
class	allpix::Units Static class to access units.
class	allpix::CapacitiveTransferModule Module that directly converts propagated charges to charges on a pixel and its neighbours (simulating the cross-coupling in CCPDs) This module is based on the SimpleTransferModule. It does a mapping of the propagated charges to the nearest pixel in the grid and copies this propageted charge, scaled by the cross-coupling matrix, to the neighbouring pixels. The coupling matrix must be provided in the configuration file as a Matrix or as a matrix file. Like the SimpleTransferModule, it only considers propagated charges within a certain distance from the implants and within the pixel grid, charges in the rest of the sensor are ignored. The cross hit created in the neighbouring pixels keeps the history, saving from where the original charge came from.
class	allpix::CorryvreckanWriterModule Module to do function.
class	allpix::CSADigitizerModule Module to simulate digitization of collected charges.
class	allpix::DatabaseWriterModule Module to write object data to PostgreSQL databases.
class	allpix::DefaultDigitizerModule Module to simulate digitization of collected charges.
class	allpix::CosmicsGeneratorActionG4 Generates the particles in every event.
class	allpix::GeneratorActionInitializationMaster Creates and initialize the GPS messenger on master before workers use it.
class	allpix::DepositionCosmicsModule Module to simulate the particles stemming from cosmics rays and showers incident on the setup.
class	allpix::RNGWrapper This class is a wrapper that allows to pass the per-thread random number engine from Geant4 to CRY. The Geant4 engine is seeded by the Allpix Squared framework for every event, and separately per thread, so using this engine in CRY ensures a reproducible and thread-safe simulation.
class	allpix::ActionInitializationG4 Initializer for the tracker and generator actions, required for RunManager.
class	allpix::DepositionGeant4Module Module to simulate the particle beam and generating the charge deposits in the sensor.
class	allpix::GeneratorActionG4 Generates the particles in every event.
class	allpix::SDAndFieldConstruction User hook to construct the sensitive detector and magnetic field.
class	allpix::SensitiveDetectorActionG4 Handles the steps of the particles in all sensitive devices.
class	allpix::SetTrackInfoUserHookG4 Assigns every G4Track a TrackInfoG4 which carries various information, including the custom track id.
class	allpix::StepInfoUserHookG4 Allows access to the info of each Geant4 step.
class	allpix::TrackInfoG4 Allpix implementation of G4VUserTrackInformation to handle unique track IDs and the creation of MCTracks.
class	allpix::TrackInfoManager The TrackInfoManager is a factory for TrackInfoG4 objects and manages MCTracks within AP2.
class	allpix::ActionInitializationPrimaries Initializer for the generator actions, required for RunManager.
class	allpix::DepositionGeneratorModule Module to read primary particles from MC generators.
class	allpix::PrimariesGeneratorAction Generates the particles in every event.
class	allpix::PrimariesReader Interface class to read primary particles from input data in different file formats.
class	allpix::PrimariesReaderGenie Reads particles from an input data file.
class	allpix::PrimariesReaderHepMC Reads particles from an input data file.
class	allpix::DepositionLaserModule Module to do function.
class	allpix::DepositionPointChargeModule Module to deposit charges at predefined positions in the sensor volume.
class	allpix::DepositionReaderModule Module to read pre-computed energy deposits.
class	allpix::Cluster
class	allpix::DetectorHistogrammerModule Module to plot the final digitized pixel data.
class	allpix::DopingProfileReaderModule Module to do function.
class	allpix::DummyModule Module which serves as a demonstrator and wireframe for new modules.
class	allpix::ElectricFieldReaderModule Module to read electric fields from INIT format or apply a linear electric field.
class	allpix::GDMLOutputWriterModule Module to construct a GDML Output of the geometry.
class	allpix::GenericPropagationModule Generic module for Runge-Kutta propagation of charge deposits in the sensitive device.
class	allpix::DetectorConstructionG4 Constructs the Geant4 geometry during Geant4 initialization.
class	allpix::GeometryBuilderGeant4Module Module to construct the Geant4 geometry from the internal geometry.
class	allpix::GeometryConstructionG4 Constructs the Geant4 geometry during Geant4 initialization.
class	allpix::Materials
class	allpix::Parameterization2DG4 Represents a 2D Geant4 parameterization in the X,Y plane.
class	allpix::ParameterisedG4 Class to construct parameterized physical volumes allowing to switch off overlap checking.
class	allpix::BoxModel Model of a rectangular box.
class	allpix::ConeModel
class	allpix::CylinderModel Model of an cylinder with inner and outer radius.
class	allpix::SphereModel Model of an sphere with inner and outer radius.
class	allpix::PassiveMaterialConstructionG4 Constructs passive materials during Geant4 initialization.
class	allpix::PassiveMaterialModel Base of all passive material models.
class	allpix::InducedTransferModule Module to calculate the total induced charge from propagated charge carriers and to assign them to pixels.
class	allpix::LCIOWriterModule Module to write hit data to LCIO file.
class	allpix::MagneticFieldReaderModule Module to define magnetic fields.
class	allpix::ProjectionPropagationModule Module to project created electrons onto the sensor surface including diffusion.
class	allpix::PulseTransferModule Module to combine all charges induced at every pixel.
class	allpix::RCEWriterModule Module to write object data to ROOT trees in RCE format for telescope reconstruction.
class	allpix::ROOTObjectReaderModule Module to read data stored in ROOT file back to allpix messages.
class	allpix::ROOTObjectWriterModule Module to write object data to ROOT trees in file for persistent storage.
class	allpix::SimpleTransferModule Module that directly converts propagated charges to charges on a pixel.
class	allpix::TextWriterModule Module to write object data to simple ASCII text files.
class	allpix::TransientPropagationModule Module for simulation of transient current development using a Runge-Kutta approach.
class	allpix::VisualizationGeant4Module Module that shows visualization of constructed Geant4 geometry.
class	allpix::WeightingPotentialReaderModule Module to read weighting potentials.
class	allpix::DepositedCharge Charge deposit in sensor of detector.
class	allpix::MissingReferenceException Indicates an object that does not contain a reference fetched.
class	allpix::IncompatibleDatatypesException Indicates that two objects are of incompatible data types and cannot be combined.
class	allpix::PulseBadAllocException Indicates that a pulse object could not be allocated.
class	allpix::MCParticle Monte-Carlo particle through the sensor.
class	allpix::MCTrack Monte-Carlo track through the world.
class	allpix::Object Base class for internal objects.
class	allpix::Pixel Pixel in the model with indices, location and size.
class	allpix::PixelCharge Set of charges at a pixel.
class	allpix::PixelHit Pixel triggered in an event after digitization.
class	allpix::PixelPulse Pixel triggered in an event after digitization.
class	allpix::PropagatedCharge Set of charges propagated through the sensor.
class	allpix::Pulse Pulse holding induced charges as a function of time.
class	allpix::SensorCharge Base object for charge deposits and propagated charges in the sensor.
class	allpix::DetrappingModel Charge carrier detrapping time models.
class	allpix::NoDetrapping No detrapping.
class	allpix::ConstantDetrapping Constant detrapping rate of charge carriers.
class	allpix::Detrapping Wrapper class and factory for detrapping models.
class	allpix::ModelError Base class for all model exceptions in the framework.
class	allpix::InvalidModelError Notifies of an invalid model.
class	allpix::ModelUnsuitable Notifies of a model unsuitable for the current simulation.
class	allpix::ImpactIonizationModel Impact ionization models.
class	allpix::NoImpactIonization No multiplication.
class	allpix::Massey Massey model for impact ionization.
class	allpix::MasseyOptimized Massey model for impact ionization with optimized parameters.
class	allpix::VanOverstraetenDeMan van Overstraeten de Man model for impact ionization
class	allpix::VanOverstraetenDeManOptimized van Overstraeten de Man model for impact ionization with optimized parameters
class	allpix::OkutoCrowell Okuto Crowell model for impact ionization.
class	allpix::OkutoCrowellOptimized Okuto Crowell model for impact ionization with optimized parameters.
class	allpix::Bologna Bologna model for impact ionization.
class	allpix::CustomGain Custom gain model for charge carriers.
class	allpix::ImpactIonization Wrapper class and factory for impact ionization models.
class	allpix::MobilityModel Charge carrier mobility models.
class	allpix::JacoboniCanali Jacoboni/Canali mobility model for charge carriers in silicon.
class	allpix::Canali Canali mobility model.
class	allpix::CanaliFast Fast implementation of the Canali mobility model.
class	allpix::Hamburg Hamburg (Klanner-Scharf) parametrization for <100> silicon.
class	allpix::HamburgHighField Hamburg (Klanner-Scharf) high-field parametrization for <100> silicon.
class	allpix::Masetti Masetti mobility model for charge carriers in silicon.
class	allpix::MasettiCanali Combination of the Masetti and Canali mobility models for charge carriers in silicon (“extended Canali model”)
class	allpix::Arora Arora mobility model for charge carriers in silicon.
class	allpix::RuchKino Ruch-Kino mobility model for charge carriers in GaAs:Cr.
class	allpix::Quay
class	allpix::Levinshtein Levinshtein mobility models for charge carriers in gallium nitride.
class	allpix::ConstantMobility Constant mobility of electrons and holes.
class	allpix::Custom Custom mobility model for charge carriers.
class	allpix::Mobility Wrapper class and factory for mobility models.
class	allpix::RecombinationModel Charge carrier recombination models.
class	allpix::None No recombination.
class	allpix::ShockleyReadHall Shockley-Read-Hall recombination of charge carriers in silicon.
class	allpix::Auger Auger recombination of charge carriers in silicon.
class	allpix::ShockleyReadHallAuger Auger recombination of charge carriers in silicon.
class	allpix::ConstantLifetime Simple recombination of charge carriers through constant lifetimes of holes and electrons.
class	allpix::CustomRecombination Custom recombination model for charge carriers.
class	allpix::Recombination Wrapper class and factory for recombination models.
class	allpix::TrappingModel Charge carrier trapping models.
class	allpix::NoTrapping No trapping.
class	allpix::ConstantTrapping Constant trapping rate of charge carriers.
class	allpix::Ljubljana Ljubljana / Kramberger effective trapping model for charge carriers in silicon.
class	allpix::Dortmund Dortmund / Krasel effective trapping model for charge carriers in silicon.
class	allpix::CMSTracker Effective trapping model developed by the CMS Tracker Group.
class	allpix::Mandic Mandic effective trapping model.
class	allpix::CustomTrapping Custom trapping model for charge carriers.
class	allpix::Trapping Wrapper class and factory for trapping models.
class	allpix::FieldData
class	allpix::FieldParser Class to parse Allpix Squared field data from files.
class	allpix::FieldWriter Class to write Allpix Squared field data to files.
class	allpix::G4ExceptionHandler Exception handler for Geant4.
class	allpix::G4LoggingDestination Log message sink for Geant4 output streams.
class	allpix::MTRunManager A custom run manager for Geant4 that can work with external threads and be used concurrently.
class	allpix::RunManager A wrapper around G4RunManager that allows us to use our own event seeds.
class	allpix::SensitiveDetectorAndFieldConstruction Constructs the sensitive detectors and field for each worker.
class	allpix::WorkerRunManager Run manager for Geant4 that can be used by multiple threads where each thread will have its own instance.
class	allpix::LiangBarsky
class	allpix::LineGraph
class	allpix::ThreadedHistogram A re-implementation of ROOT::TThreadedObject.
class	allpix::RungeKutta Class to perform arbitrary Runge-Kutta integration.
class	allpix::TabulatedPow Class to pre-calculate powers of a fixed exponent within a defined range.

Types

	Name
enum class	FieldType { NONE = 0, CONSTANT, LINEAR, GRID, CUSTOM1D, CUSTOM} Type of fields.
enum class	FieldMapping { PIXEL_FULL = 0, PIXEL_FULL_INVERSE, PIXEL_HALF_LEFT, PIXEL_HALF_RIGHT, PIXEL_HALF_TOP, PIXEL_HALF_BOTTOM, PIXEL_QUADRANT_I, PIXEL_QUADRANT_II, PIXEL_QUADRANT_III, PIXEL_QUADRANT_IV, SENSOR} Type of field maps.
enum class	SensorMaterial { SILICON = 1, GALLIUM_ARSENIDE, GERMANIUM, CADMIUM_TELLURIDE, CADMIUM_ZINC_TELLURIDE, DIAMOND, SILICON_CARBIDE, GALLIUM_NITRIDE} Sensor materials.
enum class	Dopant { PHOSPHORUS = 0, ARSENIC} Type of dopant.
enum class	MagneticFieldType { NONE = 0, CONSTANT, CUSTOM} Type of the magnetic field.
enum class uint32_t	MsgFlags { NONE = 0, REQUIRED = (1 « 0), ALLOW_OVERWRITE = (1 « 1), IGNORE_NAME = (1 « 2), UNNAMED_ONLY = (1 « 3)} Flags to change the behaviour of delegates.
enum class	LogLevel { FATAL = 0, STATUS, ERROR, WARNING, INFO, DEBUG, NONE, TRACE, PRNG} Logging detail level.
enum class	LogFormat { SHORT = 0, DEFAULT, LONG} Format of the logger.
enum class	CarrierState { UNKNOWN = 0, MOTION, RECOMBINED, TRAPPED, HALTED} State of the charge carrier.
enum class int8_t	CarrierType { ELECTRON = -1, HOLE = 1} Flags to distinguish between electron and hole charge carriers.
enum class size_t	FieldQuantity { UNKNOWN = 0, SCALAR = 1, VECTOR = 3} Field quantities.
enum class	FileType { UNKNOWN = 0, INIT, APF} Type of file formats.
template <typename T > using std::vector< std::vector< T > >	Matrix
template using std::function< T(const ROOT::Math::XYZPoint &pos)>	FieldFunction Functor returning the field at a given position.
using std::function< ROOT::Math::XYZVector(const ROOT::Math::XYZPoint &)>	MagneticFieldFunction
using std::list< std::shared_ptr< Module > >	ModuleList
template <typename T > using boost::random::normal_distribution< T >	normal_distribution
template <typename T > using boost::random::piecewise_linear_distribution< T >	piecewise_linear_distribution
template <typename T > using boost::random::poisson_distribution< T >	poisson_distribution
template <typename T > using boost::random::uniform_real_distribution< T >	uniform_real_distribution
template <typename T > using boost::random::exponential_distribution< T >	exponential_distribution
using DefaultLogger	Log
using Message< DepositedCharge >	DepositedChargeMessage Typedef for message carrying deposits.
using Message< MCParticle >	MCParticleMessage Typedef for message carrying MC particles.
using Message< MCTrack >	MCTrackMessage Typedef for message carrying MC tracks.
using std::tuple< MCTrack, MCParticle, DepositedCharge, PropagatedCharge, PixelCharge, PixelHit >	OBJECTS Tuple containing all objects.
using Message< PixelCharge >	PixelChargeMessage Typedef for message carrying pixel charges.
using Message< PixelHit >	PixelHitMessage Typedef for message carrying pixel hits.
using Message< PixelPulse >	PixelPulseMessage Typedef for message carrying pixel pulses.
using Message< PropagatedCharge >	PropagatedChargeMessage Typedef for message carrying propagated charges.
template <class T > using std::unique_ptr< ThreadedHistogram< T > >	Histogram

Functions

	Name
std::string	to_string_impl(const std::string & inp, empty_tag ) Conversion handler for strings.
std::string	to_string_impl(const char * inp, empty_tag ) Conversion handler for strings.
std::string	to_string_impl(char * inp, empty_tag ) Conversion handler for strings.
template <typename T > void	flip_vector_components(T & field, bool x, bool y) Helper function to invert the field vector when flipping the field direction at pixel/field boundaries.
void	flip_vector_components< ROOT::Math::XYZVector >(ROOT::Math::XYZVector & vec, bool x, bool y)
void	flip_vector_components< double >(double & , bool , bool )
MsgFlags	**[operator
MsgFlags	operator&(MsgFlags f1, MsgFlags f2) Give the set of flags present in both sets of message flags.
bool	allpix_module_is_unique() Returns the type of the Module it is linked to.
Module *	allpix_module_generator(Configuration & config, Messenger * messenger, GeometryManager * geo_manager) Instantiates an unique module.
Module *	allpix_module_generator(Configuration & config, Messenger * messenger, std::shared_ptr< Detector > detector) Instantiates a detector module.
void	SUPPRESS_STREAM(std::ostream & stream) Suppress a stream from writing any output.
void	RELEASE_STREAM(std::ostream & stream) Release an suppressed stream so it can write again.
std::string	trim(const std::string & str, const std::string & delims =" \t\n\r\v") Trims leading and trailing characters from a string.
template <typename T > T	from_string(std::string str) Converts a string to any supported type.
std::string	from_string_helper(std::string str) Internal helper method for checking and trimming conversions from string.
template <typename T > std::enable_if_t< std::is_arithmetic< T >::value, T >	from_string_impl(std::string str, type_tag< T > ) Conversion handler for all arithmetic types.
template <typename T > std::enable_if_t< std::is_enum< T >::value, T >	from_string_impl(std::string str, type_tag< T > ) Conversion handler for all enum types.
std::string	from_string_impl(std::string str, type_tag< std::string > ) Conversion handler for strings.
std::filesystem::path	from_string_impl(std::string str, type_tag< std::filesystem::path > ) Conversion handler for filesystem paths.
bool	from_string_impl(std::string str, type_tag< bool > ) Conversion handler for booleans.
template <typename T > std::string	to_string(T inp) Converts any type to a string.
template <typename T ,std::enable_if_t< std::is_arithmetic< T >::value, bool > =true> std::string	to_string_impl(T inp, empty_tag ) Conversion handler for all arithmetic types.
template <typename T > std::vector< T >	split(std::string str, const std::string & delims =" \t,") Splits string into substrings at delimiters.
template <typename T > std::string	transform(const std::string & str, const T & op) Transforms a string and returns the transformed string.
std::string	demangle(const char * name, bool keep_allpix =false) Demangle the type to human-readable form if it is mangled.
std::ostream &	operator«(std::ostream & out, const allpix::Object & obj) Overloaded ostream operator for printing of object data.
std::ostream &	operator«(std::ostream & os, const CarrierType type)
CarrierType	invertCarrierType(const CarrierType & type) Invert the type of a charge carrier.
G4ThreeVector	from_string_impl(std::string str, type_tag< G4ThreeVector > ) Enable support to convert string directly to Geant4 3D vector while fetching configuration parameter.
std::string	to_string_impl(const G4ThreeVector & vec, empty_tag ) Enable support to convert Geant4 3D vector to string for storage in the configuration.
G4TwoVector	from_string_impl(std::string str, type_tag< G4TwoVector > ) Enable support to convert string directly to Geant4 2D vector for fetching configuration parameter.
std::string	to_string_impl(const G4TwoVector & vec, empty_tag ) Enable support to convert Geant4 2D vector to string for storage in the configuration.
template <typename T > G4ThreeVector	toG4Vector(const ROOT::Math::DisplacementVector3D< T > & vector) Utility method to convert ROOT 3D vector to Geant4 3D vector.
template <typename T > G4ThreeVector	toG4Vector(const ROOT::Math::PositionVector3D< T > & vector) Utility method to convert ROOT 2D vector to Geant4 2D vector.
template <typename T > ROOT::Math::DisplacementVector3D< T >	from_string_impl(std::string str, type_tag< ROOT::Math::DisplacementVector3D< T » ) Enable support to convert string directly to ROOT 3D displacement vector while fetching configuration parameter.
template <typename T > std::string	to_string_impl(const ROOT::Math::DisplacementVector3D< T > & vec, empty_tag ) Enable support to convert ROOT 3D displacement vector to string for storage in the configuration.
template <typename T > ROOT::Math::DisplacementVector2D< T >	from_string_impl(std::string str, type_tag< ROOT::Math::DisplacementVector2D< T » ) Enable support to convert string directly to ROOT 2D displacement vector while fetching configuration parameter.
template <typename T > std::string	to_string_impl(const ROOT::Math::DisplacementVector2D< T > & vec, empty_tag ) Enable support to convert ROOT 2D displacement vector to string for storage in the configuration.
template <typename T > ROOT::Math::PositionVector3D< T >	from_string_impl(std::string str, type_tag< ROOT::Math::PositionVector3D< T » ) Enable support to convert string directly to ROOT 3D position vector while fetching configuration parameter.
template <typename T > std::string	to_string_impl(const ROOT::Math::PositionVector3D< T > & vec, empty_tag ) Enable support to convert ROOT 3D position vector to string for storage in the configuration.
template <typename T > ROOT::Math::PositionVector2D< T >	from_string_impl(std::string str, type_tag< ROOT::Math::PositionVector2D< T » ) Enable support to convert string directly to ROOT 2D position vector while fetching configuration parameter.
template <typename T > std::string	to_string_impl(const ROOT::Math::PositionVector2D< T > & vec, empty_tag ) Enable support to convert ROOT 2D position vector to string for storage in the configuration.
template <typename T ,typename U > std::ostream &	operator«(std::ostream & os, const ROOT::Math::DisplacementVector3D< T, U > & vec) Overload output stream operator to display ROOT 3D displacement vector.
template <typename T ,typename U > std::ostream &	operator«(std::ostream & os, const ROOT::Math::DisplacementVector2D< T, U > & vec) Overload output stream operator to display ROOT 2D displacement vector.
template <typename T ,typename U > std::ostream &	operator«(std::ostream & os, const ROOT::Math::PositionVector3D< T, U > & vec) Overload output stream operator to display ROOT 3D position vector.
template <typename T ,typename U > std::ostream &	operator«(std::ostream & os, const ROOT::Math::PositionVector2D< T, U > & vec) Overload output stream operator to display ROOT 2D position vector.
template <typename T ,class… ARGS> std::unique_ptr< ThreadedHistogram< T > >	CreateHistogram(ARGS &&… args) Helper method to instantiate new objects of the type ThreadedHistogram.
std::unique_lock< std::mutex >	root_process_lock() Lock for TProcessID simultaneous action.
template <typename T ,int S,int D =3,class… Args> RungeKutta< T, S, D >	make_runge_kutta(const Eigen::Matrix< T, S+2, S > & tableau, Args &&… args) Utility function to create RungeKutta class using template deduction.
void	register_units() Sets the default unit conventions.

Attributes

	Name
thread_local double(T::*)()	RNGWrapper
std::map< SensorMaterial, double >	ionization_energies Ionization / charge creation energy for different materials.
std::map< SensorMaterial, double >	fano_factors Fano factors for different materials.

Detailed Description

Helper class to hold support layers for a detector model.

Copyright: Copyright (c) 2017-2024 CERN and the Allpix Squared authors. This software is distributed under the terms of the MIT License, copied verbatim in the file “LICENSE.md”. In applying this license, CERN does not waive the privileges and immunities granted to it by virtue of its status as an Intergovernmental Organization or submit itself to any jurisdiction. SPDX-License-Identifier: MIT

Types Documentation

enum FieldType

Enumerator	Value	Description
NONE	0	No field is applied.
CONSTANT		Constant field.
LINEAR		Linear field (linearity determined by function)
GRID		Field supplied through a regularized grid.
CUSTOM1D		Custom field function, dependent only on z.
CUSTOM		Custom field function.

Type of fields.

enum FieldMapping

Enumerator	Value	Description
PIXEL_FULL	0	The field map spans the full pixel plane.
PIXEL_FULL_INVERSE		The field map spans the full pixel plane, but pixel centers are at field corners.
PIXEL_HALF_LEFT		The field map spans the left half of the volume and is mirrored along x.
PIXEL_HALF_RIGHT		The field map spans the right half of the volume and is mirrored along x.
PIXEL_HALF_TOP		The field map spans the top half of the volume and is mirrored along y.
PIXEL_HALF_BOTTOM		The field map spans the bottom half of the volume and is mirrored along y.
PIXEL_QUADRANT_I		The field map spans the top right quadrant of the volume and is mirrored to the other quadrants
PIXEL_QUADRANT_II		The field map spans the top left quadrant of the volume and is mirrored to the other quadrants
PIXEL_QUADRANT_III		The field map spans the lower left quadrant of the volume and is mirrored to the other quadrants
PIXEL_QUADRANT_IV		The field map spans the lower right quadrant of the volume and is mirrored to the other quadrants
SENSOR		The field is mapped to the full sensor, starting at the local coordinate origin. The field is mirrored at its edges.

Type of field maps.

enum SensorMaterial

Enumerator	Value	Description
SILICON	1	Silicon.
GALLIUM_ARSENIDE		Gallium Arsenide.
GERMANIUM		Germanium.
CADMIUM_TELLURIDE		Cadmium Telluride.
CADMIUM_ZINC_TELLURIDE		Cadmium Zinc Telluride.
DIAMOND		Diamond.
SILICON_CARBIDE		Silicon Carbide.
GALLIUM_NITRIDE		Gallium Nitride.

Sensor materials.

enum Dopant

Enumerator	Value	Description
PHOSPHORUS	0
ARSENIC

Type of dopant.

enum MagneticFieldType

Enumerator	Value	Description
NONE	0	No magnetic field is simulated.
CONSTANT		Constant magnetic field (mostly for testing)
CUSTOM		Custom magnetic field function.

Type of the magnetic field.

enum MsgFlags

Enumerator	Value	Description
NONE	0	No enabled flags.
REQUIRED	(1 « 0)	Require a message before running a module.
ALLOW_OVERWRITE	(1 « 1)	Allow overwriting a previous message.
IGNORE_NAME	(1 « 2)	Listen to all ignoring message name (equal to * as a input configuration parameter)
UNNAMED_ONLY	(1 « 3)	Listen to all messages without explicit name (equal to ? as configuration parameter)

Flags to change the behaviour of delegates.

All flags are distinct and can be combined using the | (OR) operator. The flags should be passed to the Messenger when registering a filter or when binding either a single or multiple messages. It depends on the delegate which combination of flags is valid.

enum LogLevel

Enumerator	Value	Description
FATAL	0	Fatal problems that terminate the framework (typically exceptions)
STATUS		Only critical progress information.
ERROR		Critical problems that usually lead to fatal errors.
WARNING		Possible issue that could lead to unexpected results.
INFO		General information about processes (should not be called in run function)
DEBUG		Detailed information about physics process.
NONE		Indicates the log level has not been set (cannot be selected by the user)
TRACE		Software debugging information about what part is currently running.
PRNG		Logging level printing every pseudo-random number requested.

Logging detail level.

enum LogFormat

Enumerator	Value	Description
SHORT	0	Only include a single character for the log level, the section header and the message.
DEFAULT		Also include the time and a full logging level description.
LONG		All of the above and also information about the file and line where the message was defined.

Format of the logger.

enum CarrierState

Enumerator	Value	Description
UNKNOWN	0	State of the propagated charge carrier is unknown.
MOTION		The propagated charge carrier is in motion.
RECOMBINED		The propagated charge carrier has recombined with the lattice.
TRAPPED		The propagated charge carrier is trapped temporarily.
HALTED		The carrier has come to a halt because it, for example, has reached the sensor surface or an implant.

State of the charge carrier.

enum CarrierType

Enumerator	Value	Description
ELECTRON	-1
HOLE	1

Flags to distinguish between electron and hole charge carriers.

enum FieldQuantity

Enumerator	Value	Description
UNKNOWN	0	Unknown field quantity.
SCALAR	1	Scalar field, i.e. one entry per field position.
VECTOR	3	Vector field, i.e. three entries per field position.

Field quantities.

enum FileType

Enumerator	Value	Description
UNKNOWN	0	Unknown file format.
INIT		Legacy file format, values stored in plain-text ASCII.
APF		Binary Allpix Squared format serialized using the cereal library.

Type of file formats.

using Matrix

template <typename T >
using allpix::Matrix = typedef std::vector<std::vector<T> >;

using FieldFunction

template <typename T  =ROOT::Math::XYZVector>
using allpix::FieldFunction = typedef std::function<T(const ROOT::Math::XYZPoint& pos)>;

Functor returning the field at a given position.

Parameters:

pos Position in local coordinates at which the field should be evaluated

using MagneticFieldFunction

using allpix::MagneticFieldFunction = typedef std::function<ROOT::Math::XYZVector(const ROOT::Math::XYZPoint&)>;

using ModuleList

using allpix::ModuleList = typedef std::list<std::shared_ptr<Module> >;

using normal_distribution

template <typename T >
using allpix::normal_distribution = typedef boost::random::normal_distribution<T>;

using piecewise_linear_distribution

template <typename T >
using allpix::piecewise_linear_distribution = typedef boost::random::piecewise_linear_distribution<T>;

using poisson_distribution

template <typename T >
using allpix::poisson_distribution = typedef boost::random::poisson_distribution<T>;

using uniform_real_distribution

template <typename T >
using allpix::uniform_real_distribution = typedef boost::random::uniform_real_distribution<T>;

using exponential_distribution

template <typename T >
using allpix::exponential_distribution = typedef boost::random::exponential_distribution<T>;

using Log

using allpix::Log = typedef DefaultLogger;

using DepositedChargeMessage

using allpix::DepositedChargeMessage = typedef Message<DepositedCharge>;

Typedef for message carrying deposits.

using MCParticleMessage

using allpix::MCParticleMessage = typedef Message<MCParticle>;

Typedef for message carrying MC particles.

using MCTrackMessage

using allpix::MCTrackMessage = typedef Message<MCTrack>;

Typedef for message carrying MC tracks.

using OBJECTS

using allpix::OBJECTS = typedef std::tuple<MCTrack, MCParticle, DepositedCharge, PropagatedCharge, PixelCharge, PixelHit>;

Tuple containing all objects.

using PixelChargeMessage

using allpix::PixelChargeMessage = typedef Message<PixelCharge>;

Typedef for message carrying pixel charges.

using PixelHitMessage

using allpix::PixelHitMessage = typedef Message<PixelHit>;

Typedef for message carrying pixel hits.

using PixelPulseMessage

using allpix::PixelPulseMessage = typedef Message<PixelPulse>;

Typedef for message carrying pixel pulses.

using PropagatedChargeMessage

using allpix::PropagatedChargeMessage = typedef Message<PropagatedCharge>;

Typedef for message carrying propagated charges.

using Histogram

template <class T >
using allpix::Histogram = typedef std::unique_ptr<ThreadedHistogram<T> >;

Functions Documentation

function to_string_impl

inline std::string to_string_impl(
    const std::string & inp,
    empty_tag 
)

Conversion handler for strings.

Note: Overloaded for different types of strings

Adds enclosing double quotation marks to properly store strings containing whitespace.

function to_string_impl

inline std::string to_string_impl(
    const char * inp,
    empty_tag 
)

Conversion handler for strings.

Note: Overloaded for different types of strings

Adds enclosing double quotation marks to properly store strings containing whitespace.

function to_string_impl

inline std::string to_string_impl(
    char * inp,
    empty_tag 
)

Conversion handler for strings.

Note: Overloaded for different types of strings

Adds enclosing double quotation marks to properly store strings containing whitespace.

function flip_vector_components

template <typename T >
void flip_vector_components(
    T & field,
    bool x,
    bool y
)

Helper function to invert the field vector when flipping the field direction at pixel/field boundaries.

Parameters:

field Field value, templated to support vector fields and scalar fields
x Boolean to indicate flipping in x-direction
y Boolean to indicate flipping in y-direction

function flip_vector_components< ROOT::Math::XYZVector >

inline void flip_vector_components< ROOT::Math::XYZVector >(
    ROOT::Math::XYZVector & vec,
    bool x,
    bool y
)

function flip_vector_components< double >

inline void flip_vector_components< double >(
    double & ,
    bool ,
    bool 
)

function operator|

inline MsgFlags operator|(
    MsgFlags f1,
    MsgFlags f2
)

Combine two sets of message flags.

Parameters:

f1 First set of flag
f2 Second set of flag

Return: New set of flag representing the combination of the two given sets

function operator&

inline MsgFlags operator&(
    MsgFlags f1,
    MsgFlags f2
)

Give the set of flags present in both sets of message flags.

Parameters:

f1 First flag
f2 Second flag

Return: New flag representing the flags present in both sets of flags

function allpix_module_is_unique

bool allpix_module_is_unique()

Returns the type of the Module it is linked to.

Used by the ModuleManager to determine if it should instantiate a single module or modules per detector instead.

function allpix_module_generator

Module * allpix_module_generator(
    Configuration & config,
    Messenger * messenger,
    GeometryManager * geo_manager
)

Instantiates an unique module.

Parameters:

config Configuration for this module
messenger Pointer to the Messenger (guaranteed to be valid until the module is destructed)
geo_manager Pointer to the global GeometryManager (guaranteed to be valid until the module is destructed)

Return: Instantiation of the module

Internal method for the dynamic loading in the ModuleManager. Forwards the supplied arguments to the constructor and returns an instantiation.

function allpix_module_generator

Module * allpix_module_generator(
    Configuration & config,
    Messenger * messenger,
    std::shared_ptr< Detector > detector
)

Instantiates a detector module.

Parameters:

config Configuration for this module
messenger Pointer to the Messenger (guaranteed to be valid until the module is destructed)
detector Pointer to the Detector object this module is bound to

Return: Instantiation of the module

Internal method for the dynamic loading in the ModuleManager. Forwards the supplied arguments to the constructor and returns an instantiation

function SUPPRESS_STREAM

inline void SUPPRESS_STREAM(
    std::ostream & stream
)

Suppress a stream from writing any output.

Parameters:

stream The stream to suppress

function RELEASE_STREAM

inline void RELEASE_STREAM(
    std::ostream & stream
)

Release an suppressed stream so it can write again.

Parameters:

stream The stream to release

function trim

std::string trim(
    const std::string & str,
    const std::string & delims =" \t\n\r\v"
)

Trims leading and trailing characters from a string.

Parameters:

str String that should be trimmed
delims List of delimiters to trim from the string (defaults to all whitespace)

function from_string

template <typename T >
T from_string(
    std::string str
)

Converts a string to any supported type.

Parameters:

str String to convert

See: String conversions

function from_string_helper

std::string from_string_helper(
    std::string str
)

Internal helper method for checking and trimming conversions from string.

Parameters:

str Input string to check and trim

Return: Trimmed string

function from_string_impl

template <typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T > from_string_impl(
    std::string str,
    type_tag< T > 
)

Conversion handler for all arithmetic types.

Exceptions:

std::invalid_argument If the string cannot be converted to the required arithmetic type

function from_string_impl

template <typename T >
std::enable_if_t< std::is_enum< T >::value, T > from_string_impl(
    std::string str,
    type_tag< T > 
)

Conversion handler for all enum types.

Exceptions:

std::invalid_argument If the string cannot be converted to the required enum type

function from_string_impl

std::string from_string_impl(
    std::string str,
    type_tag< std::string > 
)

Conversion handler for strings.

Exceptions:

std::invalid_argument If no closing quotation mark as last character after an opening quotation mark
std::invalid_argument If string without enclosing quotation marks, but more data after whitespace is found

If a pair of enclosing double quotation marks is found, the whole string within the quotation marks is returned. Otherwise only the first part is read until whitespace is encountered.

function from_string_impl

std::filesystem::path from_string_impl(
    std::string str,
    type_tag< std::filesystem::path > 
)

Conversion handler for filesystem paths.

Exceptions:

std::invalid_argument If no closing quotation mark as last character after an opening quotation mark
std::invalid_argument If string without enclosing quotation marks, but more data after whitespace is found

First parse as normal string and then construct path from it.

function from_string_impl

bool from_string_impl(
    std::string str,
    type_tag< bool > 
)

Conversion handler for booleans.

Exceptions:

std::invalid_argument If the string cannot be converted to a boolean type

Both numerical (0, 1) and textual representations (“false”, “true”) are supported for booleans. No enclosing quotation marks should be used.

function to_string

template <typename T >
std::string to_string(
    T inp
)

Converts any type to a string.

Note: C-strings are not supported due to allocation issues

function to_string_impl

template <typename T ,
std::enable_if_t< std::is_arithmetic< T >::value, bool >  =true>
std::string to_string_impl(
    T inp,
    empty_tag 
)

Conversion handler for all arithmetic types.

Conversion handler for all enum types.

function split

template <typename T >
std::vector< T > split(
    std::string str,
    const std::string & delims =" \t,"
)

Splits string into substrings at delimiters.

Parameters:

str String to split
delims Delimiters to split at (defaults to space, tab and comma)

Return: List of all the substrings with all empty substrings ignored (thus removed)

function transform

template <typename T >
std::string transform(
    const std::string & str,
    const T & op
)

Transforms a string and returns the transformed string.

Parameters:

str String that should be transformed
op Unary operator to act on the string

Return: Transformed string

function demangle

inline std::string demangle(
    const char * name,
    bool keep_allpix =false
)

Demangle the type to human-readable form if it is mangled.

Parameters:

name The possibly mangled name
keep_allpix If true the allpix namespace tag will be kept, otherwise it is removed

function operator«

std::ostream & operator<<(
    std::ostream & out,
    const allpix::Object & obj
)

Overloaded ostream operator for printing of object data.

Parameters:

out Stream to write output to
obj Object to print to stream

Return: Stream where output was written to

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const CarrierType type
)

function invertCarrierType

inline CarrierType invertCarrierType(
    const CarrierType & type
)

Invert the type of a charge carrier.

Parameters:

type Initial type of the charge carrier

Return: Inverted type of the charge carrier

function from_string_impl

inline G4ThreeVector from_string_impl(
    std::string str,
    type_tag< G4ThreeVector > 
)

Enable support to convert string directly to Geant4 3D vector while fetching configuration parameter.

function to_string_impl

inline std::string to_string_impl(
    const G4ThreeVector & vec,
    empty_tag 
)

Enable support to convert Geant4 3D vector to string for storage in the configuration.

function from_string_impl

inline G4TwoVector from_string_impl(
    std::string str,
    type_tag< G4TwoVector > 
)

Enable support to convert string directly to Geant4 2D vector for fetching configuration parameter.

function to_string_impl

inline std::string to_string_impl(
    const G4TwoVector & vec,
    empty_tag 
)

Enable support to convert Geant4 2D vector to string for storage in the configuration.

function toG4Vector

template <typename T >
G4ThreeVector toG4Vector(
    const ROOT::Math::DisplacementVector3D< T > & vector
)

Utility method to convert ROOT 3D vector to Geant4 3D vector.

function toG4Vector

template <typename T >
G4ThreeVector toG4Vector(
    const ROOT::Math::PositionVector3D< T > & vector
)

Utility method to convert ROOT 2D vector to Geant4 2D vector.

function from_string_impl

template <typename T >
inline ROOT::Math::DisplacementVector3D< T > from_string_impl(
    std::string str,
    type_tag< ROOT::Math::DisplacementVector3D< T >> 
)

Enable support to convert string directly to ROOT 3D displacement vector while fetching configuration parameter.

function to_string_impl

template <typename T >
inline std::string to_string_impl(
    const ROOT::Math::DisplacementVector3D< T > & vec,
    empty_tag 
)

Enable support to convert ROOT 3D displacement vector to string for storage in the configuration.

function from_string_impl

template <typename T >
inline ROOT::Math::DisplacementVector2D< T > from_string_impl(
    std::string str,
    type_tag< ROOT::Math::DisplacementVector2D< T >> 
)

Enable support to convert string directly to ROOT 2D displacement vector while fetching configuration parameter.

function to_string_impl

template <typename T >
inline std::string to_string_impl(
    const ROOT::Math::DisplacementVector2D< T > & vec,
    empty_tag 
)

Enable support to convert ROOT 2D displacement vector to string for storage in the configuration.

function from_string_impl

template <typename T >
inline ROOT::Math::PositionVector3D< T > from_string_impl(
    std::string str,
    type_tag< ROOT::Math::PositionVector3D< T >> 
)

Enable support to convert string directly to ROOT 3D position vector while fetching configuration parameter.

function to_string_impl

template <typename T >
inline std::string to_string_impl(
    const ROOT::Math::PositionVector3D< T > & vec,
    empty_tag 
)

Enable support to convert ROOT 3D position vector to string for storage in the configuration.

function from_string_impl

template <typename T >
inline ROOT::Math::PositionVector2D< T > from_string_impl(
    std::string str,
    type_tag< ROOT::Math::PositionVector2D< T >> 
)

Enable support to convert string directly to ROOT 2D position vector while fetching configuration parameter.

function to_string_impl

template <typename T >
inline std::string to_string_impl(
    const ROOT::Math::PositionVector2D< T > & vec,
    empty_tag 
)

Enable support to convert ROOT 2D position vector to string for storage in the configuration.

function operator«

template <typename T ,
typename U >
inline std::ostream & operator<<(
    std::ostream & os,
    const ROOT::Math::DisplacementVector3D< T, U > & vec
)

Overload output stream operator to display ROOT 3D displacement vector.

function operator«

template <typename T ,
typename U >
inline std::ostream & operator<<(
    std::ostream & os,
    const ROOT::Math::DisplacementVector2D< T, U > & vec
)

Overload output stream operator to display ROOT 2D displacement vector.

function operator«

template <typename T ,
typename U >
inline std::ostream & operator<<(
    std::ostream & os,
    const ROOT::Math::PositionVector3D< T, U > & vec
)

Overload output stream operator to display ROOT 3D position vector.

function operator«

template <typename T ,
typename U >
inline std::ostream & operator<<(
    std::ostream & os,
    const ROOT::Math::PositionVector2D< T, U > & vec
)

Overload output stream operator to display ROOT 2D position vector.

function CreateHistogram

template <typename T ,
class... ARGS>
std::unique_ptr< ThreadedHistogram< T > > CreateHistogram(
    ARGS &&... args
)

Helper method to instantiate new objects of the type ThreadedHistogram.

Parameters:

args Arguments passed to histogram class

Return: Unique pointer to newly created object

function root_process_lock

inline std::unique_lock< std::mutex > root_process_lock()

Lock for TProcessID simultaneous action.

function make_runge_kutta

template <typename T ,
int S,
int D =3,
class... Args>
RungeKutta< T, S, D > make_runge_kutta(
    const Eigen::Matrix< T, S+2, S > & tableau,
    Args &&... args
)

Utility function to create RungeKutta class using template deduction.

Parameters:

tableau One of the possible Runge-Kutta tableaus (see allpix::tableau)
args Other forwarded arguments to the RungeKutta::RungeKutta constructor

Return: Instantiation of RungeKutta class with the forwarded arguments

function register_units

static void register_units()

Sets the default unit conventions.

Attributes Documentation

variable RNGWrapper

thread_local double(T::*)() RNGWrapper;

variable ionization_energies

static std::map< SensorMaterial, double > ionization_energies = {
        {SensorMaterial::SILICON, 3.64e-6},
        {SensorMaterial::GALLIUM_ARSENIDE, 4.2e-6},
        {SensorMaterial::GALLIUM_NITRIDE,
         8.33e-6}, 
        {SensorMaterial::GERMANIUM, 2.97e-6},         
        {SensorMaterial::CADMIUM_TELLURIDE, 4.43e-6}, 
        {SensorMaterial::CADMIUM_ZINC_TELLURIDE, 4.6e-6},
        {SensorMaterial::DIAMOND, 13.1e-6},         
        {SensorMaterial::SILICON_CARBIDE, 7.6e-6}};

Ionization / charge creation energy for different materials.

Warning: All values in framework-internal units, here: MeV

variable fano_factors

static std::map< SensorMaterial, double > fano_factors = {
        {SensorMaterial::SILICON, 0.115},
        {SensorMaterial::GALLIUM_ARSENIDE, 0.14},
        {SensorMaterial::GALLIUM_NITRIDE,
         0.07}, 
        {SensorMaterial::GERMANIUM, 0.112},             
        {SensorMaterial::CADMIUM_TELLURIDE, 0.24},      
        {SensorMaterial::CADMIUM_ZINC_TELLURIDE, 0.14}, 
        {SensorMaterial::DIAMOND, 0.382},               
        {SensorMaterial::SILICON_CARBIDE, 0.1}};

Fano factors for different materials.

Updated on 2025-02-27 at 14:14:45 +0000