G4PVParameterised Class Reference

#include <G4PVParameterised.hh>

Inheritance diagram for G4PVParameterised:

Public Member Functions
	G4PVParameterised (const G4String &pName, G4LogicalVolume *pLogical, G4LogicalVolume *pMotherLogical, const EAxis pAxis, const G4int nReplicas, G4VPVParameterisation *pParam, G4bool pSurfChk=false)
	G4PVParameterised (const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, const EAxis pAxis, const G4int nReplicas, G4VPVParameterisation *pParam, G4bool pSurfChk=false)
	G4PVParameterised (__void__ &)
	~G4PVParameterised () override
G4bool	IsParameterised () const override
EVolume	VolumeType () const final
G4VPVParameterisation *	GetParameterisation () const override
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const override
void	SetRegularStructureId (G4int code) override
G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1) override
Public Member Functions inherited from G4PVReplica
	G4PVReplica (const G4String &pName, G4LogicalVolume *pLogical, G4LogicalVolume *pMother, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double offset=0.)
	G4PVReplica (const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, const EAxis pAxis, const G4int nReplicas, const G4double width, const G4double offset=0.)
	G4PVReplica (__void__ &)
	G4PVReplica (const G4PVReplica &)=delete
G4PVReplica &	operator= (const G4PVReplica &)=delete
	~G4PVReplica () override
EVolume	VolumeType () const override
G4bool	IsMany () const override
G4bool	IsReplicated () const override
G4int	GetCopyNo () const override
void	SetCopyNo (G4int CopyNo) override
G4bool	IsParameterised () const override
G4VPVParameterisation *	GetParameterisation () const override
G4int	GetMultiplicity () const override
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const override
G4bool	IsRegularStructure () const override
G4int	GetRegularStructureId () const override
G4int	GetInstanceID () const
void	InitialiseWorker (G4PVReplica *pMasterObject)
void	TerminateWorker (G4PVReplica *pMasterObject)
Public Member Functions inherited from G4VPhysicalVolume
	G4VPhysicalVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother)
virtual	~G4VPhysicalVolume ()
	G4VPhysicalVolume (const G4VPhysicalVolume &)=delete
G4VPhysicalVolume &	operator= (const G4VPhysicalVolume &)=delete
G4bool	operator== (const G4VPhysicalVolume &p) const
G4RotationMatrix *	GetObjectRotation () const
G4RotationMatrix	GetObjectRotationValue () const
G4ThreeVector	GetObjectTranslation () const
const G4RotationMatrix *	GetFrameRotation () const
G4ThreeVector	GetFrameTranslation () const
const G4ThreeVector	GetTranslation () const
const G4RotationMatrix *	GetRotation () const
void	SetTranslation (const G4ThreeVector &v)
G4RotationMatrix *	GetRotation ()
void	SetRotation (G4RotationMatrix *)
G4LogicalVolume *	GetLogicalVolume () const
void	SetLogicalVolume (G4LogicalVolume *pLogical)
G4LogicalVolume *	GetMotherLogical () const
void	SetMotherLogical (G4LogicalVolume *pMother)
const G4String &	GetName () const
void	SetName (const G4String &pName)
	G4VPhysicalVolume (__void__ &)
G4int	GetInstanceID () const
EVolume	DeduceVolumeType () const

Additional Inherited Members
Static Public Member Functions inherited from G4PVReplica
static const G4PVRManager &	GetSubInstanceManager ()
Static Public Member Functions inherited from G4VPhysicalVolume
static const G4PVManager &	GetSubInstanceManager ()
static void	Clean ()
Protected Member Functions inherited from G4PVReplica
	G4PVReplica (const G4String &pName, G4int nReplicas, EAxis pAxis, G4LogicalVolume *pLogical, G4LogicalVolume *pMotherLogical)
Protected Member Functions inherited from G4VPhysicalVolume
void	InitialiseWorker (G4VPhysicalVolume *pMasterObject, G4RotationMatrix *pRot, const G4ThreeVector &tlate)
void	TerminateWorker (G4VPhysicalVolume *pMasterObject)
Protected Attributes inherited from G4PVReplica
EAxis	faxis
G4int	fnReplicas
G4double	fwidth
G4double	foffset
Protected Attributes inherited from G4VPhysicalVolume
G4int	instanceID
Static Protected Attributes inherited from G4VPhysicalVolume
static G4GEOM_DLL G4PVManager	subInstanceManager

Detailed Description

Definition at line 42 of file G4PVParameterised.hh.

Constructor & Destructor Documentation

G4PVParameterised() [1/3]

G4PVParameterised::G4PVParameterised	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4LogicalVolume *	pMotherLogical,
		const EAxis	pAxis,
		const G4int	nReplicas,
		G4VPVParameterisation *	pParam,
		G4bool	pSurfChk = false )

Definition at line 84 of file G4PVParameterised.cc.

  : G4PVReplica(pName, nReplicas, pAxis, pLogical, pMotherLogical ),
    fparam(pParam)
{
  SetMotherLogical( pMotherLogical );
  if( pMotherLogical != nullptr )
  {
    // Registration moved here to ensure that the volume is recognised as Parameterised
    pMotherLogical->AddDaughter(this);
  }
  if (pSurfChk) { CheckOverlaps(); }
}

G4PVParameterised() [2/3]

G4PVParameterised::G4PVParameterised	(	const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMother,
		const EAxis	pAxis,
		const G4int	nReplicas,
		G4VPVParameterisation *	pParam,
		G4bool	pSurfChk = false )

Definition at line 41 of file G4PVParameterised.cc.

: G4PVReplica(pName, nReplicas, pAxis, pLogical,
              pMotherPhysical != nullptr ? pMotherPhysical->GetLogicalVolume() : nullptr ),
    fparam(pParam)
{
  G4LogicalVolume* motherLogical= pMotherPhysical != nullptr ?
      pMotherPhysical->GetLogicalVolume() : nullptr;
 
  SetMotherLogical( motherLogical );
  if( motherLogical != nullptr )
  {
    // Registration moved here to ensure that the volume is recognised as Parameterised     
    motherLogical->AddDaughter(this);
  }
 
#ifdef G4VERBOSE  
  if ((pMotherPhysical != nullptr) && (pMotherPhysical->IsParameterised()))
  {
    std::ostringstream message, hint;
    message << "A parameterised volume is being placed" << G4endl
            << "inside another parameterised volume !";
    hint << "To make sure that no overlaps are generated," << G4endl
         << "you should verify the mother replicated shapes" << G4endl
         << "are of the same type and dimensions." << G4endl
         << "   Mother physical volume: " << pMotherPhysical->GetName() << G4endl
         << "   Parameterised volume: " << pName << G4endl
         << "  (To switch this warning off, compile with G4_NO_VERBOSE)";
    G4Exception("G4PVParameterised::G4PVParameterised()", "GeomVol1002",
                JustWarning, message, G4String(hint.str()));
  }
#endif
  if (pSurfChk) { CheckOverlaps(); }
}

G4PVParameterised() [3/3]

G4PVParameterised::G4PVParameterised

(

__void__ &

a

)

Definition at line 107 of file G4PVParameterised.cc.

  : G4PVReplica(a)
{
}

~G4PVParameterised()

G4PVParameterised::~G4PVParameterised ( )

overridedefault

Member Function Documentation

CheckOverlaps()

G4bool G4PVParameterised::CheckOverlaps ( G4int res = 1000, G4double tol = 0., G4bool verbose = true, G4int maxErr = 1 )

overridevirtual

Reimplemented from G4VPhysicalVolume.

Definition at line 172 of file G4PVParameterised.cc.

{
  if (res<=0) { return false; }
 
  G4int trials = 0;
  G4bool retval = false;
  G4VSolid *solidA = nullptr, *solidB = nullptr;
  G4LogicalVolume* motherLog = GetMotherLogical();
  G4VSolid *motherSolid = motherLog->GetSolid();
  std::vector<G4ThreeVector> points;
 
  if (verbose)
  {
    G4cout << "Checking overlaps for parameterised volume "
           << GetName() << " ... ";
  }
 
  for (auto i=0; i<GetMultiplicity(); ++i)
  {
    solidA = fparam->ComputeSolid(i, this);
    solidA->ComputeDimensions(fparam, i, this);
    fparam->ComputeTransformation(i, this);
 
    // Create the transformation from daughter to mother
    //
    G4AffineTransform Tm( GetRotation(), GetTranslation() );
 
    // Generate random points on surface according to the given resolution,
    // transform them to the mother's coordinate system and if no overlaps
    // with the mother volume, cache them in a vector for later use with
    // the daughters
    //
    for (auto n=0; n<res; ++n)
    {
      G4ThreeVector mp = Tm.TransformPoint(solidA->GetPointOnSurface());
 
      // Checking overlaps with the mother volume
      //
      if (motherSolid->Inside(mp)==kOutside)
      {
        G4double distin = motherSolid->DistanceToIn(mp);
        if (distin > tol)
        {
          ++trials; retval = true;
          std::ostringstream message;
          message << "Overlap with mother volume !" << G4endl
                  << "         Overlap is detected for volume "
                  << GetName() << ", parameterised instance: " << i << G4endl
                  << "          with its mother volume "
                  << motherLog->GetName() << G4endl
                  << "          at mother local point " << mp << ", "
                  << "overlapping by at least: "
                  << G4BestUnit(distin, "Length");
          if (trials>=maxErr)
          {
            message << G4endl
                    << "NOTE: Reached maximum fixed number -" << maxErr
                    << "- of overlaps reports for this volume !";
          }
          G4Exception("G4PVParameterised::CheckOverlaps()",
                      "GeomVol1002", JustWarning, message);
          if (trials>=maxErr)  { return true; }
        }
      }
      points.push_back(mp);
    }
 
    // Checking overlaps with each other parameterised instance
    //
    for (auto j=i+1; j<GetMultiplicity(); ++j)
    {
      solidB = fparam->ComputeSolid(j,this);
      solidB->ComputeDimensions(fparam, j, this);
      fparam->ComputeTransformation(j, this);
 
      // Create the transformation for daughter volume
      //
      G4AffineTransform Td( GetRotation(), GetTranslation() );
 
      for (const auto & point : points)
      {
        // Transform each point according to daughter's frame
        //
        G4ThreeVector md = Td.InverseTransformPoint(point);
 
        if (solidB->Inside(md)==kInside)
        {
          G4double distout = solidB->DistanceToOut(md);
          if (distout > tol)
          {
            ++trials; retval = true;
            std::ostringstream message;
            message << "Overlap within parameterised volumes !" << G4endl
                    << "          Overlap is detected for volume "
                    << GetName() << ", parameterised instance: " << i << G4endl
                    << "          with parameterised volume instance: " << j
                    << G4endl
                    << "          at local point " << md << ", "
                    << "overlapping by at least: "
                    << G4BestUnit(distout, "Length")
                    << ", related to volume instance: " << j << ".";
            if (trials>=maxErr)
            {
              message << G4endl
                      << "NOTE: Reached maximum fixed number -" << maxErr
                      << "- of overlaps reports for this volume !";
            }
            G4Exception("G4PVParameterised::CheckOverlaps()",
                        "GeomVol1002", JustWarning, message);
            if (trials>=maxErr)  { return true; }
          }
        }
      }
    }
  }
  if (verbose)
  {
    G4cout << "OK! " << G4endl;
  }
 
  return retval;
}

Referenced by G4PVParameterised(), and G4PVParameterised().

GetParameterisation()

G4VPVParameterisation * G4PVParameterised::GetParameterisation ( ) const

overridevirtual

Implements G4VPhysicalVolume.

Definition at line 120 of file G4PVParameterised.cc.

{
  return fparam;
}

Referenced by G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), and G4tgbGeometryDumper::DumpPVParameterised().

GetReplicationData()

void G4PVParameterised::GetReplicationData ( EAxis & axis, G4int & nReplicas, G4double & width, G4double & offset, G4bool & consuming ) const

overridevirtual

Implements G4VPhysicalVolume.

Definition at line 144 of file G4PVParameterised.cc.

{
  axis = faxis;
  nReplicas = fnReplicas;
  width = fwidth;
  offset = foffset;
  consuming = false;
}

Referenced by G4tgbGeometryDumper::DumpPVParameterised().

IsParameterised()

G4bool G4PVParameterised::IsParameterised ( ) const

overridevirtual

Implements G4VPhysicalVolume.

Definition at line 128 of file G4PVParameterised.cc.

{
  return true;
}

SetRegularStructureId()

void G4PVParameterised::SetRegularStructureId ( G4int code )

overridevirtual

Reimplemented from G4PVReplica.

Definition at line 160 of file G4PVParameterised.cc.

{
  G4PVReplica::SetRegularStructureId( code );
  // To undertake additional preparation, a derived volume must
  // redefine this method, while calling also the above method
}

VolumeType()

EVolume G4PVParameterised::VolumeType ( ) const

finalvirtual

Implements G4VPhysicalVolume.

Definition at line 136 of file G4PVParameterised.cc.

{
  return kParameterised;
}

---

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

• G4PVParameterised.hh
• G4PVParameterised.cc