#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__ &)

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.

References G4LogicalVolume::AddDaughter(), CheckOverlaps(), FatalException, G4Exception(), and G4VPhysicalVolume::SetMotherLogical().

Referenced by LXeMainVolume::LXeMainVolume(), and LXeWLSFiber::LXeWLSFiber().

   : 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(); }
 }

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.

References G4LogicalVolume::AddDaughter(), CheckOverlaps(), FatalException, G4Exception(), G4VPhysicalVolume::GetRotation(), HepGeom::Transform3D::getRotation(), CLHEP::HepRotation::inverse(), G4VPhysicalVolume::SetMotherLogical(), and G4VPhysicalVolume::SetRotation().

   : 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(); }
 }

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.

References G4LogicalVolume::AddDaughter(), CheckOverlaps(), FatalException, G4Exception(), G4VPhysicalVolume::GetLogicalVolume(), and G4VPhysicalVolume::SetMotherLogical().

   : 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(); }
   }
 }

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.

References G4LogicalVolume::AddDaughter(), CheckOverlaps(), FatalException, G4Exception(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetRotation(), and G4VPhysicalVolume::SetMotherLogical().

   : 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 ( )

virtual

Definition at line 159 of file G4PVPlacement.cc.

References G4VPhysicalVolume::GetRotation().

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

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 244 of file G4PVPlacement.cc.

References G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), G4BestUnit, G4cout, G4endl, G4Exception(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4VPhysicalVolume::GetName(), G4LogicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4VSolid::GetPointOnSurface(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4VPhysicalVolume::GetTranslation(), G4VSolid::Inside(), G4AffineTransform::Inverse(), JustWarning, kInside, kOutside, n, and G4AffineTransform::TransformPoint().

Referenced by export_G4PVPlacement(), and G4PVPlacement().

 {
   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;
 }