G4AssemblyVolume Class Reference

#include <G4AssemblyVolume.hh>

Public Member Functions
void	AddPlacedAssembly (G4AssemblyVolume *pAssembly, G4ThreeVector &translation, G4RotationMatrix *rotation)
void	AddPlacedAssembly (G4AssemblyVolume *pAssembly, G4Transform3D &transformation)
void	AddPlacedVolume (G4LogicalVolume *pPlacedVolume, G4ThreeVector &translation, G4RotationMatrix *rotation)
void	AddPlacedVolume (G4LogicalVolume *pPlacedVolume, G4Transform3D &transformation)
	G4AssemblyVolume ()
	G4AssemblyVolume (G4LogicalVolume *volume, G4ThreeVector &translation, G4RotationMatrix *rotation)
unsigned int	GetAssemblyID () const
unsigned int	GetImprintsCount () const
G4Transform3D &	GetImprintTransformation (unsigned int imprintID)
unsigned int	GetInstanceCount () const
std::vector< G4AssemblyTriplet >::iterator	GetTripletsIterator ()
std::vector< G4VPhysicalVolume * >::iterator	GetVolumesIterator ()
void	MakeImprint (G4LogicalVolume *pMotherLV, G4ThreeVector &translationInMother, G4RotationMatrix *pRotationInMother, G4int copyNumBase=0, G4bool surfCheck=false)
void	MakeImprint (G4LogicalVolume *pMotherLV, G4Transform3D &transformation, G4int copyNumBase=0, G4bool surfCheck=false)
std::size_t	TotalImprintedVolumes () const
std::size_t	TotalTriplets () const
	~G4AssemblyVolume ()

Protected Member Functions
void	ImprintsCountMinus ()
void	ImprintsCountPlus ()
void	InstanceCountMinus ()
void	InstanceCountPlus ()
void	SetAssemblyID (unsigned int value)
void	SetImprintsCount (unsigned int value)
void	SetInstanceCount (unsigned int value)

Private Member Functions
void	MakeImprint (G4AssemblyVolume *pAssembly, G4LogicalVolume *pMotherLV, G4Transform3D &transformation, G4int copyNumBase=0, G4bool surfCheck=false)

Private Attributes
unsigned int	fAssemblyID = 0
unsigned int	fImprintsCounter
std::map< unsigned int, G4Transform3D >	fImprintsTransf
std::vector< G4VPhysicalVolume * >	fPVStore
std::vector< G4AssemblyTriplet >	fTriplets

Static Private Attributes
static G4ThreadLocal unsigned int	fsInstanceCounter = 0

Detailed Description

Definition at line 53 of file G4AssemblyVolume.hh.

Constructor & Destructor Documentation

G4AssemblyVolume() [1/2]

G4AssemblyVolume::G4AssemblyVolume

(

)

Definition at line 45 of file G4AssemblyVolume.cc.

{
  InstanceCountPlus();
  SetAssemblyID( GetInstanceCount() );
  SetImprintsCount( 0 );
  G4AssemblyStore* aStore = G4AssemblyStore::GetInstance();
  if (aStore->GetAssembly(fAssemblyID,false))
  {
    std::ostringstream message;
    message << "The assembly has NOT been registered !" << G4endl
            << "          Assembly " << fAssemblyID
            << " already existing in store !" << G4endl;
    G4Exception("G4AssemblyVolume::G4AssemblyVolume()", "GeomVol1001",
                JustWarning, message);
  }
  else
  {
    aStore->Register(this);
  }
}

References fAssemblyID, G4endl, G4Exception(), G4AssemblyStore::GetAssembly(), G4AssemblyStore::GetInstance(), GetInstanceCount(), InstanceCountPlus(), JustWarning, G4AssemblyStore::Register(), SetAssemblyID(), and SetImprintsCount().

G4AssemblyVolume() [2/2]

G4AssemblyVolume::G4AssemblyVolume	(	G4LogicalVolume *	volume,
		G4ThreeVector &	translation,
		G4RotationMatrix *	rotation
	)

Definition at line 68 of file G4AssemblyVolume.cc.

{
  InstanceCountPlus();
  SetAssemblyID( GetInstanceCount() );
  SetImprintsCount( 0 );
  AddPlacedVolume(volume, translation, rotation);
  G4AssemblyStore* aStore = G4AssemblyStore::GetInstance();
  if (aStore->GetAssembly(fAssemblyID,false))
  {
    std::ostringstream message;
    message << "The assembly has NOT been registered !" << G4endl
            << "          Assembly " << fAssemblyID
            << " already existing in store !" << G4endl;
    G4Exception("G4Assembly::G4Assembly()", "GeomVol1001",
                JustWarning, message);
  }
  else
  {
    aStore->Register(this);
  }
}

References AddPlacedVolume(), fAssemblyID, G4endl, G4Exception(), G4AssemblyStore::GetAssembly(), G4AssemblyStore::GetInstance(), GetInstanceCount(), InstanceCountPlus(), JustWarning, G4AssemblyStore::Register(), SetAssemblyID(), and SetImprintsCount().

~G4AssemblyVolume()

G4AssemblyVolume::~G4AssemblyVolume

(

)

Definition at line 94 of file G4AssemblyVolume.cc.

{
  unsigned int howmany = fTriplets.size();
  if( howmany != 0 )
  {
    for( unsigned int i = 0; i < howmany; ++i )
    {
      G4RotationMatrix* pRotToClean = fTriplets[i].GetRotation();
      if( pRotToClean != 0 )
      {
        delete pRotToClean;
      }
    }
  }
  fTriplets.clear();
  
  // No need to delete physical volumes, as these are deleted
  // by physical-volumes store.
  //
  fPVStore.clear();
  InstanceCountMinus();
  G4AssemblyStore::GetInstance()->DeRegister(this);
}

References G4AssemblyStore::DeRegister(), fPVStore, fTriplets, G4AssemblyStore::GetInstance(), and InstanceCountMinus().

Member Function Documentation

AddPlacedAssembly() [1/2]

void G4AssemblyVolume::AddPlacedAssembly	(	G4AssemblyVolume *	pAssembly,
		G4ThreeVector &	translation,
		G4RotationMatrix *	rotation
	)

Definition at line 165 of file G4AssemblyVolume.cc.

{
  G4RotationMatrix*  toStore  = new G4RotationMatrix;
  
  if( pRotation != nullptr )  { *toStore = *pRotation; }
  
  G4AssemblyTriplet toAdd( pAssembly, translation, toStore );
  fTriplets.push_back( toAdd );
}

References fTriplets.

AddPlacedAssembly() [2/2]

void G4AssemblyVolume::AddPlacedAssembly	(	G4AssemblyVolume *	pAssembly,
		G4Transform3D &	transformation
	)

Definition at line 180 of file G4AssemblyVolume.cc.

{
  // Decompose transformation
  //
  G4Scale3D     scale;
  G4Rotate3D    rotation;
  G4Translate3D translation;
  transformation.getDecomposition(scale, rotation, translation);
 
  G4ThreeVector      v = translation.getTranslation();
  G4RotationMatrix*  r = new G4RotationMatrix;
                    *r = rotation.getRotation();
  
  G4bool isReflection = false;
  if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)  { isReflection = true; }
  
  G4AssemblyTriplet toAdd( pAssembly, v, r, isReflection );
  fTriplets.push_back( toAdd );
}

References fTriplets, HepGeom::Transform3D::getDecomposition(), HepGeom::Transform3D::getRotation(), and HepGeom::Transform3D::getTranslation().

Referenced by G4GDMLReadStructure::PhysvolRead().

AddPlacedVolume() [1/2]

void G4AssemblyVolume::AddPlacedVolume	(	G4LogicalVolume *	pPlacedVolume,
		G4ThreeVector &	translation,
		G4RotationMatrix *	rotation
	)

Definition at line 128 of file G4AssemblyVolume.cc.

{
  G4RotationMatrix*  toStore  = new G4RotationMatrix;
  
  if( pRotation != nullptr )  { *toStore = *pRotation; }
  
  G4AssemblyTriplet toAdd( pVolume, translation, toStore );
  fTriplets.push_back( toAdd );
}

References fTriplets.

Referenced by G4tgbVolume::ConstructG4PhysVol(), G4AssemblyVolume(), and G4GDMLReadStructure::PhysvolRead().

AddPlacedVolume() [2/2]

void G4AssemblyVolume::AddPlacedVolume	(	G4LogicalVolume *	pPlacedVolume,
		G4Transform3D &	transformation
	)

Definition at line 142 of file G4AssemblyVolume.cc.

{
  // Decompose transformation
  G4Scale3D     scale;
  G4Rotate3D    rotation;
  G4Translate3D translation;
  transformation.getDecomposition(scale, rotation, translation);
 
  G4ThreeVector      v = translation.getTranslation();
  G4RotationMatrix*  r = new G4RotationMatrix;
                    *r = rotation.getRotation();
  
  G4bool isReflection = false;
  if (scale(0,0)*scale(1,1)*scale(2,2) < 0.)  { isReflection = true; }
 
  G4AssemblyTriplet toAdd( pVolume, v, r, isReflection );
  fTriplets.push_back( toAdd );
}

References fTriplets, HepGeom::Transform3D::getDecomposition(), HepGeom::Transform3D::getRotation(), and HepGeom::Transform3D::getTranslation().

GetAssemblyID()

unsigned int G4AssemblyVolume::GetAssemblyID ( ) const

inline

Referenced by MakeImprint().

GetImprintsCount()

unsigned int G4AssemblyVolume::GetImprintsCount ( ) const

inline

Referenced by MakeImprint().

GetImprintTransformation()

G4Transform3D & G4AssemblyVolume::GetImprintTransformation ( unsigned int  imprintID )

inline

Referenced by G4GDMLWriteStructure::TraverseVolumeTree().

GetInstanceCount()

unsigned int G4AssemblyVolume::GetInstanceCount

(

)

const

Definition at line 377 of file G4AssemblyVolume.cc.

{
  return G4AssemblyVolume::fsInstanceCounter;
}

References fsInstanceCounter.

Referenced by G4AssemblyVolume().

GetTripletsIterator()

std::vector< G4AssemblyTriplet >::iterator G4AssemblyVolume::GetTripletsIterator ( )

inline

Referenced by G4GDMLWriteStructure::AssemblyWrite().

GetVolumesIterator()

std::vector< G4VPhysicalVolume * >::iterator G4AssemblyVolume::GetVolumesIterator ( )

inline

ImprintsCountMinus()

void G4AssemblyVolume::ImprintsCountMinus ( )

inlineprotected

ImprintsCountPlus()

void G4AssemblyVolume::ImprintsCountPlus ( )

inlineprotected

Referenced by MakeImprint().

InstanceCountMinus()

void G4AssemblyVolume::InstanceCountMinus ( )

protected

Definition at line 392 of file G4AssemblyVolume.cc.

{
  G4AssemblyVolume::fsInstanceCounter--;
}

References fsInstanceCounter.

Referenced by ~G4AssemblyVolume().

InstanceCountPlus()

void G4AssemblyVolume::InstanceCountPlus ( )

protected

Definition at line 387 of file G4AssemblyVolume.cc.

{
  G4AssemblyVolume::fsInstanceCounter++;
}

References fsInstanceCounter.

Referenced by G4AssemblyVolume().

MakeImprint() [1/3]

void G4AssemblyVolume::MakeImprint ( G4AssemblyVolume *  pAssembly, G4LogicalVolume *  pMotherLV, G4Transform3D &  transformation, G4int  copyNumBase = 0, G4bool  surfCheck = false  )

private

Definition at line 239 of file G4AssemblyVolume.cc.

{
  unsigned int  numberOfDaughters;
    
  if( copyNumBase == 0 )
  {
    numberOfDaughters = pMotherLV->GetNoDaughters();
  }
  else
  {
    numberOfDaughters = copyNumBase;
  }
 
  // We start from the first available index
  //
  numberOfDaughters++;
 
  ImprintsCountPlus();
  
  auto triplets = pAssembly->fTriplets;
 
  // store the transformation in a container (for GDML persistency)
  fImprintsTransf[GetImprintsCount()] = transformation;
 
  for( unsigned int i = 0; i < triplets.size(); ++i )
  {
    G4Transform3D Ta( *(triplets[i].GetRotation()),
                      triplets[i].GetTranslation() );
    if ( triplets[i].IsReflection() )  { Ta = Ta * G4ReflectZ3D(); }
 
    G4Transform3D Tfinal = transformation * Ta;
    
    if ( triplets[i].GetVolume() )
    {
      // Generate the unique name for the next PV instance
      // The name has format:
      //
      // av_WWW_impr_XXX_YYY_ZZZ
      // where the fields mean:
      // WWW - assembly volume instance number
      // XXX - assembly volume imprint number
      // YYY - the name of a log. volume we want to make a placement of
      // ZZZ - the log. volume index inside the assembly volume
      //
      std::stringstream pvName;
      pvName << "av_"
             << GetAssemblyID()
             << "_impr_"
             << GetImprintsCount()
             << "_"
             << triplets[i].GetVolume()->GetName().c_str()
             << "_pv_"
             << i
             << std::ends;
 
      // Generate a new physical volume instance inside a mother
      // (as we allow 3D transformation use G4ReflectionFactory to 
      //  take into account eventual reflection)
      //
      G4PhysicalVolumesPair pvPlaced
        = G4ReflectionFactory::Instance()->Place( Tfinal,
                                                  pvName.str().c_str(),
                                                  triplets[i].GetVolume(),
                                                  pMotherLV,
                                                  false,
                                                  numberOfDaughters + i,
                                                  surfCheck );
 
      // Register the physical volume created by us so we can delete it later
      //
      fPVStore.push_back( pvPlaced.first );
      if ( pvPlaced.second )  { fPVStore.push_back( pvPlaced.second ); }
 
      // Here I want to save the imprint transformation to some container, so I can retrieve the original values later
      // imprintTrans[GetImprintsCount()] = transformation;
      
    }
    else if ( triplets[i].GetAssembly() )
    {
      // Place volumes in this assembly with composed transformation
      //
      MakeImprint( triplets[i].GetAssembly(), pMotherLV,
                   Tfinal, i*100+copyNumBase, surfCheck ); 
    }
    else
    {
      G4Exception("G4AssemblyVolume::MakeImprint(..)",
                  "GeomVol0003", FatalException,
                  "Triplet has no volume and no assembly");
    }  
  }  
}    

References FatalException, fImprintsTransf, fPVStore, fTriplets, G4Exception(), GetAssemblyID(), GetImprintsCount(), G4LogicalVolume::GetNoDaughters(), pyG4VTouchable::GetRotation, ImprintsCountPlus(), G4ReflectionFactory::Instance(), MakeImprint(), and G4ReflectionFactory::Place().

MakeImprint() [2/3]

void G4AssemblyVolume::MakeImprint	(	G4LogicalVolume *	pMotherLV,
		G4ThreeVector &	translationInMother,
		G4RotationMatrix *	pRotationInMother,
		G4int	copyNumBase = 0,
		G4bool	surfCheck = false
	)

Definition at line 336 of file G4AssemblyVolume.cc.

{
  // If needed user can specify explicitely the base count from which to start
  // off for the generation of phys. vol. copy numbers.
  // The old behaviour is preserved when copyNumBase == 0, e.g. the generated
  // copy numbers start from the count equal to current number of daughter
  // volumes before an imprint is made
 
  // Compose transformation
  //
  if( pRotationInMother == nullptr )
  {
    // Make it by default an indentity matrix
    //
    pRotationInMother =
      const_cast<G4RotationMatrix*>( &G4RotationMatrix::IDENTITY );
  }
 
  G4Transform3D transform( *pRotationInMother,
                            translationInMother );
  MakeImprint(this, pMotherLV, transform, copyNumBase, surfCheck);
}

References CLHEP::HepRotation::IDENTITY, MakeImprint(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by G4tgbVolume::ConstructG4PhysVol(), MakeImprint(), and G4GDMLReadStructure::PhysvolRead().

MakeImprint() [3/3]

void G4AssemblyVolume::MakeImprint	(	G4LogicalVolume *	pMotherLV,
		G4Transform3D &	transformation,
		G4int	copyNumBase = 0,
		G4bool	surfCheck = false
	)

Definition at line 363 of file G4AssemblyVolume.cc.

{
  // If needed user can specify explicitely the base count from which to start
  // off for the generation of phys. vol. copy numbers.
  // The old behaviour is preserved when copyNumBase == 0, e.g. the generated
  // copy numbers start from the count equal to current number of daughter
  // volumes before a imprint is made
 
  MakeImprint(this, pMotherLV, transformation, copyNumBase, surfCheck);
}

References MakeImprint().

SetAssemblyID()

void G4AssemblyVolume::SetAssemblyID ( unsigned int  value )

inlineprotected

Referenced by G4AssemblyVolume().

SetImprintsCount()

void G4AssemblyVolume::SetImprintsCount ( unsigned int  value )

inlineprotected

Referenced by G4AssemblyVolume().

SetInstanceCount()

void G4AssemblyVolume::SetInstanceCount ( unsigned int  value )

inlineprotected

Definition at line 382 of file G4AssemblyVolume.cc.

{
  G4AssemblyVolume::fsInstanceCounter = value;
}

References fsInstanceCounter.

TotalImprintedVolumes()

std::size_t G4AssemblyVolume::TotalImprintedVolumes ( ) const

inline

TotalTriplets()

std::size_t G4AssemblyVolume::TotalTriplets ( ) const

inline

Referenced by G4GDMLWriteStructure::AssemblyWrite().

Field Documentation

fAssemblyID

unsigned int G4AssemblyVolume::fAssemblyID = 0

private

Definition at line 217 of file G4AssemblyVolume.hh.

Referenced by G4AssemblyVolume().

fImprintsCounter

unsigned int G4AssemblyVolume::fImprintsCounter

private

Definition at line 209 of file G4AssemblyVolume.hh.

fImprintsTransf

std::map<unsigned int, G4Transform3D> G4AssemblyVolume::fImprintsTransf

private

Definition at line 221 of file G4AssemblyVolume.hh.

Referenced by MakeImprint().

fPVStore

std::vector<G4VPhysicalVolume*> G4AssemblyVolume::fPVStore

private

Definition at line 198 of file G4AssemblyVolume.hh.

Referenced by MakeImprint(), and ~G4AssemblyVolume().

fsInstanceCounter

G4ThreadLocal unsigned int G4AssemblyVolume::fsInstanceCounter = 0

staticprivate

Definition at line 213 of file G4AssemblyVolume.hh.

Referenced by GetInstanceCount(), InstanceCountMinus(), InstanceCountPlus(), and SetInstanceCount().

fTriplets

std::vector<G4AssemblyTriplet> G4AssemblyVolume::fTriplets

private

Definition at line 193 of file G4AssemblyVolume.hh.

Referenced by AddPlacedAssembly(), AddPlacedVolume(), MakeImprint(), and ~G4AssemblyVolume().

---

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

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