G4ReflectionFactory Class Reference

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. More...

#include <G4ReflectionFactory.hh>

Public Member Functions
	~G4ReflectionFactory ()
	G4ReflectionFactory (const G4ReflectionFactory &)=delete
G4ReflectionFactory &	operator= (const G4ReflectionFactory &)=delete
G4PhysicalVolumesPair	Place (const G4Transform3D &transform3D, const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, G4bool isMany, G4int copyNo, G4bool surfCheck=false)
G4PhysicalVolumesPair	Replicate (const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4int nofReplicas, G4double width, G4double offset=0.)
G4PhysicalVolumesPair	Divide (const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4int nofDivisions, G4double width, G4double offset)
G4PhysicalVolumesPair	Divide (const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4int nofDivisions, G4double offset)
G4PhysicalVolumesPair	Divide (const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, G4double width, G4double offset)
void	SetVerboseLevel (G4int verboseLevel)
G4int	GetVerboseLevel () const
void	SetVolumesNameExtension (const G4String &nameExtension)
const G4String &	GetVolumesNameExtension () const
void	SetScalePrecision (G4double scaleValue)
G4double	GetScalePrecision () const
G4LogicalVolume *	GetConstituentLV (G4LogicalVolume *reflLV) const
G4LogicalVolume *	GetReflectedLV (G4LogicalVolume *lv) const
G4bool	IsConstituent (G4LogicalVolume *lv) const
G4bool	IsReflected (G4LogicalVolume *lv) const
const G4ReflectedVolumesMap &	GetReflectedVolumesMap () const
void	Clean ()

Static Public Member Functions
static G4ReflectionFactory *	Instance ()

Detailed Description

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)

Definition at line 89 of file G4ReflectionFactory.hh.

Constructor & Destructor Documentation

~G4ReflectionFactory()

G4ReflectionFactory::~G4ReflectionFactory

(

)

Destructor.

Definition at line 92 of file G4ReflectionFactory.cc.

{
  delete fInstance;
}

G4ReflectionFactory()

G4ReflectionFactory::G4ReflectionFactory ( const G4ReflectionFactory & )

delete

Copy constructor and assignment operator not allowed.

Referenced by G4ReflectionFactory(), Instance(), and operator=().

Member Function Documentation

Clean()

void G4ReflectionFactory::Clean

(

)

Clears the maps of constituent and reflected volumes.

Note

To be used exclusively when volumes are removed from the stores.

Definition at line 743 of file G4ReflectionFactory.cc.

{
  fConstituentLVMap.clear();
  fReflectedLVMap.clear();
}

Divide() [1/3]

G4PhysicalVolumesPair G4ReflectionFactory::Divide	(	const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		EAxis	axis,
		G4double	width,
		G4double	offset )

Definition at line 319 of file G4ReflectionFactory.cc.

{
  // 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.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "Divide " << name << " lv " << LV << " " 
           << LV->GetName() << G4endl;
  }  
 
  G4VPVDivisionFactory* divisionFactory = GetPVDivisionFactory();
 
  G4VPhysicalVolume* pv1 = divisionFactory
    -> CreatePVDivision(name, LV, motherLV, axis, width, offset);
 
  G4VPhysicalVolume* pv2 = nullptr;
  if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
  {
    // if mother was reflected
    // reflect the LV and replicate it in reflected mother
    
    pv2 = divisionFactory->CreatePVDivision(name, ReflectLV(LV), reflMotherLV, 
                                            axis, width, offset); 
  }
    
  return {pv1, pv2};            
}         

Divide() [2/3]

G4PhysicalVolumesPair G4ReflectionFactory::Divide	(	const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		EAxis	axis,
		G4int	nofDivisions,
		G4double	offset )

Definition at line 278 of file G4ReflectionFactory.cc.

{
  // 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.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "Divide " << name << " lv " << LV << " " 
           << LV->GetName() << G4endl;
  }  
 
  G4VPVDivisionFactory* divisionFactory = GetPVDivisionFactory();
 
  G4VPhysicalVolume* pv1 = divisionFactory
      ->CreatePVDivision(name, LV, motherLV, axis, nofDivisions, offset);
 
  G4VPhysicalVolume* pv2 = nullptr;
  if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
  {
    // if mother was reflected
    // reflect the LV and replicate it in reflected mother
    
    pv2 = divisionFactory->CreatePVDivision(name, ReflectLV(LV), reflMotherLV, 
                                            axis, nofDivisions, offset); 
  }
    
  return {pv1, pv2};            
}         

Divide() [3/3]

G4PhysicalVolumesPair G4ReflectionFactory::Divide	(	const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		EAxis	axis,
		G4int	nofDivisions,
		G4double	width,
		G4double	offset )

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.

Definition at line 236 of file G4ReflectionFactory.cc.

{
  // 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.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "Divide " << name << " lv " << LV << " " 
           << LV->GetName() << G4endl;
  }  
 
  G4VPVDivisionFactory* divisionFactory = GetPVDivisionFactory();
 
  G4VPhysicalVolume* pv1 = divisionFactory
      ->CreatePVDivision(name, LV, motherLV, axis, nofDivisions, width, offset);
 
  G4VPhysicalVolume* pv2 = nullptr;
  if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
  {
    // if mother was reflected
    // reflect the LV and replicate it in reflected mother
    
    pv2 = divisionFactory->CreatePVDivision(name, ReflectLV(LV), reflMotherLV, 
                                            axis, nofDivisions, width, offset); 
  }
    
  return {pv1, pv2};            
}         

Referenced by G4GDMLReadStructure::DivisionvolRead().

GetConstituentLV()

G4LogicalVolume * G4ReflectionFactory::GetConstituentLV

(

G4LogicalVolume *

reflLV

)

const

Returns the consituent volume of the given reflected volume. Returns nullptr if the given reflected volume was not found.

Definition at line 672 of file G4ReflectionFactory.cc.

{              
  // Returns the consituent volume of the given reflected volume,
  // nullptr if the given reflected volume was not found.
  // ---
 
  auto it = fReflectedLVMap.find(reflLV);
 
  if (it == fReflectedLVMap.cend()) { return nullptr; }
 
  return (*it).second;
}        

GetReflectedLV()

G4LogicalVolume * G4ReflectionFactory::GetReflectedLV

(

G4LogicalVolume *

lv

)

const

Returns the reflected volume of the given consituent volume. Returns nullptr if the given volume was not reflected.

Definition at line 688 of file G4ReflectionFactory.cc.

{              
  // Returns the reflected volume of the given consituent volume,
  // nullptr if the given volume was not reflected.
  // ---
 
  auto it = fConstituentLVMap.find(lv);
 
  if (it == fConstituentLVMap.cend()) { return nullptr; }
 
  return (*it).second;
}        

Referenced by Divide(), Divide(), Divide(), Place(), and Replicate().

GetReflectedVolumesMap()

const G4ReflectedVolumesMap & G4ReflectionFactory::GetReflectedVolumesMap

(

)

const

Returns a handle to the internal map of volumes which have been reflected, after that placement or replication is performed.

Definition at line 736 of file G4ReflectionFactory.cc.

{
  return fReflectedLVMap;
}

GetScalePrecision()

G4double G4ReflectionFactory::GetScalePrecision

(

)

const

Definition at line 830 of file G4ReflectionFactory.cc.

{
  return fScalePrecision;
}

GetVerboseLevel()

G4int G4ReflectionFactory::GetVerboseLevel

(

)

const

Definition at line 844 of file G4ReflectionFactory.cc.

{
  return fVerboseLevel;
}

GetVolumesNameExtension()

const G4String & G4ReflectionFactory::GetVolumesNameExtension

(

)

const

Definition at line 858 of file G4ReflectionFactory.cc.

{
  return fNameExtension;
}

Instance()

G4ReflectionFactory * G4ReflectionFactory::Instance ( )

static

Gets pointer to the instance of the singleton.

Definition at line 67 of file G4ReflectionFactory.cc.

{
  // Static singleton access method.
  // ---
 
  if (fInstance == nullptr) { fInstance = new G4ReflectionFactory(); }
 
  return fInstance;
}  

Referenced by G4tgbVolume::ConstructG4PhysVol(), G3Division::CreatePVReplica(), G4GDMLReadStructure::DivisionvolRead(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVPlacement(), G3toG4BuildPVTree(), G4GDMLWriteStructure::G4GDMLWriteStructure(), G4tgbVolumeMgr::G4tgbVolumeMgr(), G4GDMLReadStructure::PhysvolRead(), and G4GDMLReadStructure::ReplicaRead().

IsConstituent()

G4bool G4ReflectionFactory::IsConstituent

(

G4LogicalVolume *

lv

)

const

Returns true if the given volume has been already reflected (i.e. is in the map of constituent volumes).

Definition at line 703 of file G4ReflectionFactory.cc.

{
  // Returns true if the given volume has been already reflected
  // (is in the map of constituent volumes).
  // ---
 
  return (fConstituentLVMap.find(lv) != fConstituentLVMap.cend());
}  

IsReflected()

G4bool G4ReflectionFactory::IsReflected

(

G4LogicalVolume *

lv

)

const

Returns true if the given volume is a reflected volume (i.e. is in the map reflected volumes).

Definition at line 714 of file G4ReflectionFactory.cc.

{
  // Returns true if the given volume is a reflected volume
  // (is in the map reflected  volumes).
  // ---
 
  return (fReflectedLVMap.find(lv) != fReflectedLVMap.cend());
}  

Referenced by G4tgbGeometryDumper::DumpPhysVol(), and G4tgbGeometryDumper::DumpPVPlacement().

operator=()

G4ReflectionFactory & G4ReflectionFactory::operator= ( const G4ReflectionFactory & )

delete

Place()

G4PhysicalVolumesPair G4ReflectionFactory::Place	(	const G4Transform3D &	transform3D,
		const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		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 places it in the given mother.

Parameters

[in]	transform3D	The transformation in 3D space that can contain a reflection.
[in]	pName	The volume name.
[in]	LV	Pointer to the logical volume to be placed.
[in]	motherLV	Pointer to the logical volume of the mother.
[in]	isMany	Not used.
[in]	copyNo	The optional custom copy number.
[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.

Definition at line 104 of file G4ReflectionFactory.cc.

{
  // 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 nullptr if mother LV was not reflected.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "Place " << name << " lv " << LV << " "
           << LV->GetName() << G4endl;
  }  
 
  // decompose transformation
  G4Scale3D     scale;
  G4Rotate3D    rotation;
  G4Translate3D translation;
 
  transform3D.getDecomposition(scale, rotation, translation);
  G4Transform3D pureTransform3D = translation * rotation;
  
  //PrintTransform(transform3D);
  //PrintTransform(pureTransform3D);
 
  // check that scale correspond to fScale
  //
  CheckScale(scale);
  
  //
  // reflection IS NOT present in transform3D 
  //
 
  if (!IsReflection(scale))
  {
    if (fVerboseLevel>0) { G4cout << "Scale positive" << G4endl; }
 
    G4VPhysicalVolume* pv1
      =  new G4PVPlacement(pureTransform3D, LV, name,
                           motherLV, isMany, copyNo, surfCheck);
 
    G4VPhysicalVolume* pv2 = nullptr;
    if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
    {
      // if mother was reflected
      // reflect this LV and place it in reflected mother
      
      pv2 = new G4PVPlacement(fScale * (pureTransform3D * fScale.inverse()),
                              ReflectLV(LV, surfCheck), name, reflMotherLV,
                              isMany, copyNo, surfCheck);
    }
    
    return {pv1, pv2};            
  }         
           
  //
  //  reflection IS present in transform3D
  //
 
  if (fVerboseLevel>0) { G4cout << "scale negative" << G4endl; }
 
  G4VPhysicalVolume* pv1
    = new G4PVPlacement(pureTransform3D, ReflectLV(LV, surfCheck), name,
                        motherLV, isMany, copyNo, surfCheck);
 
  G4VPhysicalVolume* pv2 = nullptr;
  if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
  {
 
    // if mother was reflected
    // place the refLV consituent in reflected mother
 
    pv2 =  new G4PVPlacement(fScale * (pureTransform3D * fScale.inverse()),
                             LV, name, reflMotherLV, isMany, copyNo, surfCheck);
  }
 
  return {pv1, pv2};
}           

Referenced by G4tgbVolume::ConstructG4PhysVol(), G3Division::CreatePVReplica(), G3toG4BuildPVTree(), and G4GDMLReadStructure::PhysvolRead().

Replicate()

G4PhysicalVolumesPair G4ReflectionFactory::Replicate	(	const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		EAxis	axis,
		G4int	nofReplicas,
		G4double	width,
		G4double	offset = 0. )

Creates a replica in the given mother.

Parameters

[in]	name	The volume name.
[in]	LV	Pointer to the logical volume to be replicated.
[in]	motherLV	Pointer to the logical volume of the mother.
[in]	axis	The axis along which do the replication.
[in]	nofReplicas	The number of copies to replicate.
[in]	width	The witdh of the replicated object along the axis.
[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.

Definition at line 197 of file G4ReflectionFactory.cc.

{
  // Creates replica in given mother.
  // The result is a pair of physical volumes;
  // the second physical volume is a replica in a reflected mother
  // - or nullptr if mother LV was not reflected.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "Replicate " << name << " lv " << LV << " " 
           << LV->GetName() << G4endl;
  }  
 
  G4VPhysicalVolume* pv1
    = new G4PVReplica(name, LV, motherLV, axis, nofReplicas, width, offset);
 
  G4VPhysicalVolume* pv2 = nullptr;
  if (G4LogicalVolume* reflMotherLV = GetReflectedLV(motherLV))
  {
    // if mother was reflected
    // reflect the LV and replicate it in reflected mother
    
    pv2 = new G4PVReplica(name, ReflectLV(LV), reflMotherLV, 
                          axis, nofReplicas, width, offset); 
  }
    
  return {pv1, pv2};            
}         

Referenced by G3Division::CreatePVReplica(), and G4GDMLReadStructure::ReplicaRead().

SetScalePrecision()

void G4ReflectionFactory::SetScalePrecision

(

G4double

scaleValue

)

Sets/gets the precision factor for the scale consistency check. The default value is set to 10*kCarTolerance.

Definition at line 823 of file G4ReflectionFactory.cc.

{
  fScalePrecision = scaleValue;
}

Referenced by G4tgbVolumeMgr::G4tgbVolumeMgr().

SetVerboseLevel()

void G4ReflectionFactory::SetVerboseLevel

(

G4int

verboseLevel

)

Verbosity control.

Definition at line 837 of file G4ReflectionFactory.cc.

{
  fVerboseLevel = verboseLevel;
}

SetVolumesNameExtension()

void G4ReflectionFactory::SetVolumesNameExtension

(

const G4String &

nameExtension

)

Sets/returns the name extension for the reflected solids and logical volumes.

Definition at line 851 of file G4ReflectionFactory.cc.

{
  fNameExtension = nameExtension;
}

---

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

• G4ReflectionFactory.hh
• G4ReflectionFactory.cc