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

Static Public Member Functions
static G4ReflectionFactory *	Instance ()

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

Detailed Description

Definition at line 84 of file G4ReflectionFactory.hh.

Constructor & Destructor Documentation

G4ReflectionFactory::~G4ReflectionFactory ( )

virtual

Definition at line 97 of file G4ReflectionFactory.cc.

{
  delete fInstance;
}

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::G4ReflectionFactory ( const G4ReflectionFactory &  )

protected

Member Function Documentation

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:

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:

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:

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:

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:

const G4ReflectedVolumesMap & G4ReflectionFactory::GetReflectedVolumesMap

(

)

const

Definition at line 752 of file G4ReflectionFactory.cc.

{
  return fReflectedLVMap;
}

G4double G4ReflectionFactory::GetScalePrecision

(

)

const

Definition at line 843 of file G4ReflectionFactory.cc.

{
  return fScalePrecision;
}

G4int G4ReflectionFactory::GetVerboseLevel

(

)

const

Definition at line 857 of file G4ReflectionFactory.cc.

{
  return fVerboseLevel;
}

const G4String & G4ReflectionFactory::GetVolumesNameExtension

(

)

const

Definition at line 871 of file G4ReflectionFactory.cc.

{
  return fNameExtension;
}

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:

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

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:

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

protected

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:

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:

void G4ReflectionFactory::Reset

(

)

Definition at line 760 of file G4ReflectionFactory.cc.

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

void G4ReflectionFactory::SetScalePrecision

(

G4double

scaleValue

)

Definition at line 836 of file G4ReflectionFactory.cc.

{
  fScalePrecision = scaleValue;
}

Here is the caller graph for this function:

void G4ReflectionFactory::SetVerboseLevel

(

G4int

verboseLevel

)

Definition at line 850 of file G4ReflectionFactory.cc.

{
  fVerboseLevel = verboseLevel;
}

void G4ReflectionFactory::SetVolumesNameExtension

(

const G4String &

nameExtension

)

Definition at line 864 of file G4ReflectionFactory.cc.

{
  fNameExtension = nameExtension;
}

---

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

• source/geant4.10.03.p02/source/geometry/volumes/include/G4ReflectionFactory.hh
• source/geant4.10.03.p02/source/geometry/volumes/src/G4ReflectionFactory.cc