G4PVPlacement Class Reference

#include <G4PVPlacement.hh>

Inheritance diagram for G4PVPlacement:

Collaboration 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__ &)
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
Public Member Functions inherited from G4VPhysicalVolume
	G4VPhysicalVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother)
virtual	~G4VPhysicalVolume ()
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)
EVolume	VolumeType () const
virtual G4int	GetMultiplicity () const
	G4VPhysicalVolume (__void__ &)
G4int	GetInstanceID () const

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicalVolume
static const G4PVManager &	GetSubInstanceManager ()
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 51 of file G4PVPlacement.hh.

Constructor & Destructor Documentation

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

Definition at line 100 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(pRot,tlate,pName,pCurrentLogical,0),
    fmany(pMany), fallocatedRotM(false), 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(); }
}

Here is the call graph for this function:

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

Definition at line 125 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(0,Transform3D.getTranslation(),pName,pCurrentLogical,0),
    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() != 0);
  SetMotherLogical(pMotherLogical);
  if (pMotherLogical) { pMotherLogical->AddDaughter(this); }
  if ((pSurfChk) && (pMotherLogical)) { CheckOverlaps(); }
}

Here is the call graph for this function:

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

Definition at line 43 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(pRot,tlate,pName,pLogical,pMother),
    fmany(pMany), fallocatedRotM(false), 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(); }
  }
}

Here is the call graph for this function:

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

Definition at line 71 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(); }
  }
}

Here is the call graph for this function:

G4PVPlacement::~G4PVPlacement ( )

virtual

Definition at line 159 of file G4PVPlacement.cc.

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

Here is the call graph for this function:

G4PVPlacement::G4PVPlacement

(

__void__ &

a

)

Definition at line 151 of file G4PVPlacement.cc.

  : G4VPhysicalVolume(a), fmany(false), fallocatedRotM(0), fcopyNo(0)
{
}

Member Function Documentation

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

virtual

Reimplemented from G4VPhysicalVolume.

Definition at line 236 of file G4PVPlacement.cc.

{
  if (res<=0) { return false; }

  G4VSolid* solid = GetLogicalVolume()->GetSolid();
  G4LogicalVolume* motherLog = GetMotherLogical();
  if (!motherLog) { return false; }

  G4int trials = 0;
  G4bool retval = false;

  G4VSolid* motherSolid = motherLog->GetSolid();

  if (verbose)
  {
    G4cout << "Checking overlaps for volume " << GetName() << " ... ";
  }

  // Create the transformation from daughter to mother
  //
  G4AffineTransform Tm( GetRotation(), GetTranslation() );

  for (G4int n=0; n<res; n++)
  {
    // Generate a random point on the solid's surface
    //
    G4ThreeVector point = solid->GetPointOnSurface();

    // Transform the generated point to the mother's coordinate system
    //
    G4ThreeVector mp = Tm.TransformPoint(point);

    // 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() << 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("G4PVPlacement::CheckOverlaps()",
                    "GeomVol1002", JustWarning, message);
        if (trials>=maxErr)  { return true; }
      }
    }

    // Checking overlaps with each 'sister' volume
    //
    for (G4int i=0; i<motherLog->GetNoDaughters(); i++)
    {
      G4VPhysicalVolume* daughter = motherLog->GetDaughter(i);

      if (daughter == this) { continue; }

      // Create the transformation for daughter volume and transform point
      //
      G4AffineTransform Td( daughter->GetRotation(),
                            daughter->GetTranslation() );
      G4ThreeVector md = Td.Inverse().TransformPoint(mp);

      G4VSolid* daughterSolid = daughter->GetLogicalVolume()->GetSolid();
      if (daughterSolid->Inside(md)==kInside)
      {
        G4double distout = daughterSolid->DistanceToOut(md);
        if (distout > tol)
        {
          trials++; retval = true;
          std::ostringstream message;
          message << "Overlap with volume already placed !" << G4endl
                  << "          Overlap is detected for volume "
                  << GetName() << G4endl
                  << "          with " << daughter->GetName() << " volume's"
                  << G4endl
                  << "          local point " << md << ", "
                  << "overlapping by at least: "
                  << G4BestUnit(distout,"Length");
          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; }
        }
      }

      // Now checking that 'sister' volume is not totally included and
      // overlapping. Do it only once, for the first point generated
      //
      if (n==0)
      {
        // Generate a single point on the surface of the 'sister' volume
        // and verify that the point is NOT inside the current volume

        G4ThreeVector dPoint = daughterSolid->GetPointOnSurface();

        // Transform the generated point to the mother's coordinate system
        // and finally to current volume's coordinate system
        //
        G4ThreeVector mp2 = Td.TransformPoint(dPoint);
        G4ThreeVector msi = Tm.Inverse().TransformPoint(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() << G4endl
                  << "          apparently fully encapsulating volume "
                  << daughter->GetName() << G4endl
                  << "          at the same level !";
          G4Exception("G4PVPlacement::CheckOverlaps()",
                      "GeomVol1002", JustWarning, message);
          if (trials>=maxErr)  { return true; }
        }
      }
    }
  }

  if (verbose)
  {
    G4cout << "OK! " << G4endl;
  }

  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4PVPlacement::GetCopyNo ( ) const

inlinevirtual

Implements G4VPhysicalVolume.

Definition at line 125 of file G4PVPlacement.hh.

{ return fcopyNo; }

G4VPVParameterisation * G4PVPlacement::GetParameterisation ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 199 of file G4PVPlacement.cc.

{
  return 0;
}

G4int G4PVPlacement::GetRegularStructureId ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 228 of file G4PVPlacement.cc.

{
  return 0;  
}           

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

virtual

Implements G4VPhysicalVolume.

Definition at line 208 of file G4PVPlacement.cc.

{
  // No-operations
}

G4bool G4PVPlacement::IsMany ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 167 of file G4PVPlacement.cc.

{
  return fmany; 
}

G4bool G4PVPlacement::IsParameterised ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 191 of file G4PVPlacement.cc.

{
  return false;
}

G4bool G4PVPlacement::IsRegularStructure ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 218 of file G4PVPlacement.cc.

{
  return false;
}           

G4bool G4PVPlacement::IsReplicated ( ) const

virtual

Implements G4VPhysicalVolume.

Definition at line 183 of file G4PVPlacement.cc.

{
  return false;
}

void G4PVPlacement::SetCopyNo ( G4int  CopyNo )

virtual

Implements G4VPhysicalVolume.

Definition at line 175 of file G4PVPlacement.cc.

{
  fcopyNo= newCopyNo;
}

---

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

• geant4.10.03.p01/source/geometry/volumes/include/G4PVPlacement.hh
• geant4.10.03.p01/source/geometry/volumes/src/G4PVPlacement.cc