G4PVParameterised Class Reference

G4PVParameterised represents many touchable detector elements differing in their positioning and dimensions. Both are calculated by means of a G4VParameterisation object. The positioning is assumed to be dominant along a specified Cartesian axis. More...

#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__ &)
	~G4PVParameterised () override=default
G4bool	IsParameterised () const override
EVolume	VolumeType () const final
G4VPVParameterisation *	GetParameterisation () const override
void	GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const override
void	SetRegularStructureId (G4int code) override
G4bool	CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1) override

Detailed Description

G4PVParameterised represents many touchable detector elements differing in their positioning and dimensions. Both are calculated by means of a G4VParameterisation object. The positioning is assumed to be dominant along a specified Cartesian axis.

Definition at line 49 of file G4PVParameterised.hh.

Constructor & Destructor Documentation

G4PVParameterised() [1/3]

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

Replicates the volume 'nReplicas' times using the paramaterisation 'pParam', within the mother volume 'pMotherLogical'. The positioning of the replicas is dominant along the specified axis.

Parameters

[in]	pName	The volume name.
[in]	pLogical	Pointer to the logical volume of the replica.
[in]	pMotherLogical	Pointer to the logical volume of the mother.
[in]	pAxis	The axis along which do the replication.
[in]	nReplicas	The number of copies to replicate.
[in]	pParam	Pointer to the provided parameterisation algorithm.
[in]	pSurfChk	Boolean flag, if true activates check for overlaps with existing volumes (false by default).

Definition at line 85 of file G4PVParameterised.cc.

  : G4PVReplica(pName, nReplicas, pAxis, pLogical, pMotherLogical ),
    fparam(pParam)
{
  SetMotherLogical( pMotherLogical );
  if( pMotherLogical != nullptr )
  {
    // Registration moved here to ensure that the volume is recognised as Parameterised
    pMotherLogical->AddDaughter(this);
  }
  if (pSurfChk) { CheckOverlaps(); }
}

G4PVParameterised() [2/3]

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

Similar to the constructor above, except for the mother pointer's type being here a G4VPhysicalVolume.

Parameters

[in]	pName	The volume name.
[in]	pLogical	Pointer to the logical volume of the replica.
[in]	pMother	Pointer to the physical volume of the mother.
[in]	pAxis	The axis along which do the replication.
[in]	nReplicas	The number of copies to replicate.
[in]	pParam	Pointer to the provided parameterisation algorithm.
[in]	pSurfChk	Boolean flag, if true activates check for overlaps with existing volumes (false by default).

Definition at line 41 of file G4PVParameterised.cc.

: G4PVReplica(pName, nReplicas, pAxis, pLogical,
              pMotherPhysical != nullptr ? pMotherPhysical->GetLogicalVolume() : nullptr ),
    fparam(pParam)
{
  G4LogicalVolume* motherLogical= pMotherPhysical != nullptr ?
      pMotherPhysical->GetLogicalVolume() : nullptr;
 
  SetMotherLogical( motherLogical );
  if( motherLogical != nullptr )
  {
    // Registration moved here to ensure that the volume is recognised as Parameterised     
    motherLogical->AddDaughter(this);
  }
 
#ifdef G4VERBOSE  
  if ((pMotherPhysical != nullptr) && (pMotherPhysical->IsParameterised()))
  {
    std::ostringstream message;
    std::ostringstream 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: " << pMotherPhysical->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() [3/3]

G4PVParameterised::G4PVParameterised

(

__void__ &

a

)

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

Definition at line 108 of file G4PVParameterised.cc.

  : G4PVReplica(a)
{
}

~G4PVParameterised()

G4PVParameterised::~G4PVParameterised ( )

overridedefault

Default Destructor.

Member Function Documentation

CheckOverlaps()

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

override

Verifies if each instance of the parameterised volume is overlapping with other instances 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 (deafult 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.

Definition at line 168 of file G4PVParameterised.cc.

{
  if (res<=0) { return false; }
 
  G4int trials = 0;
  G4bool retval = false;
  G4VSolid* solidA = nullptr;
  G4VSolid* solidB = nullptr;
  G4LogicalVolume* motherLog = GetMotherLogical();
  G4VSolid* motherSolid = motherLog->GetSolid();
  std::vector<G4ThreeVector> points;
 
  if (verbose)
  {
    G4cout << "Checking overlaps for parameterised volume "
           << GetName() << " ... ";
  }
 
  for (auto 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 (auto 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)
        {
          ++trials; retval = true;
          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");
          if (trials>=maxErr)
          {
            message << G4endl
                    << "NOTE: Reached maximum fixed number -" << maxErr
                    << "- of overlaps reports for this volume !";
          }
          G4Exception("G4PVParameterised::CheckOverlaps()",
                      "GeomVol1002", JustWarning, message);
          if (trials>=maxErr)  { return true; }
        }
      }
      points.push_back(mp);
    }
 
    // Checking overlaps with each other parameterised instance
    //
    for (auto 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 (const auto & point : points)
      {
        // Transform each point according to daughter's frame
        //
        G4ThreeVector md = Td.InverseTransformPoint(point);
 
        if (solidB->Inside(md)==kInside)
        {
          G4double distout = solidB->DistanceToOut(md);
          if (distout > tol)
          {
            ++trials; retval = true;
            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 << ".";
            if (trials>=maxErr)
            {
              message << G4endl
                      << "NOTE: Reached maximum fixed number -" << maxErr
                      << "- of overlaps reports for this volume !";
            }
            G4Exception("G4PVParameterised::CheckOverlaps()",
                        "GeomVol1002", JustWarning, message);
            if (trials>=maxErr)  { return true; }
          }
        }
      }
    }
  }
  if (verbose)
  {
    G4cout << "OK! " << G4endl;
  }
 
  return retval;
}

Referenced by G4PVParameterised(), G4PVParameterised(), and ~G4PVParameterised().

GetParameterisation()

G4VPVParameterisation * G4PVParameterised::GetParameterisation ( ) const

override

Returns the current pointer to the parameterisation algorithm.

Definition at line 116 of file G4PVParameterised.cc.

{
  return fparam;
}

Referenced by G4LogicalVolumeModel::DescribeYourselfTo(), G4VFieldModel::DescribeYourselfTo(), G4tgbGeometryDumper::DumpPVParameterised(), and ~G4PVParameterised().

GetReplicationData()

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

override

Fills arguments with the attributes from the base replica.

Parameters

[in,out]	axis	Axis of parameterisation returned.
[in,out]	nReplicas	The number of replica copies.
[in,out]	width	Width of the replica object.
[in,out]	offset	Potential offset in replication.
[in,out]	consuming	Flag of replica characterisation (always false for parameterisations).

Definition at line 140 of file G4PVParameterised.cc.

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

Referenced by G4tgbGeometryDumper::DumpPVParameterised(), and ~G4PVParameterised().

IsParameterised()

G4bool G4PVParameterised::IsParameterised ( ) const

override

Returns true to identify if it is a parameterised physical volume.

Definition at line 124 of file G4PVParameterised.cc.

{
  return true;
}

SetRegularStructureId()

void G4PVParameterised::SetRegularStructureId ( G4int code )

override

Sets code and can prepare for special type of regular volumes.

Definition at line 156 of file G4PVParameterised.cc.

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

Referenced by ~G4PVParameterised().

VolumeType()

EVolume G4PVParameterised::VolumeType ( ) const

final

Returns the volume type characterisation.

Definition at line 132 of file G4PVParameterised.cc.

{
  return kParameterised;
}

---

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

• G4PVParameterised.hh
• G4PVParameterised.cc