G4ReflectionFactory Class Reference

#include <G4ReflectionFactory.hh>

Public Member Functions
virtual	~G4ReflectionFactory ()
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 ()
	G4ReflectionFactory (const G4ReflectionFactory &)=delete
G4ReflectionFactory &	operator= (const G4ReflectionFactory &)=delete

Static Public Member Functions
static G4ReflectionFactory *	Instance ()

Protected Member Functions
	G4ReflectionFactory ()

Detailed Description

Definition at line 78 of file G4ReflectionFactory.hh.

Constructor & Destructor Documentation

~G4ReflectionFactory()

G4ReflectionFactory::~G4ReflectionFactory ( )

virtual

Definition at line 92 of file G4ReflectionFactory.cc.

{
  delete fInstance;
}

G4ReflectionFactory() [1/2]

G4ReflectionFactory::G4ReflectionFactory ( const G4ReflectionFactory & )

delete

G4ReflectionFactory() [2/2]

G4ReflectionFactory::G4ReflectionFactory ( )

protected

Definition at line 79 of file G4ReflectionFactory.cc.

  : fNameExtension(fDefaultNameExtension)    
{
  // Protected singleton constructor.
  // ---
 
  fScalePrecision = 10.
                  * G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fInstance = this;
}

Referenced by Instance().

Member Function Documentation

Clean()

void G4ReflectionFactory::Clean

(

)

Definition at line 751 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 321 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 280 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 )

Definition at line 238 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

Definition at line 680 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.end()) return nullptr;
 
  return (*it).second;
}        

Referenced by G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetReflectedLV()

G4LogicalVolume * G4ReflectionFactory::GetReflectedLV

(

G4LogicalVolume *

lv

)

const

Definition at line 696 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.end()) return nullptr;
 
  return (*it).second;
}        

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

GetReflectedVolumesMap()

const G4ReflectedVolumesMap & G4ReflectionFactory::GetReflectedVolumesMap

(

)

const

Definition at line 744 of file G4ReflectionFactory.cc.

{
  return fReflectedLVMap;
}

GetScalePrecision()

G4double G4ReflectionFactory::GetScalePrecision

(

)

const

Definition at line 834 of file G4ReflectionFactory.cc.

{
  return fScalePrecision;
}

GetVerboseLevel()

G4int G4ReflectionFactory::GetVerboseLevel

(

)

const

Definition at line 848 of file G4ReflectionFactory.cc.

{
  return fVerboseLevel;
}

GetVolumesNameExtension()

const G4String & G4ReflectionFactory::GetVolumesNameExtension

(

)

const

Definition at line 862 of file G4ReflectionFactory.cc.

{
  return fNameExtension;
}

Instance()

G4ReflectionFactory * G4ReflectionFactory::Instance ( )

static

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

Definition at line 711 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.end());
}  

IsReflected()

G4bool G4ReflectionFactory::IsReflected

(

G4LogicalVolume *

lv

)

const

Definition at line 722 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.end());
}  

Referenced by G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVPlacement(), G4GDMLWriteStructure::PhysvolWrite(), and G4GDMLWriteStructure::TraverseVolumeTree().

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 )

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

Definition at line 199 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

)

Definition at line 827 of file G4ReflectionFactory.cc.

{
  fScalePrecision = scaleValue;
}

Referenced by G4tgbVolumeMgr::G4tgbVolumeMgr().

SetVerboseLevel()

void G4ReflectionFactory::SetVerboseLevel

(

G4int

verboseLevel

)

Definition at line 841 of file G4ReflectionFactory.cc.

{
  fVerboseLevel = verboseLevel;
}

SetVolumesNameExtension()

void G4ReflectionFactory::SetVolumesNameExtension

(

const G4String &

nameExtension

)

Definition at line 855 of file G4ReflectionFactory.cc.

{
  fNameExtension = nameExtension;
}

---

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

• G4ReflectionFactory.hh
• G4ReflectionFactory.cc