lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.4.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2025-06-26 09:17:29 +02:00
parent 20a218bbe1
commit a499fb82e9
1941 changed files with 203285 additions and 95593 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/volumes/include/G4ReflectionFactory.hh
+171 -92
View File
@@ -28,38 +28,18 @@
// Class description:
//
// Class providing functions for volumes placements with a general
// transfomation that can contain reflection.
// transfomation that can contain a reflection.
// Reflection is then applied to a solid: a new G4ReflectedSolid
// instance is created and is placed with a transformation containing
// pure rotation and translation only.
// The pair of constituent and reflected logical volumes is
// considered as a generalized logical volume that is addressed
// considered as a generalised logical volume that is addressed
// by user specifying the constituent logical volume.
//
// Decomposition of a general transformation that can include reflection
// in a "reflection-free" transformation:
//
// x(inM') = TG*x(inM) TG - general transformation
// = T*(R*x(inM)) T - "reflection-free" transformation
// = T* x(inReflM)
//
// Daughters transformation:
// When a volume V containing daughter D with transformation TD
// is placed in mother M with a general tranformation TGV,
// the TGV is decomposed. New reflected volume ReflV containing
// a new daughter ReflD with reflected transformation ReflTD is created:
//
// x(inV) = TD * x(inD);
// x(inM) = TGV * x(inV)
// = TV * R * x(inV)
// = TV * R * TD * x(inD)
// = TV * R*TD*R-1 * R*x(inD)
// = TV * ReflTD * x(inReflD)
// Author: Ivana Hrivnacova (Ivana.Hrivnacova@cern.ch), 16.10.2001
// Author: Ivana Hrivnacova (IN2P3/IJCLab Orsay), 16 October 2001
// --------------------------------------------------------------------
#ifndef G4_REFLECTION_FACTORY_HH
#define G4_REFLECTION_FACTORY_HH
#define G4_REFLECTION_FACTORY_HH 1
#include "G4Types.hh"
#include "G4Transform3D.hh"
@@ -75,18 +55,78 @@ class G4VPVDivisionFactory;
using G4PhysicalVolumesPair = std::pair<G4VPhysicalVolume*, G4VPhysicalVolume*>;
using G4ReflectedVolumesMap = std::map<G4LogicalVolume*, G4LogicalVolume*,
std::less<G4LogicalVolume*> >;
/**
* @brief G4ReflectionFactory provides functions for volumes placements with
* a general transfomation that can contain a reflection.
* Reflection is then applied to a solid: a new G4ReflectedSolid instance is
* created and is placed with a transformation containing pure rotation and
* translation only.
* The pair of constituent and reflected logical volumes is considered as a
* generalised logical volume that is addressed by user specifying the
* constituent logical volume.
*
* Decomposition of a general transformation that can include reflection
* in a "reflection-free" transformation:
*
* x(inM') = TG*x(inM) TG - general transformation
* = T*(R*x(inM)) T - "reflection-free" transformation
* = T* x(inReflM)
*
* Daughters transformation:
* When a volume V containing daughter D with transformation TD
* is placed in mother M with a general tranformation TGV,
* the TGV is decomposed. New reflected volume ReflV containing
* a new daughter ReflD with reflected transformation ReflTD is created:
*
* x(inV) = TD * x(inD);
* x(inM) = TGV * x(inV)
* = TV * R * x(inV)
* = TV * R * TD * x(inD)
* = TV * R*TD*R-1 * R*x(inD)
* = TV * ReflTD * x(inReflD)
*/
class G4ReflectionFactory
{
using LogicalVolumesMapIterator = G4ReflectedVolumesMap::const_iterator;
public:
virtual ~G4ReflectionFactory();
// Virtual destructor.
/**
* Destructor.
*/
~G4ReflectionFactory();
/**
* Copy constructor and assignment operator not allowed.
*/
G4ReflectionFactory(const G4ReflectionFactory&) = delete;
G4ReflectionFactory& operator=(const G4ReflectionFactory&) = delete;
/**
* Gets pointer to the instance of the singleton.
*/
static G4ReflectionFactory* Instance();
// Gets pointer to the instance of the singleton.
/**
* Evaluates the passed transformation; if it contains reflection
* it performs its decomposition, creates new reflected solid and
* logical volume (or retrieves them from a map if the reflected
* objects were already created), transforms the daughters (if present)
* and places it in the given mother.
* @param[in] transform3D The transformation in 3D space that can contain
* a reflection.
* @param[in] pName The volume name.
* @param[in] LV Pointer to the logical volume to be placed.
* @param[in] motherLV Pointer to the logical volume of the mother.
* @param[in] isMany Not used.
* @param[in] copyNo The optional custom copy number.
* @param[in] surfCheck Boolean flag, if true activates check for overlaps
* with existing volumes (false by default).
* @returns A pair of physical volumes; the second physical volume
* is a placement in a reflected mother or nullptr if mother
* logical volume was not reflected.
*/
G4PhysicalVolumesPair Place(const G4Transform3D& transform3D,
const G4String& name,
G4LogicalVolume* LV,
@@ -94,15 +134,20 @@ class G4ReflectionFactory
G4bool isMany,
G4int copyNo,
G4bool surfCheck = false);
// Evaluates the passed transformation; if it contains reflection
// it performs its decomposition, creates new reflected solid and
// logical volume (or retrieves them from a map if the reflected
// objects were already created), transforms the daughters (if present)
// and place it in the given mother.
// The result is a pair of physical volumes;
// the second physical volume is a placement in a reflected mother
// or 0 if mother LV was not reflected.
/**
* Creates a replica in the given mother.
* @param[in] name The volume name.
* @param[in] LV Pointer to the logical volume to be replicated.
* @param[in] motherLV Pointer to the logical volume of the mother.
* @param[in] axis The axis along which do the replication.
* @param[in] nofReplicas The number of copies to replicate.
* @param[in] width The witdh of the replicated object along the axis.
* @param[in] offset The optional offset distance from mother's border.
* @returns A pair of physical volumes; the second physical volume is
* a replica in a reflected mother or nullptr if the mother
* logical volume was not reflected.
*/
G4PhysicalVolumesPair Replicate(const G4String& name,
G4LogicalVolume* LV,
G4LogicalVolume* motherLV,
@@ -110,11 +155,14 @@ class G4ReflectionFactory
G4int nofReplicas,
G4double width,
G4double offset = 0.);
// Creates replica in the given mother.
// The result is a pair of physical volumes;
// the second physical volume is a replica in a reflected mother
// or 0 if mother LV was not reflected.
/**
* Methods to create a division in the given mother, along with the
* possible specifications for creating a division.
* @returns A pair of physical volumes; the second physical volume is
* a division in a reflected mother or nullptr if mother
* logical volume was not reflected.
*/
G4PhysicalVolumesPair Divide(const G4String& name,
G4LogicalVolume* LV,
G4LogicalVolume* motherLV,
@@ -134,103 +182,134 @@ class G4ReflectionFactory
EAxis axis,
G4double width,
G4double offset);
// Creates division in the given mother.
// The result is a pair of physical volumes;
// the second physical volume is a division in a reflected mother
// or nullptr if mother LV was not reflected.
void SetVerboseLevel(G4int verboseLevel);
/**
* Verbosity control.
*/
void SetVerboseLevel(G4int verboseLevel);
G4int GetVerboseLevel() const;
// Sets/gets verbosity level.
void SetVolumesNameExtension(const G4String& nameExtension);
/**
* Sets/returns the name extension for the reflected solids and
* logical volumes.
*/
void SetVolumesNameExtension(const G4String& nameExtension);
const G4String& GetVolumesNameExtension() const;
// Returns the name extension for the reflected solids
// and logical volumes.
void SetScalePrecision(G4double scaleValue);
/**
* Sets/gets the precision factor for the scale consistency check.
* The default value is set to 10*kCarTolerance.
*/
void SetScalePrecision(G4double scaleValue);
G4double GetScalePrecision() const;
// Sets/gets precision factor for the scale consistency check
// The default value is set to 10*kCarTolerance.
/**
* Returns the consituent volume of the given reflected volume.
* Returns nullptr if the given reflected volume was not found.
*/
G4LogicalVolume* GetConstituentLV(G4LogicalVolume* reflLV) const;
// Returns the consituent volume of the given reflected volume,
// nullptr if the given reflected volume was not found.
/**
* Returns the reflected volume of the given consituent volume.
* Returns nullptr if the given volume was not reflected.
*/
G4LogicalVolume* GetReflectedLV(G4LogicalVolume* lv) const;
// Returns the reflected volume of the given consituent volume,
// nullptr if the given volume was not reflected.
/**
* Returns true if the given volume has been already reflected
* (i.e. is in the map of constituent volumes).
*/
G4bool IsConstituent(G4LogicalVolume* lv) const;
// Returns true if the given volume has been already reflected
// (is in the map of constituent volumes).
/**
* Returns true if the given volume is a reflected volume
* (i.e. is in the map reflected volumes).
*/
G4bool IsReflected(G4LogicalVolume* lv) const;
// Returns true if the given volume is a reflected volume
// (is in the map reflected volumes).
/**
* Returns a handle to the internal map of volumes which have
* been reflected, after that placement or replication is performed.
*/
const G4ReflectedVolumesMap& GetReflectedVolumesMap() const;
// Returns a handle to the internal map of volumes which have
// been reflected, after that placement or replication is performed.
/**
* Clears the maps of constituent and reflected volumes.
* @note To be used exclusively when volumes are removed from the stores.
*/
void Clean();
// Clear maps of constituent and reflected volumes.
// To be used exclusively when volumes are removed from the stores.
G4ReflectionFactory(const G4ReflectionFactory&) = delete;
G4ReflectionFactory& operator=(const G4ReflectionFactory&) = delete;
// Disabled copy constructor and assignment operator.
protected:
G4ReflectionFactory();
// Protected singleton constructor.
private:
/**
* Private singleton constructor.
*/
G4ReflectionFactory();
/**
* Gets/creates the reflected solid and logical volume
* and copies + transforms logical volumes of daughters.
*/
G4LogicalVolume* ReflectLV(G4LogicalVolume* LV, G4bool surfCheck = false);
// Gets/creates the reflected solid and logical volume
// and copies + transforms LV daughters.
/**
* Creates the reflected solid and logical volume
* and adds the logical volumes pair in the maps.
*/
G4LogicalVolume* CreateReflectedLV(G4LogicalVolume* LV);
// Creates the reflected solid and logical volume
// and add the logical volumes pair in the maps.
/**
* Reflects daughters recursively.
*/
void ReflectDaughters(G4LogicalVolume* LV,
G4LogicalVolume* refLV, G4bool surfCheck = false);
// Reflects daughters recursively.
/**
* Copies and transforms daughter of G4PVPlacement type of
* a constituent volume into a reflected volume.
*/
void ReflectPVPlacement(G4VPhysicalVolume* PV,
G4LogicalVolume* refLV, G4bool surfCheck = false);
// Copies and transforms daughter of PVPlacement type of
// a constituent volume into a reflected volume.
/**
* Copies and transforms daughter of G4PVReplica type of
* a constituent volume into a reflected volume.
*/
void ReflectPVReplica(G4VPhysicalVolume* PV, G4LogicalVolume* refLV);
// Copies and transforms daughter of PVReplica type of
// a constituent volume into a reflected volume.
/**
* Copies and transforms daughter of G4PVDivision type of
* a constituent volume into a reflected volume.
*/
void ReflectPVDivision(G4VPhysicalVolume* PV, G4LogicalVolume* refLV);
// Copies and transforms daughter of PVDivision type of
// a constituent volume into a reflected volume.
/**
* Not yet implemented.
* Should copy and transform daughter of G4PVParameterised type of
* a constituent volume into a reflected volume.
*/
void ReflectPVParameterised(G4VPhysicalVolume* PV,
G4LogicalVolume* refLV, G4bool surfChk = false);
// Not implemented yet.
// Should copy and transform daughter of PVReplica type of
// a constituent volume into a reflected volume.
/**
* Returns true if the scale is negative, false otherwise.
*/
G4bool IsReflection(const G4Scale3D& scale) const;
// Returns true if the scale is negative, false otherwise.
/**
* Checks if scale correspond to fScale, if not gives exception.
*/
void CheckScale(const G4Scale3D& scale) const;
// Checks if scale correspond to fScale, if not gives exception.
/**
* Checks if the division factory is instanciated, if not gives exception.
*/
G4VPVDivisionFactory* GetPVDivisionFactory() const;
// Checks if the division factory is instanciated,
// if not gives exception.
void PrintConstituentLVMap();
// Temporary - for debugging purpose.
/**
* Dump method, for debugging purpose.
*/
void PrintConstituentLVMap() const;
private: