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__ &)
virtual	~G4PVParameterised ()
G4bool	IsParameterised () const
G4VPVParameterisation *	GetParameterisation () const
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
virtual void	SetRegularStructureId (G4int Code)
G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true)

---

Detailed Description

Definition at line 47 of file G4PVParameterised.hh.

---

Constructor & Destructor Documentation

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

Definition at line 78 of file G4PVParameterised.cc.

References CheckOverlaps().

  : G4PVReplica(pName, pLogical, pMotherLogical, pAxis, nReplicas, 0, 0),
    fparam(pParam)
{
  if (pSurfChk) { CheckOverlaps(); }
}

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

Definition at line 46 of file G4PVParameterised.cc.

References CheckOverlaps(), G4endl, G4Exception(), G4VPhysicalVolume::GetName(), G4VPhysicalVolume::IsParameterised(), and JustWarning.

  : G4PVReplica(pName, pLogical, pMother, pAxis, nReplicas, 0, 0),
    fparam(pParam)
{
#ifdef G4VERBOSE  
  if ((pMother) && (pMother->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: " << pMother->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::G4PVParameterised

(

__void__ &

)

Definition at line 95 of file G4PVParameterised.cc.

  : G4PVReplica(a), fparam(0)
{
}

G4PVParameterised::~G4PVParameterised

(

)

[virtual]

Definition at line 103 of file G4PVParameterised.cc.

{
}

---

Member Function Documentation

G4bool G4PVParameterised::CheckOverlaps	(	G4int	res = 1000,
		G4double	tol = 0.,
		G4bool	verbose = true
	)			[virtual]

Reimplemented from G4VPhysicalVolume.

Definition at line 154 of file G4PVParameterised.cc.

References G4VSolid::ComputeDimensions(), G4VPVParameterisation::ComputeSolid(), G4VPVParameterisation::ComputeTransformation(), G4VSolid::DistanceToIn(), G4BestUnit, G4cout, G4endl, G4Exception(), G4VPhysicalVolume::GetMotherLogical(), G4PVReplica::GetMultiplicity(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetPointOnSurface(), G4VPhysicalVolume::GetRotation(), G4LogicalVolume::GetSolid(), G4VPhysicalVolume::GetTranslation(), G4VSolid::Inside(), G4AffineTransform::Inverse(), JustWarning, kInside, kOutside, CLHEP::detail::n, and G4AffineTransform::TransformPoint().

Referenced by G4PVParameterised().

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

  G4VSolid *solidA = 0, *solidB = 0;
  G4LogicalVolume *motherLog = GetMotherLogical();
  G4VSolid *motherSolid = motherLog->GetSolid();
  std::vector<G4ThreeVector> points;

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

  for (G4int 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 (G4int 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)
        {
          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");
          G4Exception("G4PVParameterised::CheckOverlaps()",
                      "GeomVol1002", JustWarning, message);
          return true;
        }
      }
      points.push_back(mp);
    }

    // Checking overlaps with each other parameterised instance
    //
    std::vector<G4ThreeVector>::iterator pos;
    for (G4int 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 (pos=points.begin(); pos!=points.end(); pos++)
      {
        // Transform each point according to daughter's frame
        //
        G4ThreeVector md = Td.Inverse().TransformPoint(*pos);

        if (solidB->Inside(md)==kInside)
        {
          G4double distout = solidB->DistanceToOut(md);
          if (distout > tol)
          {
            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 << ".";
            G4Exception("G4PVParameterised::CheckOverlaps()",
                        "GeomVol1002", JustWarning, message);
            return true;
          }
        }
      }
    }
  }
  if (verbose)
  {
    G4cout << "OK! " << G4endl;
  }

  return false;
}

G4VPVParameterisation * G4PVParameterised::GetParameterisation

(

)

const [virtual]

Reimplemented from G4PVReplica.

Definition at line 110 of file G4PVParameterised.cc.

Referenced by G4tgbGeometryDumper::DumpPVParameterised().

{
  return fparam;
}

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

Reimplemented from G4PVReplica.

Definition at line 126 of file G4PVParameterised.cc.

References G4PVReplica::faxis, G4PVReplica::fnReplicas, G4PVReplica::foffset, and G4PVReplica::fwidth.

Referenced by G4tgbGeometryDumper::DumpPVParameterised().

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

G4bool G4PVParameterised::IsParameterised

(

)

const [virtual]

Reimplemented from G4PVReplica.

Definition at line 118 of file G4PVParameterised.cc.

{
  return true;
}

void G4PVParameterised::SetRegularStructureId

(

G4int

Code

)

[virtual]

Reimplemented from G4PVReplica.

Definition at line 142 of file G4PVParameterised.cc.

References G4PVReplica::SetRegularStructureId().

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

---

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

• G4PVParameterised.hh
• G4PVParameterised.cc

---