G4PVPlacement Class Reference

#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)
virtual	~G4PVPlacement ()
G4int	GetCopyNo () const
void	SetCopyNo (G4int CopyNo)
G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1)
	G4PVPlacement (__void__ &)
	G4PVPlacement (const G4PVPlacement &)=delete
G4PVPlacement &	operator= (const G4PVPlacement &)=delete
G4bool	IsMany () const
G4bool	IsReplicated () const
G4bool	IsParameterised () const
G4VPVParameterisation *	GetParameterisation () const
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
G4bool	IsRegularStructure () const
G4int	GetRegularStructureId () const
EVolume	VolumeType () const
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)
virtual G4int	GetMultiplicity () const
virtual EVolume	VolumeType () const =0
virtual G4bool	IsMany () const =0
virtual G4int	GetCopyNo () const =0
virtual void	SetCopyNo (G4int CopyNo)=0
virtual G4bool	IsReplicated () const =0
virtual G4bool	IsParameterised () const =0
virtual G4VPVParameterisation *	GetParameterisation () const =0
virtual void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
virtual G4bool	IsRegularStructure () const =0
virtual G4int	GetRegularStructureId () const =0
virtual G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int errMax=1)
	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

Definition at line 43 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
	)

Definition at line 96 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) { pMotherLogical->AddDaughter(this); }
  if ((pSurfChk) && (pMotherLogical)) { CheckOverlaps(); }
}

G4PVPlacement() [2/6]

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

Definition at line 121 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) { pMotherLogical->AddDaughter(this); }
  if ((pSurfChk) && (pMotherLogical)) { 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
	)

Definition at line 39 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(pRot, tlate, pName, pLogical, pMother),
    fmany(pMany), fcopyNo(pCopyNo)
{
  if (pMother)
  {
    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
	)

Definition at line 67 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(NewPtrRotMatrix(Transform3D.getRotation().inverse()),
                      Transform3D.getTranslation(), pName, pLogical, pMother),
    fmany(pMany), fcopyNo(pCopyNo)
{
  fallocatedRotM = (GetRotation() != 0);
  if (pMother)
  {
    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()

G4PVPlacement::~G4PVPlacement ( )

virtual

Definition at line 156 of file G4PVPlacement.cc.

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

G4PVPlacement() [5/6]

G4PVPlacement::G4PVPlacement

(

__void__ &

a

)

Definition at line 148 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(a)
{
}

G4PVPlacement() [6/6]

G4PVPlacement::G4PVPlacement ( const G4PVPlacement &  )

delete

Member Function Documentation

CheckOverlaps()

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

virtual

Reimplemented from G4VPhysicalVolume.

Definition at line 243 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, ymin =  kInfinity, zmin =  kInfinity;
  G4double xmax = -kInfinity, ymax = -kInfinity, 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.), 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), 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, dymin =  kInfinity, dzmin =  kInfinity;
      G4double dxmax = -kInfinity, dymax = -kInfinity, dzmax = -kInfinity;
      for (G4int i = 0; i < 8; ++i)
      {
        G4ThreeVector p = Td.TransformPoint(pbox[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().

GetCopyNo()

G4int G4PVPlacement::GetCopyNo ( ) const

inlinevirtual

Implements G4VPhysicalVolume.

Definition at line 117 of file G4PVPlacement.hh.

{ return fcopyNo; }

Referenced by CheckOverlaps().

GetParameterisation()

G4VPVParameterisation * G4PVPlacement::GetParameterisation ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 196 of file G4PVPlacement.cc.

{
  return nullptr;
}

GetRegularStructureId()

G4int G4PVPlacement::GetRegularStructureId ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 225 of file G4PVPlacement.cc.

{
  return 0;
}

GetReplicationData()

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

virtual

Implements G4VPhysicalVolume.

Definition at line 204 of file G4PVPlacement.cc.

{
  // No-operations
}

IsMany()

G4bool G4PVPlacement::IsMany ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 164 of file G4PVPlacement.cc.

{
  return fmany;
}

IsParameterised()

G4bool G4PVPlacement::IsParameterised ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 188 of file G4PVPlacement.cc.

{
  return false;
}

IsRegularStructure()

G4bool G4PVPlacement::IsRegularStructure ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 215 of file G4PVPlacement.cc.

{
  return false;
}

IsReplicated()

G4bool G4PVPlacement::IsReplicated ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 180 of file G4PVPlacement.cc.

{
  return false;
}

operator=()

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

delete

SetCopyNo()

void G4PVPlacement::SetCopyNo ( G4int  CopyNo )

virtual

Implements G4VPhysicalVolume.

Definition at line 172 of file G4PVPlacement.cc.

{
  fcopyNo = newCopyNo;
}

VolumeType()

EVolume G4PVPlacement::VolumeType ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 235 of file G4PVPlacement.cc.

{
  return kNormal;
}

---

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

• G4PVPlacement.hh
• G4PVPlacement.cc