G4ReflectionFactory Class Reference

#include <G4ReflectionFactory.hh>

Collaboration diagram for G4ReflectionFactory:

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	Reset ()

Static Public Member Functions
static G4ReflectionFactory *	Instance ()

Protected Member Functions
	G4ReflectionFactory ()
	G4ReflectionFactory (const G4ReflectionFactory &)
G4ReflectionFactory &	operator= (const G4ReflectionFactory &)

Private Types
typedef G4ReflectedVolumesMap::const_iterator	LogicalVolumesMapIterator

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

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

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

Detailed Description

Definition at line 84 of file G4ReflectionFactory.hh.

Member Typedef Documentation

LogicalVolumesMapIterator

typedef G4ReflectedVolumesMap::const_iterator G4ReflectionFactory::LogicalVolumesMapIterator

private

Definition at line 86 of file G4ReflectionFactory.hh.

Constructor & Destructor Documentation

~G4ReflectionFactory()

G4ReflectionFactory::~G4ReflectionFactory ( )

virtual

Definition at line 97 of file G4ReflectionFactory.cc.

{
  delete fInstance;
}

G4ReflectionFactory() [1/2]

G4ReflectionFactory::G4ReflectionFactory ( )

protected

Definition at line 83 of file G4ReflectionFactory.cc.

  : fVerboseLevel(0),
    fNameExtension(fDefaultNameExtension)    
{
  // Protected singleton constructor.
  // ---

  fScalePrecision = 10.
                  * G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fInstance = this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4ReflectionFactory() [2/2]

G4ReflectionFactory::G4ReflectionFactory ( const G4ReflectionFactory &  )

protected

Member Function Documentation

CheckScale()

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

private

Definition at line 783 of file G4ReflectionFactory.cc.

{
  // Check if scale correspond to fScale,
  // if not give exception.
  // ---

  if (!IsReflection(scale)) return;
  
  G4double diff = 0.;
  for (G4int i=0; i<4; i++)
    for (G4int 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);
  }
}    

Here is the call graph for this function:

Here is the caller graph for this function:

CreateReflectedLV()

G4LogicalVolume * G4ReflectionFactory::CreateReflectedLV ( G4LogicalVolume *  LV )

private

Definition at line 403 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;        
}

Here is the call graph for this function:

Here is the caller graph for this function:

Divide() [1/3]

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

Definition at line 243 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 0 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 = 0;
  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);            
}         

Here is the call graph for this function:

Here is the caller graph for this function:

Divide() [2/3]

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

Definition at line 285 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 0 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 = 0;
  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);            
}         

Here is the call graph for this function:

Divide() [3/3]

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

Definition at line 326 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 0 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 = 0;
  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);            
}         

Here is the call graph for this function:

GetConstituentLV()

G4LogicalVolume * G4ReflectionFactory::GetConstituentLV

(

G4LogicalVolume *

reflLV

)

const

Definition at line 685 of file G4ReflectionFactory.cc.

{              
  // Returns the consituent volume of the given reflected volume,
  // 0 if the given reflected volume was not found.
  // ---

  LogicalVolumesMapIterator it = fReflectedLVMap.find(reflLV);

  if (it == fReflectedLVMap.end()) return 0;

  return (*it).second;
}        

Here is the caller graph for this function:

GetPVDivisionFactory()

G4VPVDivisionFactory * G4ReflectionFactory::GetPVDivisionFactory ( ) const

private

Definition at line 808 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;
}  

Here is the call graph for this function:

Here is the caller graph for this function:

GetReflectedLV()

G4LogicalVolume * G4ReflectionFactory::GetReflectedLV

(

G4LogicalVolume *

lv

)

const

Definition at line 701 of file G4ReflectionFactory.cc.

{              
  // Returns the reflected volume of the given consituent volume,
  // 0 if the given volume was not reflected.
  // ---

  LogicalVolumesMapIterator it = fConstituentLVMap.find(lv);

  if (it == fConstituentLVMap.end()) return 0;

  return (*it).second;
}        

Here is the caller graph for this function:

GetReflectedVolumesMap()

const G4ReflectedVolumesMap & G4ReflectionFactory::GetReflectedVolumesMap

(

)

const

Definition at line 752 of file G4ReflectionFactory.cc.

{
  return fReflectedLVMap;
}

GetScalePrecision()

G4double G4ReflectionFactory::GetScalePrecision

(

)

const

Definition at line 843 of file G4ReflectionFactory.cc.

{
  return fScalePrecision;
}

GetVerboseLevel()

G4int G4ReflectionFactory::GetVerboseLevel

(

)

const

Definition at line 857 of file G4ReflectionFactory.cc.

{
  return fVerboseLevel;
}

GetVolumesNameExtension()

const G4String & G4ReflectionFactory::GetVolumesNameExtension

(

)

const

Definition at line 871 of file G4ReflectionFactory.cc.

{
  return fNameExtension;
}

Instance()

G4ReflectionFactory * G4ReflectionFactory::Instance ( void  )

static

Definition at line 71 of file G4ReflectionFactory.cc.

{
  // Static singleton access method.
  // ---

  if (!fInstance) { fInstance = new G4ReflectionFactory(); }

  return fInstance;
}  

Here is the call graph for this function:

Here is the caller graph for this function:

IsConstituent()

G4bool G4ReflectionFactory::IsConstituent

(

G4LogicalVolume *

lv

)

const

Definition at line 716 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());
}  

Here is the caller graph for this function:

IsReflected()

G4bool G4ReflectionFactory::IsReflected

(

G4LogicalVolume *

lv

)

const

Definition at line 727 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());
}  

Here is the caller graph for this function:

IsReflection()

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

private

Definition at line 738 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;  
}

Here is the caller graph for this function:

operator=()

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

protected

Place()

G4PhysicalVolumesPair G4ReflectionFactory::Place	(	const G4Transform3D &	transform3D,
		const G4String &	name,
		G4LogicalVolume *	LV,
		G4LogicalVolume *	motherLV,
		G4bool	isMany,
		G4int	copyNo,
		G4bool	surfCheck = false
	)

Definition at line 109 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 0 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 = 0;
    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 = 0;
  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);  
}           

Here is the call graph for this function:

Here is the caller graph for this function:

PrintConstituentLVMap()

void G4ReflectionFactory::PrintConstituentLVMap ( )

private

Definition at line 768 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;
}  

ReflectDaughters()

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

private

Definition at line 447 of file G4ReflectionFactory.cc.

{
  // Reflects daughters recursively.
  // ---

  if (fVerboseLevel>0)
  {
    G4cout << "G4ReflectionFactory::ReflectDaughters(): " 
           << LV->GetNoDaughters() << " of " << LV->GetName() << G4endl;
  }     

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReflectLV()

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

private

Definition at line 370 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReflectPVDivision()

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

private

Definition at line 610 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)
    {
      // 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); 
  }       
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReflectPVParameterised()

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

private

Definition at line 667 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReflectPVPlacement()

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

private

Definition at line 486 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)
    {
      // 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); 
  }       
}    

Here is the call graph for this function:

Here is the caller graph for this function:

ReflectPVReplica()

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

private

Definition at line 547 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)
    {
      // 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); 
  }       
}

Here is the call graph for this function:

Here is the caller graph for this function:

Replicate()

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

Definition at line 204 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 0 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 = 0;
  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);            
}         

Here is the call graph for this function:

Here is the caller graph for this function:

Reset()

void G4ReflectionFactory::Reset

(

)

Definition at line 760 of file G4ReflectionFactory.cc.

{
  fConstituentLVMap.~map();
  fReflectedLVMap.~map();
}

SetScalePrecision()

void G4ReflectionFactory::SetScalePrecision

(

G4double

scaleValue

)

Definition at line 836 of file G4ReflectionFactory.cc.

{
  fScalePrecision = scaleValue;
}

Here is the caller graph for this function:

SetVerboseLevel()

void G4ReflectionFactory::SetVerboseLevel

(

G4int

verboseLevel

)

Definition at line 850 of file G4ReflectionFactory.cc.

{
  fVerboseLevel = verboseLevel;
}

SetVolumesNameExtension()

void G4ReflectionFactory::SetVolumesNameExtension

(

const G4String &

nameExtension

)

Definition at line 864 of file G4ReflectionFactory.cc.

{
  fNameExtension = nameExtension;
}

Member Data Documentation

fConstituentLVMap

G4ReflectedVolumesMap G4ReflectionFactory::fConstituentLVMap

private

Definition at line 250 of file G4ReflectionFactory.hh.

fDefaultNameExtension

const G4String G4ReflectionFactory::fDefaultNameExtension = "_refl"

staticprivate

Definition at line 244 of file G4ReflectionFactory.hh.

fInstance

G4ThreadLocal G4ReflectionFactory * G4ReflectionFactory::fInstance = 0

staticprivate

Definition at line 243 of file G4ReflectionFactory.hh.

fNameExtension

G4String G4ReflectionFactory::fNameExtension

private

Definition at line 249 of file G4ReflectionFactory.hh.

fReflectedLVMap

G4ReflectedVolumesMap G4ReflectionFactory::fReflectedLVMap

private

Definition at line 251 of file G4ReflectionFactory.hh.

fScale

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

staticprivate

Definition at line 245 of file G4ReflectionFactory.hh.

fScalePrecision

G4double G4ReflectionFactory::fScalePrecision

private

Definition at line 246 of file G4ReflectionFactory.hh.

fVerboseLevel

G4int G4ReflectionFactory::fVerboseLevel

private

Definition at line 248 of file G4ReflectionFactory.hh.

---

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

• G4ReflectionFactory.hh
• G4ReflectionFactory.cc