G4ReflectionFactory Class Reference

#include <G4ReflectionFactory.hh>

Public Member Functions
void	Clean ()
G4PhysicalVolumesPair	Divide (const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, EAxis axis, 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, G4int nofDivisions, G4double width, G4double offset)
	G4ReflectionFactory (const G4ReflectionFactory &)=delete
G4LogicalVolume *	GetConstituentLV (G4LogicalVolume *reflLV) const
G4LogicalVolume *	GetReflectedLV (G4LogicalVolume *lv) const
const G4ReflectedVolumesMap &	GetReflectedVolumesMap () const
G4double	GetScalePrecision () const
G4int	GetVerboseLevel () const
const G4String &	GetVolumesNameExtension () const
G4bool	IsConstituent (G4LogicalVolume *lv) const
G4bool	IsReflected (G4LogicalVolume *lv) const
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.)
void	SetScalePrecision (G4double scaleValue)
void	SetVerboseLevel (G4int verboseLevel)
void	SetVolumesNameExtension (const G4String &nameExtension)
virtual	~G4ReflectionFactory ()

Static Public Member Functions
static G4ReflectionFactory *	Instance ()

Protected Member Functions
	G4ReflectionFactory ()

Private Types
using	LogicalVolumesMapIterator = G4ReflectedVolumesMap::const_iterator

Private Member Functions
void	CheckScale (const G4Scale3D &scale) const
G4LogicalVolume *	CreateReflectedLV (G4LogicalVolume *LV)
G4VPVDivisionFactory *	GetPVDivisionFactory () const
G4bool	IsReflection (const G4Scale3D &scale) const
void	PrintConstituentLVMap ()
void	ReflectDaughters (G4LogicalVolume *LV, G4LogicalVolume *refLV, G4bool surfCheck=false)
G4LogicalVolume *	ReflectLV (G4LogicalVolume *LV, G4bool surfCheck=false)
void	ReflectPVDivision (G4VPhysicalVolume *PV, G4LogicalVolume *refLV)
void	ReflectPVParameterised (G4VPhysicalVolume *PV, G4LogicalVolume *refLV, G4bool surfChk=false)
void	ReflectPVPlacement (G4VPhysicalVolume *PV, G4LogicalVolume *refLV, G4bool surfCheck=false)
void	ReflectPVReplica (G4VPhysicalVolume *PV, G4LogicalVolume *refLV)

Private Attributes
G4ReflectedVolumesMap	fConstituentLVMap
G4String	fNameExtension
G4ReflectedVolumesMap	fReflectedLVMap
G4double	fScalePrecision
G4int	fVerboseLevel = 0

Static Private Attributes
static const G4String	fDefaultNameExtension = "_refl"
static G4ThreadLocal G4ReflectionFactory *	fInstance = nullptr
static const G4Scale3D	fScale = G4ScaleZ3D(-1.0)

Detailed Description

Definition at line 78 of file G4ReflectionFactory.hh.

Member Typedef Documentation

LogicalVolumesMapIterator

using G4ReflectionFactory::LogicalVolumesMapIterator = G4ReflectedVolumesMap::const_iterator

private

Definition at line 80 of file G4ReflectionFactory.hh.

Constructor & Destructor Documentation

~G4ReflectionFactory()

G4ReflectionFactory::~G4ReflectionFactory ( )

virtual

Definition at line 92 of file G4ReflectionFactory.cc.

{
  delete fInstance;
}

References 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;
}

References fInstance, fScalePrecision, G4GeometryTolerance::GetInstance(), and G4GeometryTolerance::GetSurfaceTolerance().

Referenced by Instance().

Member Function Documentation

CheckScale()

void G4ReflectionFactory::CheckScale ( const G4Scale3D &  scale ) const

private

Definition at line 777 of file G4ReflectionFactory.cc.

{
  // Check if scale correspond to fScale,
  // if not give exception.
  // ---
 
  if (!IsReflection(scale)) return;
  
  G4double diff = 0.;
  for (auto i=0; i<4; ++i)
    for (auto j=0; j<4; ++j) 
      diff += std::abs(scale(i,j) - fScale(i,j));  
 
  if (diff > fScalePrecision)
  {
    std::ostringstream message;
    message << "Unexpected scale in input !" << G4endl
            << "        Difference: " << diff;
    G4Exception("G4ReflectionFactory::CheckScale()",
                "GeomVol0002", FatalException, message);
  }
}    

References FatalException, fScale, fScalePrecision, G4endl, G4Exception(), and IsReflection().

Referenced by Place().

Clean()

void G4ReflectionFactory::Clean

(

)

Definition at line 754 of file G4ReflectionFactory.cc.

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

References fConstituentLVMap, and fReflectedLVMap.

CreateReflectedLV()

G4LogicalVolume * G4ReflectionFactory::CreateReflectedLV ( G4LogicalVolume *  LV )

private

Definition at line 398 of file G4ReflectionFactory.cc.

{
  // Creates the reflected solid and logical volume
  // and add the logical volumes pair in the maps.
  // ---
 
  // consistency check
  //
  if (fReflectedLVMap.find(LV) != fReflectedLVMap.end())
  {
    std::ostringstream message;
    message << "Invalid reflection for volume: "
           << LV->GetName() << G4endl
           << "Cannot be applied to a volume already reflected !";
    G4Exception("G4ReflectionFactory::CreateReflectedLV()",
                "GeomVol0002", FatalException, message);
  }        
              
  G4VSolid* refSolid 
    = new G4ReflectedSolid(LV->GetSolid()->GetName() + fNameExtension,
                           LV->GetSolid(), fScale);
      
  G4LogicalVolume* refLV
    = new G4LogicalVolume(refSolid, 
                          LV->GetMaterial(),                 
                          LV->GetName() + fNameExtension,
                          LV->GetFieldManager(),
                          LV->GetSensitiveDetector(),
                          LV->GetUserLimits());
  refLV->SetVisAttributes(LV->GetVisAttributes());  // vis-attributes
  refLV->SetBiasWeight(LV->GetBiasWeight());        // biasing weight
  if (LV->IsRegion())
  {
    refLV->SetRegion(LV->GetRegion());              // set a region in case
  }
 
  fConstituentLVMap[LV] = refLV;
  fReflectedLVMap[refLV] = LV;
 
  return refLV;        
}

References FatalException, fConstituentLVMap, fNameExtension, fReflectedLVMap, fScale, G4endl, G4Exception(), G4LogicalVolume::GetBiasWeight(), G4LogicalVolume::GetFieldManager(), G4LogicalVolume::GetMaterial(), G4LogicalVolume::GetName(), G4VSolid::GetName(), G4LogicalVolume::GetRegion(), G4LogicalVolume::GetSensitiveDetector(), G4LogicalVolume::GetSolid(), G4LogicalVolume::GetUserLimits(), G4LogicalVolume::GetVisAttributes(), G4LogicalVolume::IsRegion(), G4LogicalVolume::SetBiasWeight(), G4LogicalVolume::SetRegion(), and G4LogicalVolume::SetVisAttributes().

Referenced by ReflectLV(), ReflectPVDivision(), ReflectPVPlacement(), and ReflectPVReplica().

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 G4PhysicalVolumesPair(pv1, pv2);            
}         

References G4VPVDivisionFactory::CreatePVDivision(), fVerboseLevel, G4cout, G4endl, G4LogicalVolume::GetName(), GetPVDivisionFactory(), GetReflectedLV(), G4InuclParticleNames::name(), and ReflectLV().

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 G4PhysicalVolumesPair(pv1, pv2);            
}         

References G4VPVDivisionFactory::CreatePVDivision(), fVerboseLevel, G4cout, G4endl, G4LogicalVolume::GetName(), GetPVDivisionFactory(), GetReflectedLV(), G4InuclParticleNames::name(), and ReflectLV().

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 G4PhysicalVolumesPair(pv1, pv2);            
}         

References G4VPVDivisionFactory::CreatePVDivision(), fVerboseLevel, G4cout, G4endl, G4LogicalVolume::GetName(), GetPVDivisionFactory(), GetReflectedLV(), G4InuclParticleNames::name(), and ReflectLV().

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.
  // ---
 
  LogicalVolumesMapIterator it = fReflectedLVMap.find(reflLV);
 
  if (it == fReflectedLVMap.end()) return nullptr;
 
  return (*it).second;
}        

References fReflectedLVMap.

Referenced by G4GDMLWriteStructure::PhysvolWrite(), ReflectPVDivision(), ReflectPVPlacement(), ReflectPVReplica(), and G4GDMLWriteStructure::TraverseVolumeTree().

GetPVDivisionFactory()

G4VPVDivisionFactory * G4ReflectionFactory::GetPVDivisionFactory ( ) const

private

Definition at line 802 of file G4ReflectionFactory.cc.

{
  // Returns the G4PVDivisionFactory instance if it exists,
  // otherwise gives exception 
  // ---
 
  G4VPVDivisionFactory* divisionFactory = G4VPVDivisionFactory::Instance();
  if (!divisionFactory)
  {
    std::ostringstream message;
    message << "A concrete G4PVDivisionFactory instantiated is required !"
            << G4endl
            << "        It has been requested to reflect divided volumes."
            << G4endl
            << "        In this case, it is required to instantiate a concrete"
            << G4endl
            << "        factory G4PVDivisionFactory in your program -before-"
            << G4endl
            << "        executing the reflection !";
     G4Exception("G4ReflectionFactory::GetPVDivisionFactory()",
                 "GeomVol0002", FatalException, message);
  }
  
  return divisionFactory;
}  

References FatalException, G4endl, G4Exception(), and G4VPVDivisionFactory::Instance().

Referenced by Divide(), and ReflectPVDivision().

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.
  // ---
 
  LogicalVolumesMapIterator it = fConstituentLVMap.find(lv);
 
  if (it == fConstituentLVMap.end()) return nullptr;
 
  return (*it).second;
}        

References fConstituentLVMap.

Referenced by Divide(), G4GDMLParser::ImportRegions(), Place(), ReflectLV(), ReflectPVDivision(), ReflectPVPlacement(), ReflectPVReplica(), and Replicate().

GetReflectedVolumesMap()

const G4ReflectedVolumesMap & G4ReflectionFactory::GetReflectedVolumesMap

(

)

const

Definition at line 747 of file G4ReflectionFactory.cc.

{
  return fReflectedLVMap;
}

References fReflectedLVMap.

GetScalePrecision()

G4double G4ReflectionFactory::GetScalePrecision

(

)

const

Definition at line 837 of file G4ReflectionFactory.cc.

{
  return fScalePrecision;
}

References fScalePrecision.

GetVerboseLevel()

G4int G4ReflectionFactory::GetVerboseLevel

(

)

const

Definition at line 851 of file G4ReflectionFactory.cc.

{
  return fVerboseLevel;
}

References fVerboseLevel.

GetVolumesNameExtension()

const G4String & G4ReflectionFactory::GetVolumesNameExtension

(

)

const

Definition at line 865 of file G4ReflectionFactory.cc.

{
  return fNameExtension;
}

References 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;
}  

References fInstance, and G4ReflectionFactory().

Referenced by G4tgbVolume::ConstructG4PhysVol(), G3Division::CreatePVReplica(), G4GDMLReadStructure::DivisionvolRead(), G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVPlacement(), G4GDMLParser::ExportRegions(), G3toG4BuildPVTree(), G4GDMLWriteStructure::G4GDMLWriteStructure(), G4tgbVolumeMgr::G4tgbVolumeMgr(), G4GDMLParser::ImportRegions(), G4AssemblyVolume::MakeImprint(), 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());
}  

References fConstituentLVMap.

Referenced by G4GDMLParser::ImportRegions().

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());
}  

References fReflectedLVMap.

Referenced by G4tgbGeometryDumper::DumpPhysVol(), G4tgbGeometryDumper::DumpPVPlacement(), G4GDMLParser::ExportRegions(), G4GDMLWriteStructure::PhysvolWrite(), ReflectPVDivision(), ReflectPVPlacement(), ReflectPVReplica(), and G4GDMLWriteStructure::TraverseVolumeTree().

IsReflection()

G4bool G4ReflectionFactory::IsReflection ( const G4Scale3D &  scale ) const

private

Definition at line 733 of file G4ReflectionFactory.cc.

{
  // Returns true if the scale is negative, false otherwise.
  // ---
 
  if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)
    return true;
  else 
    return false;  
}

Referenced by CheckScale(), and Place().

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 G4PhysicalVolumesPair(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 G4PhysicalVolumesPair(pv1, pv2);  
}           

References CheckScale(), fScale, fVerboseLevel, G4cout, G4endl, HepGeom::Transform3D::getDecomposition(), G4LogicalVolume::GetName(), GetReflectedLV(), HepGeom::Transform3D::inverse(), IsReflection(), G4InuclParticleNames::name(), and ReflectLV().

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

PrintConstituentLVMap()

void G4ReflectionFactory::PrintConstituentLVMap ( )

private

Definition at line 762 of file G4ReflectionFactory.cc.

{
  // temporary - for debugging purpose
  // ---
 
  LogicalVolumesMapIterator it;
  for (it = fConstituentLVMap.begin(); it != fConstituentLVMap.end(); ++it)
  {
    G4cout << "lv: " << (*it).first << "  lv_refl: " << (*it).second << G4endl;
  }
  G4cout << G4endl;
}  

References fConstituentLVMap, G4cout, and G4endl.

ReflectDaughters()

void G4ReflectionFactory::ReflectDaughters ( G4LogicalVolume *  LV, G4LogicalVolume *  refLV, G4bool  surfCheck = false  )

private

Definition at line 442 of file G4ReflectionFactory.cc.

{
  // Reflects daughters recursively.
  // ---
 
  if (fVerboseLevel>0)
  {
    G4cout << "G4ReflectionFactory::ReflectDaughters(): " 
           << LV->GetNoDaughters() << " of " << LV->GetName() << G4endl;
  }     
 
  for (size_t i=0; i<LV->GetNoDaughters(); ++i)
  {
    G4VPhysicalVolume* dPV = LV->GetDaughter(i);
    
    if (!dPV->IsReplicated())
    {
      ReflectPVPlacement(dPV, refLV, surfCheck); 
    }  
    else if (!dPV->GetParameterisation())
    {
      ReflectPVReplica(dPV, refLV); 
    }  
    else if (G4VPVDivisionFactory::Instance() &&
             G4VPVDivisionFactory::Instance()->IsPVDivision(dPV))
    {
      ReflectPVDivision(dPV, refLV); 
    }  
    else
    {
      ReflectPVParameterised(dPV, refLV, surfCheck); 
    }
  }
}

References fVerboseLevel, G4cout, G4endl, G4LogicalVolume::GetDaughter(), G4LogicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4VPhysicalVolume::GetParameterisation(), G4VPVDivisionFactory::Instance(), G4VPhysicalVolume::IsReplicated(), ReflectPVDivision(), ReflectPVParameterised(), ReflectPVPlacement(), and ReflectPVReplica().

Referenced by ReflectLV(), ReflectPVDivision(), ReflectPVPlacement(), and ReflectPVReplica().

ReflectLV()

G4LogicalVolume * G4ReflectionFactory::ReflectLV ( G4LogicalVolume *  LV, G4bool  surfCheck = false  )

private

Definition at line 365 of file G4ReflectionFactory.cc.

{
  // Gets/creates the reflected solid and logical volume
  // and copies + transforms LV daughters.
  // ---
 
  G4LogicalVolume* refLV = GetReflectedLV(LV);
 
  if (!refLV)
  {
 
    // create new (reflected) objects
    //
    refLV = CreateReflectedLV(LV);
        
    // process daughters  
    //
    ReflectDaughters(LV, refLV, surfCheck);
 
    // check if to be set as root region
    //
    if (LV->IsRootRegion())
    {
       LV->GetRegion()->AddRootLogicalVolume(refLV);
    }
  }
 
  return refLV;
}

References G4Region::AddRootLogicalVolume(), CreateReflectedLV(), GetReflectedLV(), G4LogicalVolume::GetRegion(), G4LogicalVolume::IsRootRegion(), and ReflectDaughters().

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

ReflectPVDivision()

void G4ReflectionFactory::ReflectPVDivision ( G4VPhysicalVolume *  PV, G4LogicalVolume *  refLV  )

private

Definition at line 605 of file G4ReflectionFactory.cc.

{
  // Copies and transforms daughter of PVDivision type of
  // a constituent volume into a reflected volume. 
  // ---
 
  G4VPVDivisionFactory* divisionFactory = GetPVDivisionFactory();
 
  G4LogicalVolume* dLV = dPV->GetLogicalVolume();
 
  // get parameterisation data
  //
  G4VPVParameterisation* param = dPV->GetParameterisation();
 
  G4LogicalVolume* refDLV;
  
  if (fVerboseLevel>0) 
    G4cout << "Daughter: " << dPV << "  " << dLV->GetName();
  
  if (!IsReflected(dLV))
  {
    if (fVerboseLevel>0) 
      G4cout << " will be reflected." << G4endl;
 
    // get reflected volume if already created
    //
    refDLV = GetReflectedLV(dLV); 
 
    if (refDLV == nullptr)
    {
      // create new daughter solid and logical volume
      //
      refDLV = CreateReflectedLV(dLV); 
  
      // recursive call
      //
      ReflectDaughters(dLV, refDLV); 
    }     
        
    // create new daughter replica
    //
    divisionFactory->CreatePVDivision(dPV->GetName(), refDLV, refLV, param);
  }
  else
  {
    if (fVerboseLevel>0) 
      G4cout << " will be reconstitued." << G4endl;
 
    refDLV = GetConstituentLV(dLV); 
 
    divisionFactory->CreatePVDivision(dPV->GetName(), refDLV, refLV, param); 
  }       
}

References G4VPVDivisionFactory::CreatePVDivision(), CreateReflectedLV(), fVerboseLevel, G4cout, G4endl, GetConstituentLV(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::GetParameterisation(), GetPVDivisionFactory(), GetReflectedLV(), IsReflected(), and ReflectDaughters().

Referenced by ReflectDaughters().

ReflectPVParameterised()

void G4ReflectionFactory::ReflectPVParameterised ( G4VPhysicalVolume *  PV, G4LogicalVolume *  refLV, G4bool  surfChk = false  )

private

Definition at line 662 of file G4ReflectionFactory.cc.

{
  // Not implemented.
  // Should copy and transform daughter of PVReplica type of
  // a constituent volume into a reflected volume. 
  // ---
 
  std::ostringstream message;
  message << "Not yet implemented. Volume: " << dPV->GetName() << G4endl
          << "Reflection of parameterised volumes is not yet implemented.";
  G4Exception("G4ReflectionFactory::ReflectPVParameterised()",
              "GeomVol0001", FatalException, message);
}

References FatalException, G4endl, G4Exception(), and G4VPhysicalVolume::GetName().

Referenced by ReflectDaughters().

ReflectPVPlacement()

void G4ReflectionFactory::ReflectPVPlacement ( G4VPhysicalVolume *  PV, G4LogicalVolume *  refLV, G4bool  surfCheck = false  )

private

Definition at line 481 of file G4ReflectionFactory.cc.

{
  // Copies and transforms daughter of PVPlacement type of
  // a constituent volume into a reflected volume. 
  // ---
 
  G4LogicalVolume* dLV = dPV->GetLogicalVolume();
 
  // update daughter transformation
  //
  G4Transform3D dt(dPV->GetObjectRotationValue(), dPV->GetObjectTranslation());
  dt = fScale * (dt * fScale.inverse());
 
  G4LogicalVolume* refDLV;
  
  if (fVerboseLevel>0) 
    G4cout << "Daughter: " << dPV << "  " << dLV->GetName();
  
  if (!IsReflected(dLV))
  {
 
    if (fVerboseLevel>0) 
      G4cout << " will be reflected." << G4endl;
 
    // get reflected volume if already created
    refDLV = GetReflectedLV(dLV); 
 
    if (refDLV == nullptr)
    {
      // create new daughter solid and logical volume
      //
      refDLV = CreateReflectedLV(dLV); 
  
      // recursive call
      //
      ReflectDaughters(dLV, refDLV, surfCheck);   
    }  
 
    // create new daughter physical volume
    // with updated transformation
 
    new G4PVPlacement(dt, refDLV, dPV->GetName(), refLV, 
                      dPV->IsMany(), dPV->GetCopyNo(), surfCheck); 
 
  } 
  else
  {
    if (fVerboseLevel>0) 
      G4cout << " will be reconstitued." << G4endl;
 
    refDLV = GetConstituentLV(dLV); 
 
    new G4PVPlacement(dt, refDLV, dPV->GetName(), refLV, 
                      dPV->IsMany(), dPV->GetCopyNo(), surfCheck); 
  }       
}    

References CreateReflectedLV(), fScale, fVerboseLevel, G4cout, G4endl, GetConstituentLV(), G4VPhysicalVolume::GetCopyNo(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::GetObjectRotationValue(), G4VPhysicalVolume::GetObjectTranslation(), GetReflectedLV(), HepGeom::Transform3D::inverse(), G4VPhysicalVolume::IsMany(), IsReflected(), and ReflectDaughters().

Referenced by ReflectDaughters().

ReflectPVReplica()

void G4ReflectionFactory::ReflectPVReplica ( G4VPhysicalVolume *  PV, G4LogicalVolume *  refLV  )

private

Definition at line 542 of file G4ReflectionFactory.cc.

{
  // Copies and transforms daughter of PVReplica type of
  // a constituent volume into a reflected volume. 
  // ---
 
  G4LogicalVolume* dLV = dPV->GetLogicalVolume();
 
  // get replication data
  //
  EAxis axis;
  G4int nofReplicas;
  G4double width;
  G4double offset;
  G4bool consuming;
 
  dPV->GetReplicationData(axis, nofReplicas, width, offset, consuming);
 
  G4LogicalVolume* refDLV;
  
  if (fVerboseLevel>0) 
    G4cout << "Daughter: " << dPV << "  " << dLV->GetName();
  
  if (!IsReflected(dLV))
  {
    if (fVerboseLevel>0) 
      G4cout << " will be reflected." << G4endl;
 
    // get reflected volume if already created
    //
    refDLV = GetReflectedLV(dLV); 
 
    if (refDLV == nullptr)
    {
      // create new daughter solid and logical volume
      //
      refDLV = CreateReflectedLV(dLV); 
  
      // recursive call
      //
      ReflectDaughters(dLV, refDLV); 
    }     
        
    // create new daughter replica
    //
    new G4PVReplica(dPV->GetName(), refDLV, refLV, 
                    axis, nofReplicas, width, offset);
  }
  else
  {
    if (fVerboseLevel>0) 
      G4cout << " will be reconstitued." << G4endl;
 
    refDLV = GetConstituentLV(dLV); 
 
    new G4PVReplica(dPV->GetName(), refDLV, refLV, 
                    axis, nofReplicas, width, offset); 
  }       
}

References CreateReflectedLV(), fVerboseLevel, G4cout, G4endl, GetConstituentLV(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), GetReflectedLV(), G4VPhysicalVolume::GetReplicationData(), IsReflected(), and ReflectDaughters().

Referenced by ReflectDaughters().

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 G4PhysicalVolumesPair(pv1, pv2);            
}         

References fVerboseLevel, G4cout, G4endl, G4LogicalVolume::GetName(), GetReflectedLV(), G4InuclParticleNames::name(), and ReflectLV().

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

SetScalePrecision()

void G4ReflectionFactory::SetScalePrecision

(

G4double

scaleValue

)

Definition at line 830 of file G4ReflectionFactory.cc.

{
  fScalePrecision = scaleValue;
}

References fScalePrecision.

Referenced by G4tgbVolumeMgr::G4tgbVolumeMgr().

SetVerboseLevel()

void G4ReflectionFactory::SetVerboseLevel

(

G4int

verboseLevel

)

Definition at line 844 of file G4ReflectionFactory.cc.

{
  fVerboseLevel = verboseLevel;
}

References fVerboseLevel.

SetVolumesNameExtension()

void G4ReflectionFactory::SetVolumesNameExtension

(

const G4String &

nameExtension

)

Definition at line 858 of file G4ReflectionFactory.cc.

{
  fNameExtension = nameExtension;
}

References fNameExtension.

Field Documentation

fConstituentLVMap

G4ReflectedVolumesMap G4ReflectionFactory::fConstituentLVMap

private

Definition at line 244 of file G4ReflectionFactory.hh.

Referenced by Clean(), CreateReflectedLV(), GetReflectedLV(), IsConstituent(), and PrintConstituentLVMap().

fDefaultNameExtension

const G4String G4ReflectionFactory::fDefaultNameExtension = "_refl"

staticprivate

Definition at line 238 of file G4ReflectionFactory.hh.

fInstance

G4ThreadLocal G4ReflectionFactory * G4ReflectionFactory::fInstance = nullptr

staticprivate

Definition at line 237 of file G4ReflectionFactory.hh.

Referenced by G4ReflectionFactory(), Instance(), and ~G4ReflectionFactory().

fNameExtension

G4String G4ReflectionFactory::fNameExtension

private

Definition at line 243 of file G4ReflectionFactory.hh.

Referenced by CreateReflectedLV(), GetVolumesNameExtension(), and SetVolumesNameExtension().

fReflectedLVMap

G4ReflectedVolumesMap G4ReflectionFactory::fReflectedLVMap

private

Definition at line 245 of file G4ReflectionFactory.hh.

Referenced by Clean(), CreateReflectedLV(), GetConstituentLV(), GetReflectedVolumesMap(), and IsReflected().

fScale

const G4Scale3D G4ReflectionFactory::fScale = G4ScaleZ3D(-1.0)

staticprivate

Definition at line 239 of file G4ReflectionFactory.hh.

Referenced by CheckScale(), CreateReflectedLV(), Place(), and ReflectPVPlacement().

fScalePrecision

G4double G4ReflectionFactory::fScalePrecision

private

Definition at line 240 of file G4ReflectionFactory.hh.

Referenced by CheckScale(), G4ReflectionFactory(), GetScalePrecision(), and SetScalePrecision().

fVerboseLevel

G4int G4ReflectionFactory::fVerboseLevel = 0

private

Definition at line 242 of file G4ReflectionFactory.hh.

Referenced by Divide(), GetVerboseLevel(), Place(), ReflectDaughters(), ReflectPVDivision(), ReflectPVPlacement(), ReflectPVReplica(), Replicate(), and SetVerboseLevel().

---

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

• source/geometry/volumes/include/G4ReflectionFactory.hh
• source/geometry/volumes/src/G4ReflectionFactory.cc