G4PVPlacement Class Reference

G4PVPlacement represents a single volume positioned within and relative to a mother volume. More...

#include <G4PVPlacement.hh>

Inheritance diagram for G4PVPlacement:

Public Member Functions
	G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
	G4PVPlacement (const G4Transform3D &Transform3D, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
	G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
	G4PVPlacement (const G4Transform3D &Transform3D, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
	G4PVPlacement (__void__ &)
	~G4PVPlacement () override
	G4PVPlacement (const G4PVPlacement &)=delete
G4PVPlacement &	operator= (const G4PVPlacement &)=delete
G4int	GetCopyNo () const override
void	SetCopyNo (G4int CopyNo) override
G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1) override
G4bool	IsMany () const override
G4bool	IsReplicated () const override
G4bool	IsParameterised () const override
G4VPVParameterisation *	GetParameterisation () const override
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const override
G4bool	IsRegularStructure () const override
G4int	GetRegularStructureId () const override
EVolume	VolumeType () const override
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
G4RotationMatrix *	GetRotation ()
void	SetTranslation (const G4ThreeVector &v)
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)
virtual G4int	GetMultiplicity () const
	G4VPhysicalVolume (__void__ &)
G4int	GetInstanceID () const
EVolume	DeduceVolumeType () const

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicalVolume
static const G4PVManager &	GetSubInstanceManager ()
static void	Clean ()
Protected Member Functions inherited from G4VPhysicalVolume
void	InitialiseWorker (G4VPhysicalVolume *pMasterObject, G4RotationMatrix *pRot, const G4ThreeVector &tlate)
void	TerminateWorker (G4VPhysicalVolume *pMasterObject)
Protected Attributes inherited from G4VPhysicalVolume
G4int	instanceID
Static Protected Attributes inherited from G4VPhysicalVolume
static G4GEOM_DLL G4PVManager	subInstanceManager

Detailed Description

G4PVPlacement represents a single volume positioned within and relative to a mother volume.

Definition at line 46 of file G4PVPlacement.hh.

Constructor & Destructor Documentation

G4PVPlacement() [1/6]

G4PVPlacement::G4PVPlacement	(	G4RotationMatrix *	pRot,
		const G4ThreeVector &	tlate,
		G4LogicalVolume *	pCurrentLogical,
		const G4String &	pName,
		G4LogicalVolume *	pMotherLogical,
		G4bool	pMany,
		G4int	pCopyNo,
		G4bool	pSurfChk = false )

Initialises a single volume, positioned in a frame which is rotated by '*pRot' and traslated by 'tlate', relative to the coordinate system of the mother volume 'pMotherLogical'. If 'pRot=nullptr' the volume is unrotated with respect to its mother. The physical volume is added to the mother's logical volume. This is a very natural way of defining a physical volume, and is especially useful when creating subdetectors: the mother volumes are not placed until a later stage of the assembly program.

Parameters

[in]	pRot	The pointer to the rotation in the mother volume.
[in]	tlate	Traslation vector in the mother volume.
[in]	pCurrentLogical	Pointer to its logical volume.
[in]	pName	The volume name.
[in]	pMotherLogical	Pointer to the logical volume of the mother.
[in]	pMany	Flag to identify if the volume is meant to be considered an overlapping structure, or not. - not used.
[in]	pCopyNo	The optional custom copy number. Should be set to 0 for the first volume of a given type.
[in]	pSurfChk	Boolean flag, if true activates check for overlaps with existing volumes (false by default).

Definition at line 99 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(pRot, tlate, pName, pCurrentLogical, nullptr),
    fmany(pMany), fcopyNo(pCopyNo)
{
  if (pCurrentLogical == pMotherLogical)
  {
    G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
                FatalException, "Cannot place a volume inside itself!");
  }
  SetMotherLogical(pMotherLogical);
  if (pMotherLogical != nullptr) { pMotherLogical->AddDaughter(this); }
  if ((pSurfChk) && ((pMotherLogical) != nullptr)) { CheckOverlaps(); }
}

Referenced by G4PVPlacement(), and operator=().

G4PVPlacement() [2/6]

G4PVPlacement::G4PVPlacement	(	const G4Transform3D &	Transform3D,
		G4LogicalVolume *	pCurrentLogical,
		const G4String &	pName,
		G4LogicalVolume *	pMotherLogical,
		G4bool	pMany,
		G4int	pCopyNo,
		G4bool	pSurfChk = false )

Additional constructor, which expects a G4Transform3D object that represents the direct rotation and translation of the solid (NOT of the frame). The G4Transform3D argument should be constructed by: i) First rotating it to align the solid to the system of reference of its mother volume *pMotherLogical, and ii) Then placing the solid at the location Transform3D.getTranslation(), with respect to the origin of the system of coordinates of the mother volume.
This construct is useful for the people who prefer to think in terms of moving objects in a given reference frame. All other arguments are the same as for the previous constructor.

Parameters

[in]	Transform3D	The transformation in the 3D space.
[in]	pCurrentLogical	Pointer to its logical volume.
[in]	pName	The volume name.
[in]	pMotherLogical	Pointer to the logical volume of the mother.
[in]	pMany	Flag to identify if the volume is meant to be considered an overlapping structure, or not. - not used.
[in]	pCopyNo	The optional custom copy number. Should be set to 0 for the first volume of a given type.
[in]	pSurfChk	Boolean flag, if true activates check for overlaps with existing volumes (false by default).

Definition at line 123 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(nullptr, Transform3D.getTranslation(),
                      pName, pCurrentLogical, nullptr),
    fmany(pMany), fcopyNo(pCopyNo)
{
  if (pCurrentLogical == pMotherLogical)
  {
    G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
                FatalException, "Cannot place a volume inside itself!");
  }
  SetRotation( NewPtrRotMatrix(Transform3D.getRotation().inverse()) );
  fallocatedRotM = (GetRotation() != nullptr);
  SetMotherLogical(pMotherLogical);
  if (pMotherLogical != nullptr) { pMotherLogical->AddDaughter(this); }
  if ((pSurfChk) && ((pMotherLogical) != nullptr)) { CheckOverlaps(); }
}

G4PVPlacement() [3/6]

G4PVPlacement::G4PVPlacement	(	G4RotationMatrix *	pRot,
		const G4ThreeVector &	tlate,
		const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMother,
		G4bool	pMany,
		G4int	pCopyNo,
		G4bool	pSurfChk = false )

A simple variation of the first constructor, only specifying the mother volume as a pointer to its physical volume instead of its logical volume. The effect is exactly the same.

Definition at line 40 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(pRot, tlate, pName, pLogical, pMother),
    fmany(pMany), fcopyNo(pCopyNo)
{
  if (pMother != nullptr)
  {
    G4LogicalVolume* motherLogical = pMother->GetLogicalVolume();
    if (pLogical == motherLogical)
    {
      G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
                  FatalException, "Cannot place a volume inside itself!");
    }
    SetMotherLogical(motherLogical);
    motherLogical->AddDaughter(this);
    if (pSurfChk) { CheckOverlaps(); }
  }
}

G4PVPlacement() [4/6]

G4PVPlacement::G4PVPlacement	(	const G4Transform3D &	Transform3D,
		const G4String &	pName,
		G4LogicalVolume *	pLogical,
		G4VPhysicalVolume *	pMother,
		G4bool	pMany,
		G4int	pCopyNo,
		G4bool	pSurfChk = false )

Utilises both variations above (from first and third constructors). The effect is the same as for the second constructor.

Definition at line 68 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(NewPtrRotMatrix(Transform3D.getRotation().inverse()),
                      Transform3D.getTranslation(), pName, pLogical, pMother),
    fmany(pMany), fcopyNo(pCopyNo)
{
  fallocatedRotM = (GetRotation() != nullptr);
  if (pMother != nullptr)
  {
    G4LogicalVolume* motherLogical = pMother->GetLogicalVolume();
    if (pLogical == motherLogical)
    {
      G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
                  FatalException, "Cannot place a volume inside itself!");
    }
    SetMotherLogical(motherLogical);
    motherLogical->AddDaughter(this);
    if (pSurfChk) { CheckOverlaps(); }
  }
}

G4PVPlacement() [5/6]

G4PVPlacement::G4PVPlacement

(

__void__ &

a

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 150 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(a)
{
}

~G4PVPlacement()

G4PVPlacement::~G4PVPlacement ( )

override

Default Destructor.

Definition at line 158 of file G4PVPlacement.cc.

{
  if( fallocatedRotM ){ delete this->GetRotation() ; }
}

G4PVPlacement() [6/6]

G4PVPlacement::G4PVPlacement ( const G4PVPlacement & )

delete

Copy constructor and assignment operator not allowed.

Member Function Documentation

CheckOverlaps()

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

overridevirtual

Verifies if the placed volume is overlapping with existing daughters or with the mother volume. Provides default resolution for the number of points to be generated and verified. A tolerance for the precision of the overlap check can be specified, by default it is set to maximum precision. Reports a maximum of overlaps errors according to parameter in input.

Parameters

[in]	res	The number of points to generate on volume's surface.
[in]	tol	The precision tolerance for the overlap check, below which to ignore overlaps (default is maximim precision).
[in]	verbose	Verbosity mode (default is true).
[in]	maxErr	Maximum of overlaps errors to report (default is 1).

Returns

True if an overlap occurs.

Reimplemented from G4VPhysicalVolume.

Definition at line 245 of file G4PVPlacement.cc.

{
  if (res <= 0) { return false; }
 
  G4VSolid* solid = GetLogicalVolume()->GetSolid();
  G4LogicalVolume* motherLog = GetMotherLogical();
  if (motherLog == nullptr) { return false; }
 
  G4int trials = 0;
  G4bool retval = false;
 
  if (verbose)
  {
    G4cout << "Checking overlaps for volume "
           << GetName() << ':' << GetCopyNo()
           << " (" << solid->GetEntityType() << ") ... ";
  }
 
  // Check that random points are gererated correctly
  //
  G4ThreeVector ptmp = solid->GetPointOnSurface();
  if (solid->Inside(ptmp) != kSurface)
  {
    G4String position[3] = { "outside", "surface", "inside" };
    std::ostringstream message;
    message << "Sample point is not on the surface !" << G4endl
            << "          The issue is detected for volume "
            << GetName() << ':' << GetCopyNo()
            << " (" << solid->GetEntityType() << ")" << G4endl
            << "          generated point " << ptmp
            << " is " << position[solid->Inside(ptmp)];
    G4Exception("G4PVPlacement::CheckOverlaps()",
                "GeomVol1002", JustWarning, message);
    return false;
  }
 
  // Generate random points on the surface of the solid,
  // transform them into the mother volume coordinate system
  // and find the bonding box
  //
  std::vector<G4ThreeVector> points(res);
  G4double xmin =  kInfinity;
  G4double ymin =  kInfinity;
  G4double zmin =  kInfinity;
  G4double xmax = -kInfinity;
  G4double ymax = -kInfinity;
  G4double zmax = -kInfinity;
  G4AffineTransform Tm(GetRotation(), GetTranslation());
  for (G4int i = 0; i < res; ++i)
  {
    points[i] = Tm.TransformPoint(solid->GetPointOnSurface());
    xmin = std::min(xmin, points[i].x());
    ymin = std::min(ymin, points[i].y());
    zmin = std::min(zmin, points[i].z());
    xmax = std::max(xmax, points[i].x());
    ymax = std::max(ymax, points[i].y());
    zmax = std::max(zmax, points[i].z());
  }
  G4ThreeVector scenter(0.5*(xmax+xmin), 0.5*(ymax+ymin), 0.5*(zmax+zmin));
  G4double sradius = 0.5*G4ThreeVector(xmax-xmin, ymax-ymin, zmax-zmin).mag();
 
  // Check overlap with the mother volume
  //
  G4int overlapCount = 0;
  G4double overlapSize = -kInfinity;
  G4ThreeVector overlapPoint;
  G4VSolid* motherSolid = motherLog->GetSolid();
  for (G4int i = 0; i < res; ++i)
  {
    G4ThreeVector mp = points[i];
    if (motherSolid->Inside(mp) != kOutside) { continue; }
    G4double distin = motherSolid->DistanceToIn(mp);
    if (distin < tol) { continue; } // too small overlap
    ++overlapCount;
    if (distin <= overlapSize) { continue; }
    overlapSize = distin;
    overlapPoint = mp;
  }
 
  // Print information on overlap
  //
  if (overlapCount > 0)
  {
    ++trials;
    retval = true;
    std::ostringstream message;
    message << "Overlap with mother volume !" << G4endl
            << "          Overlap is detected for volume "
            << GetName() << ':' << GetCopyNo()
            << " (" << solid->GetEntityType() << ")"
            << " with its mother volume " << motherLog->GetName()
            << " (" << motherSolid->GetEntityType() << ")" << G4endl
            << "          protrusion at mother local point " << overlapPoint
            << " by " << G4BestUnit(overlapSize, "Length")
            << " (max of " << overlapCount << " cases)";
    if (trials >= maxErr)
    {
      message << G4endl
              << "NOTE: Reached maximum fixed number -" << maxErr
              << "- of overlaps reports for this volume !";
    }
    G4Exception("G4PVPlacement::CheckOverlaps()",
                "GeomVol1002", JustWarning, message);
    if (trials >= maxErr)  { return true; }
  }
 
  // Checking overlaps with each 'sister' volumes
  //
  G4VSolid* previous = nullptr;
  G4ThreeVector pmin_local(0.,0.,0.);
  G4ThreeVector pmax_local(0.,0.,0.);
 
  for (std::size_t k = 0; k < motherLog->GetNoDaughters(); ++k)
  {
    G4VPhysicalVolume* daughter = motherLog->GetDaughter((G4int)k);
    if (daughter == this) { continue; }
    G4bool check_encapsulation = true;
 
    G4AffineTransform Td(daughter->GetRotation(), daughter->GetTranslation());
    G4VSolid* daughterSolid = daughter->GetLogicalVolume()->GetSolid();
    if (previous != daughterSolid)
    {
      daughterSolid->BoundingLimits(pmin_local, pmax_local);
      previous = daughterSolid;
    }
    overlapCount = 0;
    overlapSize = -kInfinity;
    if (!Td.IsRotated()) { // no rotation, only translation
      G4ThreeVector offset = Td.NetTranslation();
      G4ThreeVector pmin(pmin_local + offset);
      G4ThreeVector pmax(pmax_local + offset);
      if (pmin.x() >= xmax) { continue; }
      if (pmin.y() >= ymax) { continue; }
      if (pmin.z() >= zmax) { continue; }
      if (pmax.x() <= xmin) { continue; }
      if (pmax.y() <= ymin) { continue; }
      if (pmax.z() <= zmin) { continue; }
      for (G4int i = 0; i < res; ++i)
      {
        G4ThreeVector p = points[i];
        if (p.x() <= pmin.x()) { continue; }
        if (p.x() >= pmax.x()) { continue; }
        if (p.y() <= pmin.y()) { continue; }
        if (p.y() >= pmax.y()) { continue; }
        if (p.z() <= pmin.z()) { continue; }
        if (p.z() >= pmax.z()) { continue; }
        G4ThreeVector md = p - offset;
        if (daughterSolid->Inside(md) == kInside)
        {
          check_encapsulation = false;
          G4double distout = daughterSolid->DistanceToOut(md);
          if (distout < tol) { continue; } // too small overlap
          ++overlapCount;
          if (distout <= overlapSize) { continue; }
          overlapSize = distout;
          overlapPoint = md;
        }
      }
    }
    else // transformation with rotation
    {
      G4ThreeVector pmin(pmin_local);
      G4ThreeVector pmax(pmax_local);
      G4ThreeVector dcenter = Td.TransformPoint(0.5*(pmin + pmax));
      G4double dradius = 0.5*((pmax - pmin).mag());
      if ((scenter - dcenter).mag2() >= (sradius + dradius)*(sradius + dradius)) { continue; }
      if (dcenter.x() - dradius >= xmax) { continue; }
      if (dcenter.y() - dradius >= ymax) { continue; }
      if (dcenter.z() - dradius >= zmax) { continue; }
      if (dcenter.x() + dradius <= xmin) { continue; }
      if (dcenter.y() + dradius <= ymin) { continue; }
      if (dcenter.z() + dradius <= zmin) { continue; }
 
      G4ThreeVector pbox[8] =
      {
        G4ThreeVector(pmin.x(), pmin.y(), pmin.z()),
        G4ThreeVector(pmax.x(), pmin.y(), pmin.z()),
        G4ThreeVector(pmin.x(), pmax.y(), pmin.z()),
        G4ThreeVector(pmax.x(), pmax.y(), pmin.z()),
        G4ThreeVector(pmin.x(), pmin.y(), pmax.z()),
        G4ThreeVector(pmax.x(), pmin.y(), pmax.z()),
        G4ThreeVector(pmin.x(), pmax.y(), pmax.z()),
        G4ThreeVector(pmax.x(), pmax.y(), pmax.z())
      };
      G4double dxmin =  kInfinity;
      G4double dymin =  kInfinity;
      G4double dzmin =  kInfinity;
      G4double dxmax = -kInfinity;
      G4double dymax = -kInfinity;
      G4double dzmax = -kInfinity;
      for (const auto & i : pbox)
      {
        G4ThreeVector p = Td.TransformPoint(i);
        dxmin = std::min(dxmin, p.x());
        dymin = std::min(dymin, p.y());
        dzmin = std::min(dzmin, p.z());
        dxmax = std::max(dxmax, p.x());
        dymax = std::max(dymax, p.y());
        dzmax = std::max(dzmax, p.z());
      }
      if (dxmin >= xmax) { continue; }
      if (dymin >= ymax) { continue; }
      if (dzmin >= zmax) { continue; }
      if (dxmax <= xmin) { continue; }
      if (dymax <= ymin) { continue; }
      if (dzmax <= zmin) { continue; }
      for (G4int i = 0; i < res; ++i)
      {
        G4ThreeVector p = points[i];
        if (p.x() >= dxmax) { continue; }
        if (p.x() <= dxmin) { continue; }
        if (p.y() >= dymax) { continue; }
        if (p.y() <= dymin) { continue; }
        if (p.z() >= dzmax) { continue; }
        if (p.z() <= dzmin) { continue; }
        G4ThreeVector md = Td.InverseTransformPoint(p);
        if (daughterSolid->Inside(md) == kInside)
        {
          check_encapsulation = false;
          G4double distout = daughterSolid->DistanceToOut(md);
          if (distout < tol) { continue; } // too small overlap
          ++overlapCount;
          if (distout <= overlapSize) { continue; }
          overlapSize = distout;
          overlapPoint = md;
        }
      }
    }
 
    // Print information on overlap
    //
    if (overlapCount > 0)
    {
      ++trials;
      retval = true;
      std::ostringstream message;
      message << "Overlap with volume already placed !" << G4endl
              << "          Overlap is detected for volume "
              << GetName() << ':' << GetCopyNo()
              << " (" << solid->GetEntityType() << ") with "
              << daughter->GetName() << ':' << daughter->GetCopyNo()
              << " (" << daughterSolid->GetEntityType() << ")" << G4endl
              << "          overlap at local point " << overlapPoint
              << " by " << G4BestUnit(overlapSize, "Length")
              << " (max of " << overlapCount << " cases)";
      if (trials >= maxErr)
      {
        message << G4endl
                << "NOTE: Reached maximum fixed number -" << maxErr
                << "- of overlaps reports for this volume !";
      }
      G4Exception("G4PVPlacement::CheckOverlaps()",
                  "GeomVol1002", JustWarning, message);
      if (trials >= maxErr)  { return true; }
    }
    else if (check_encapsulation)
    {
      // Now checking that 'sister' volume is not totally included
      // and overlapping. Generate a single point inside of
      // the 'sister' volume and verify that the point in NOT inside
      // the current volume
      //
      G4ThreeVector pSurface = daughterSolid->GetPointOnSurface();
      G4ThreeVector normal = daughterSolid->SurfaceNormal(pSurface);
      G4ThreeVector pInside = pSurface - normal*1.e-4; // move point to inside
      G4ThreeVector dPoint = (daughterSolid->Inside(pInside) == kInside) ?
        pInside : pSurface;
 
      // Transform the generated point to the mother's coordinate system
      // and then to current volume's coordinate system
      //
      G4ThreeVector mp2 = Td.TransformPoint(dPoint);
      G4ThreeVector msi = Tm.InverseTransformPoint(mp2);
 
      if (solid->Inside(msi) == kInside)
      {
        ++trials;
        retval = true;
        std::ostringstream message;
        message << "Overlap with volume already placed !" << G4endl
                << "          Overlap is detected for volume "
                << GetName() << ':' << GetCopyNo()
                << " (" << solid->GetEntityType() << ")" << G4endl
                << "          apparently fully encapsulating volume "
                << daughter->GetName() << ':' << daughter->GetCopyNo()
                << " (" << daughterSolid->GetEntityType() << ")"
                << " at the same level!";
        if (trials >= maxErr)
        {
          message << G4endl
                  << "NOTE: Reached maximum fixed number -" << maxErr
                  << "- of overlaps reports for this volume !";
        }
        G4Exception("G4PVPlacement::CheckOverlaps()",
                    "GeomVol1002", JustWarning, message);
        if (trials >= maxErr)  { return true; }
      }
    }
  }
 
  if (verbose && trials == 0) { G4cout << "OK! " << G4endl; }
  return retval;
}

Referenced by G4PVPlacement(), G4PVPlacement(), G4PVPlacement(), and G4PVPlacement().

GetCopyNo()

G4int G4PVPlacement::GetCopyNo ( ) const

inlineoverridevirtual

Returns/sets the copy number associated to the volume.

Implements G4VPhysicalVolume.

Definition at line 158 of file G4PVPlacement.hh.

{ return fcopyNo; }

Referenced by CheckOverlaps().

GetParameterisation()

G4VPVParameterisation * G4PVPlacement::GetParameterisation ( ) const

overridevirtual

Returns a pointer to the replicas parameterisation object/algorithm (able to compute dimensions and transformations of replicas), or a null pointer if not applicable.

Implements G4VPhysicalVolume.

Definition at line 198 of file G4PVPlacement.cc.

{
  return nullptr;
}

GetRegularStructureId()

G4int G4PVPlacement::GetRegularStructureId ( ) const

overridevirtual

Returns non-zero code in case the underlying volume structure is regular, voxel-like. The value is an identifier for the structure type. If non-zero the volume is a candidate for specialised navigation such as 'nearest neighbour' directly on volumes.

Implements G4VPhysicalVolume.

Definition at line 227 of file G4PVPlacement.cc.

{
  return 0;
}

GetReplicationData()

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

overridevirtual

Returns the replication information. No-op for non replicated volumes.

Parameters

[in,out]	axis	The axis of replication/parameterisation.
[in,out]	nReplicas	The number of replicated/parameterised objects.
[in,out]	width	The width of replicated object.
[in,out]	offset	The optional offset distance from mother's border.
[in,out]	consuming	Flag of replica characterisation (always true for pure replicas).

Implements G4VPhysicalVolume.

Definition at line 206 of file G4PVPlacement.cc.

{
  // No-operations
}

IsMany()

G4bool G4PVPlacement::IsMany ( ) const

overridevirtual

Stub methods, unused for placed volumes.

Implements G4VPhysicalVolume.

Definition at line 166 of file G4PVPlacement.cc.

{
  return fmany;
}

IsParameterised()

G4bool G4PVPlacement::IsParameterised ( ) const

overridevirtual

Returns true if the volume is parameterised (single object instance represents many real parameterised volumes), else false.

Implements G4VPhysicalVolume.

Definition at line 190 of file G4PVPlacement.cc.

{
  return false;
}

IsRegularStructure()

G4bool G4PVPlacement::IsRegularStructure ( ) const

overridevirtual

Used only for specialised repeated volumes. Always false with Id 0.

Implements G4VPhysicalVolume.

Definition at line 217 of file G4PVPlacement.cc.

{
  return false;
}

IsReplicated()

G4bool G4PVPlacement::IsReplicated ( ) const

overridevirtual

Returns true if the volume is replicated (single object instance represents many real volumes), else false.

Implements G4VPhysicalVolume.

Definition at line 182 of file G4PVPlacement.cc.

{
  return false;
}

operator=()

G4PVPlacement & G4PVPlacement::operator= ( const G4PVPlacement & )

delete

SetCopyNo()

void G4PVPlacement::SetCopyNo ( G4int CopyNo )

overridevirtual

Implements G4VPhysicalVolume.

Definition at line 174 of file G4PVPlacement.cc.

{
  fcopyNo = newCopyNo;
}

VolumeType()

EVolume G4PVPlacement::VolumeType ( ) const

overridevirtual

Returns the volume type characterisation.

Implements G4VPhysicalVolume.

Definition at line 237 of file G4PVPlacement.cc.

{
  return kNormal;
}

---

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

• G4PVPlacement.hh
• G4PVPlacement.cc