GeoModel Kernel Class Reference¶

This section describes in more detail the classes in the geometry kernel. In most cases we provide the class interface. In cases where part of the interface is used only internally by the geometry kernel itself and not by other users. In such cases we present a simplified picture of the interfaces.

Detailed descriptions of the geometry kernel classes follow.

Reference counting¶

Warning

The custom reference counting used in GeoModel was developed when no smart pointers were available for C++. That part will be the object of a major refactoring in the near future.

Many objects need to be allocated in the description of a complicated geometry. For efficient use of memory, these should be shared as often as possible. The extensive sharing of objects in a geometry system calls for a way of destroying the objects as soon as they are not used—by any other object that references them. The scheme for doing this is called reference counting. In the GeoModelKernel classes, it is achieved by mixing in a abstract base class, RCBase:

//RCBase
  Constructor:
    RCBase()
  Public Methods:
    void ref ()
    void unref ()
    unsigned int refCount ()

RCBase is inherited by many of the classes in the geometry system. Reference-counted objects can only be created using operator new, and cannot be created on the stack. The methods ref() and unref() can be called to increase or decrease the reference count of an object. When the reference count decreases to zero, the object deletes itself. The accessor refCount() returns the current reference count.

Materials and Elements¶

Introduction¶

Two classes are used for describing materials: GeoElement and GeoMaterial.

Elements are declared by specifying a name, chemical symbol, and atomic number and mass; the latter being specified in atomic mass units.

Materials are constructed with a name and density and are not ready-for-use until one or more elements have been added, e.g.:

water->add(hydrogen,0.11);
water->add(oxygen,0.89);
water->lock();

The add() method takes an element and its mass fraction, and is overloaded to accept also a material and its mass fraction. The lock() method protects the material against further addition of elements, and re-normalizes the mass fractions so that they sum to unity

The material responds to various queries about its composition, and in addition can return a series of derived quantities of physical interest. The interaction length and radiation length of a material are familiar and are described in the Particle Data Book¹.

Ionization energy loss in materials follows the Bethe-Bloch formula and is governed by two constants, an overall normalization term and the ionization potential, which can be computed from the atomic number and density of the material; the calculation is also described in the Particle Data Book cited above¹. The calculation does not include small corrections to the energy loss due to chemical binding of elements. These constants are available through the methods getDeDxConstant() and getDeDxI0(). The method getDeDxMin() returns the minimum ionization energy loss and is derived from the other methods.

Both materials and elements are reference-counted; the reference count of an element is incremented when it added to a material and decremented when a referencing material is destroyed; materials are reference counted when they are used in logical volumes and decremented when the referencing logical volume is destroyed.

GeoElement¶

// GeoElement
  //Constructor:
    GeoElement (const std::string & Name, const std::string & Symbol, double Z, double A)
  //Public Methods:
    std::string getName() const std::string getSymbol() const double getZ() const
    double getA() const
    double getN() const

GeoElement has a constructor which takes a name, a chemical symbol, an atomic number, and an atomic weight². The public methods provide access to this information. The getN() method returns the effective number of nucleons in the material, \(Z+A\).

GeoMaterial¶

// GeoMaterial
  //Constructor:
    GeoMaterial (const std::string & Name, double Density) const
  //Public Methods:
    void add (GeoElement * element, double fraction = 1.0) void add (GeoMaterial * material, double fraction) void lock ()
    std::string getName () const
    double getDensity () const
    unsigned int getID() const
    unsigned int getNumElements () const
    const GeoElement * getElement (unsigned int i) const double getFraction (int i) const
    double getRadLength () const
    double getIntLength () const
    double getDeDxConstant () const
    double getDeDxI0 () const
    double getDeDxMin () const

GeoMaterial is a class that describes a material, which is a list of elements. It is created “empty”; subsequently, elements are added one-by-one until the material is “locked”. When the material is locked, no further editing is possible, and a series of derived quantities (radiation length, interaction length, etc.) is computed for the material.

The construvctor, GeoMaterial(const std::string & Name, double Density) Constructs the material with a name and a density³.

The method add(GeoElement * element, double fraction = 1.0) adds an element to the material, with a specified mass fraction.

The method add(GeoMaterial * material, double fraction) adds a material to the material, with a specified mass fraction. This is useful for combining precombined materials, such as argon + ethane.

The method lock() Locks the material against further editing, and computes all derived quanties such as radiation length and interaction length.

The method getName() returns the name of the material as a string.

The method getDensity() returns the density of the material³.

The method getID() returns the id of the material as an integere. The id is generated automatically by counting instances of materials.

The method getNumElements() returns the number of elements in a material.

The method getElement(i) returns a pointer to the \(i^{th}\) element.

The method getFraction(i) returns the fraction of the \(i^{th}\) element.

The method getRadLength() returns the radiation length of the material, computed from the density, the list of constituents, and their properties.

The method getIntLength() returns the interaction length of the material, computed from the density the list of constituents, and their properties.

The following methods refer to ionization energy loss, specifically, the following formulation:

\[ \frac{dE}{dx} = \frac{K}{\beta^2} (ln (\frac{2m_e c^2 \beta^2 \gamma^2}{I_0}) - \beta^2 ) \]

The method getDeDxConstant() returns the constant, \(K\), which depends upon the material properties (mostly the density).

While the method getDeDxI0() returns the effective ionization potential \(I_0\), which is a property of the material.

The method getDeDxMin() returns an approximation for the ionization of a minimum ionizing particle (\(\beta\gamma=3.4\)), given by: \(K \times 11.528\).

Shapes¶

Introduction¶

The shape classes in the geometry kernel are data structures designed to describe several geometrical primitives. Table 1 describes the different shapes presently provided within the geometry kernel. This set is extensible; one only needs to derive a new shape from the base class and insure that it fits the pattern described below. Shapes are reference-counted objects, as described in Reference Counting.

In the table here below, a list of the existing geometrical shapes in the GeoModelKernel package is given:

Class	Shape
GeoBox	Box
GeoCons	Cone Section
GeoEllipticalTube
GeoGenericTrap
GeoPara	Parallelepiped
GeoPcon	Polycone
GeoPgon	Polygon
GeoSimplePolygonBrep
GeoTessellatedSolid
GeoTorus
GeoTrap	Trapezoid (complex)
GeoTrd	Trapezoid (simple)
GeoTube	Tube
GeoTubs	Tube Section
GeoTwistedTrap	Twisted Trapezoid
GeoUnidentifiedShape

In addition to the geometrical shapes listed above, a set of boolean operator shapes is also added:

Class	Operation
GeoShapeIntersection	Intersection
GeoShapeShift	Shift
GeoShapeSubtraction	Subtraction
GeoShapeUnion	Intersection

All shapes provide access to their geometry attributes (height, width, & cetera), and in addition perform several other services:

They calculate their volume
They can combine themselves using Boolean operations
They allow themselves to be identified through a built-in type identification scheme.

The volume calculation is an analytic calculation provided by each subclass.

One or more Boolean operation upon shapes creates a binary expression tree. This tree can be navigated later and the Boolean volumes declared to clients who can cope with them: GEANT4, notably, and certain visualization systems. Several Boolean operations may be combined in a single line of code:

GeoShape *A, *B, *C;
const GeoShape & D = (*A).add((*B) .subtract (*C));

A shape’s reference count is incremented either when the shape is used by a GeoLogVol, or in a Boolean expression. In the above example, D has been new’d, so has an unnamed temporary. The reference count of the temporary is incremented when it is combined with A to make D. When D’s reference count falls to zero, D is deleted, and the temporary is deleted.

Shapes can also be shifted about before they are used in a Boolean operation. The operation looks like this:

GeoShape *A, *B;
HepTransform3D offset;
const GeoShape & D = A->subtract (B<<offset);

The type identification scheme works by comparing the result of a static method with the result of a pure virtual method:

GeoShape *A;
if (A->typeId() == GeoBox::GetClassTypeId() ) {
    //
    // It’s a box!
    //
}

Both methods return a coded integer. When the class returns the same integer as the object, a match has occurred. Alternately one can use the methods getClassType() and type(), which return meaningful strings like “Box”, “Cons”… These are human-readable but slower to compare than unsigned integers.

All GeoShapes have the following interface:

// GeoShape
// Public Methods:
   virtual double volume () const
   const GeoShapeUnion & add ()  const
   const GeoShapeSubtraction & subtract(const GeoShape & shape) const
   const GeoShapeIntersection &   intersection(const GeoShape & shape) const
   const GeoShapeShift & operator << (const HepTransform3D &) const
   virtual const std::string & type () const
   virtual ShapeType typeID ()  const

//Static Public Methods
   const std::string & getClassType ()
   const ShapeType getClassTypeID ()

The classes GeoShapeShift, GeoShapeUnion, GeoShapeSubtraction, and GeoShapeIntersection are internal and should be considered for experts. We will not discuss them further.

We now present the interfaces to specific shapes. In general these shapes are by default constructed as symmetrically around the origin as possible.

GeoBox¶

// === GeoBox ===

   //Constructor:
   GeoBox (double XHalfLength, double YHalfLength, double ZHalfLength)

   //Public Methods:
   double getXHalfLength() const
   double getYHalfLength() const
   double getZHalfLength() const

The constructor fills the box with the \(x\), \(y\), and \(z\) half-lengths, and the accessors return those quantities.

The GeoBox shape — Figure: A GeoBox object, representing a rectangular prism or “box”.

GeoCons¶

// === GeoCons ===

   // Constructor:
   GeoCons (double RMin1, double RMin2,   
            double RMax1, double RMax2, 
            double DZ,  double SPhi,  double DPhi)

   // Public Methods:
   double getRMin1() const
   double getRMin2() const
   double getRMax1() const
   double getRMax2() const
   double getDZ() const
   double getSPhi() const
   double getDPhi() const

A GeoCons represents a cone section positioned with its axis along the \(z\) direction, and is specified by a starting value of \(\phi\), a total subtended angle in \(\phi\), a half-width in \(z\), and minimum and maximum values of radius at both extremities in \(z\). The constructor specifies the values of these constants, and the accessors return them.

The GeoCons shape — Figure: A GeoCons Object, representing a cone section.

GeoPara¶

// === GeoPara ===

  // Constructor:
  GeoPara (double XHalfLength, double YHalfLength, double ZHalfLength,
           double Alpha, double Theta, double Phi)

  // Public Methods:
  double getXHalfLength() const
  double getYHalfLength() const
  double getZHalfLength() const
  double getTheta() const
  double getAlpha() const
  double getPhi() const

The GeoPara class represents a parallelepiped. Faces at \(\pm z\) are parallel to the \(x-y\) plane. One edge of each of these faces is parallel to the \(x\)-axis, while the other edge makes an angle \(\alpha\) with respect to the \(y\)-axis. The remaining edge of the parallelepiped is oriented along a vector whose polar angle is \(\theta\) and whose azimuthal angle is \(\phi\). Half-lengths in \(x\), \(y\), and \(z\) describe the projections of the sides of the parallelepiped project onto the coordinate axes. The constructor fills these data, while the accessors return them.

Warning

Visualization of GeoPara is on the to-do list.

The GeoPara shape — Figure: GeoPara object, representing a parallelepiped.

GeoPcon¶

//=== GeoPcon ===

  // Constructor:
  GeoPcon (double SPhi, double DPhi)

  // Public Methods:
  void addPlane (double ZPlane, double RMinPlane, double RMaxPlane)
  double getSPhi() const
  double getDPhi() const
  unsigned int getNPlanes ()
  bool isValid () const
  const double & getZPlane (unsigned int i) const
  const double & getRMinPlane (unsigned int i) const
  const double & getRMaxPlane (unsigned int i) const

GeoPcon represents a polycone, which is a union of simple cone sections. The polycone subtends a fixed angle in \(\phi\) (DPhi) beginning at \(\phi_0\) (SPhi), and is specified at \(n\) locations in \(z\). At each \(z\) location, the inner and outer radius is given.

When the polycone is constructed, only \(\phi_0\) and \(\phi\) are given; then, the information at each \(z\) location is given, one plane at a time, by using the addPlane() method. At least two planes must be given, otherwise the polycone is not valid and methods such as volume() will fail and throw an exception. The isValid() method can be used to determine whether the polycone has at least two planes.

Note

A polycone (GeoPcon) with exactly two planes is equivalent geometrically to a cone section (GeoCons).

The GeoPcon shape — Figure: A GeoPcon object, representing a "polycone", which is a union of cone sections.

GeoPgon¶

//=== GeoPgon ===

  // Constructor:
  GeoPgon (double SPhi, double DPhi, unsigned int NSides)

  // Public Methods:
  double getSPhi() const
  double getDPhi() const
  unsigned int NSides() const
  unsigned int getNPlanes () const
  const double & getZPlane (unsigned int i) const
  const double & getRMinPlane (unsigned int i) const
  const double & getRMaxPlane (unsigned int i) const
  bool isValid () const
  void addPlane (double ZPlane, double RMinPlane, double RMaxPlane)

GeoPgon is similar to a GeoPcon (polycone). Like a GeoPcon it subtends a fixed angle in \(\phi\) (dPhi) beginning at \(\phi_0\) (sPhi), and is further specified by giving inner and outer radii at \(n\) locations in \(z\). However the GeoPgon object has a polygonal cross section, and the solid angle \(\phi\) is segmented into a fixed number of sides.

The constructor takes \(\phi\) , \(\phi_0\), and the number of sides in the cross-section as arguments; then, the information at each \(z\) location is given, one plane at a time, by using the addPlane() method. At least two planes must be given, otherwise the polygon is not valid and methods such as volume() will fail and throw an exception. The isValid() method can be used to determine whether the polygon has at least two planes.

Warning

Visualization of GeoPgon is on the to-do list.

The GeoPgon shape — Figure: GeoPgon object, representing a polycone with a polygonal cross section.

GeoTrap¶

//=== GeoTrap ===

  // Constructor:
  GeoTrap (double ZHalfLength, double Theta, double Phi, 
           double Dydzn, double Dxdyndzn, double Dxdypdzn,
           double Angleydzn, double Dydzp, double Dxdyndzp, 
           double Dxdypdzp, double Angleydzp)

  // Public Methods:
  double getZHalfLength() const
  double getTheta() const
  double getPhi() const
  double getDydzn() const
  double getDxdyndzn() const
  double getDxdypdzn() const
  double getAngleydzn() const
  double getDydzp() const
  double getDxdyndzp() const
  double getDxdypdzp() const
  double getAngleydzp() const

The GeoTrap class represents a very general kind of trapezoid. Two faces at \(\pm \Delta z\) (ZHalfLength) are parallel to each other and to the \(x-y\) plane. The centers of the faces are offset by a vector whose polar and azimuthal angles respectively are \(\theta\) and \(\phi\). At \(-\Delta z\), two edges parallel to the \(x\)-axis are offset by \(\pm \Delta y_n\) (Dydzn) from the face’s center, and these two faces have half-lengths of \(\Delta x_{\Delta y_n \Delta z_n}\) (Dxdyndzn) and \(\Delta x_{\Delta y_p \Delta z_n}\) (Dxdypdzn). The face at \(+\Delta z\) are similar: two edges parallel to the \(x\)-axis are offset by \(\pm \Delta y_p\) (Dydzp) from the face’s center, and these two faces have half-lengths of \(\Delta x_{\Delta y_n \Delta z_p}\) (Dxdyndzp) and \(\Delta x_{\Delta y_p \Delta z_p}\) (Dxdypdzp).

The two edges not parallel to the \(x\)-axis make an angle of \(\alpha_n\) (Angleydzn) and \(\alpha_p\) (Angleydzp) with respect to the \(y\)-axis on the bottom face (at \(-\Delta z\)) and the top face (at \(+\Delta z\)), respectively.

The constructor fills the GeoTrap with these values and the accessors return them.

The GeoTrap shape — Figure: A GeoTrap object, representing a very general kind of trapezoid.

GeoTrd¶

//=== GeoTrd ===

  // Constructor:
  GeoTrd ( double XHalfLength1, double XHalfLength2,
           double YHalfLength1, double YHalfLength2,
           double ZHalfLength)

  // Public Properties:
  double getXHalfLength1() const
  double getXHalfLength2() const
  double getYHalfLength1() const
  double getYHalfLength2() const
  double getYHalfLength() const

A GeoTrd is a simple trapezoid. Two faces at \(\pm \Delta z\) are parallel to each other and to the \(x-y\) plane, and each centered on the \(z\)-axis. At \(-\Delta z\) (\(+\Delta z\)), the half-length of the edges parallel to the \(x\)-axis is XHalfLength1 (XHalfLength2) and the half-length of the edges parallel to the \(y\)-axis is YHalfLength1 (YHalfLength2).

The constructor fills the object with these values and the accessors return them.

The GeoTrd shape — Figure: A GeoTrd object, representing a simple trapezoid.

GeoTube¶

//=== GeoTube ===

  // Constructor:
  GeoTube (double RMin, double RMax, double ZHalfLength)

  // Public Methods:
  double getRMin() const
  double getRMax() const
  double getZHalfLength() const

The GeoTube class represents a tube, specified by an inner radius (RMin), an outer radius (RMax) and a half-length in \(z\) (ZHalfLength).

The constructor fills these quantities and the accessors return them.

The GeoTube shape — Figure N: A GeoTube object, representing a tube or "pipe".

GeoTubs¶

//=== GeoTubs ===

  // Constructor:
  GeoTubs (double RMin, double RMax, double ZHalfLength, double SPhi, double DPhi)

  // Public Methods:
  double getRMin() const
  double getRMax() const
  double getZHalfLength() const
  double getSPhi() const
  double getDPhi() const

A GeoTubs is a tube section; a tube that subtends some plane angle (less than \(360^\circ\)) in \(\phi\). The GeoTubs is constructed by providing the inner radius (RMin), outer radius (RMax), half-length in \(z\) (ZHalfLength), as well as the starting \(\phi\) and \(\Delta \phi\).

Member functions provide access to these quantities.

The GeoTubs shape — Figure: A GeoTubs object, representing a tube section.

GeoTwistedTrap¶

//=== GeoTwistedTrap ===

  // Constructor:
  GeoTwistedTrap(double  PhiTwist,   // twist angle
                 double  Dz,     // half z length
                 double  Theta,  // direction between end planes
                 double  Phi,    // defined by polar and azim. angles
                 double  Dy1,    // half y length at -pDz
                 double  Dx1,    // half x length at -pDz,-pDy
                 double  Dx2,    // half x length at -pDz,+pDy
                 double  Dy2,    // half y length at +pDz
                 double  Dx3,    // half x length at +pDz,-pDy
                 double  Dx4,    // half x length at +pDz,+pDy
                 double  Alph    // tilt angle
                 )

  // Public Methods:
 double getY1HalfLength() const 
 double getX1HalfLength() const 
 double getX2HalfLength() const 
 double getY2HalfLength() const 
 double getX3HalfLength() const 
 double getX4HalfLength() const 
 double getZHalfLength()  const 
 double getPhiTwist()     const 
 double getTheta()        const 
 double getPhi()          const 
 double getTiltAngleAlpha() const

The GeoTwistedTrap class represents a twisted trapezoid. Two faces at \(\pm \Delta z\) (Dz) are parallel to each other and to the \(x-y\) plane. The centers of the faces are offset by a vector whose polar and azimuthal angles respectively are \(\theta\) and \(\phi\). At \(-\Delta z\), two edges parallel to the \(x\)-axis are offset by \(\pm \Delta y_1\) (Dy1) from the face’s center, and these two faces have half-lengths of \(\Delta x_{1}\) (Dx1) and \(\Delta x_{2}\) (Dx2). The face at \(+\Delta z\) are similar: two edges parallel to the \(x\)-axis are offset by \(\pm \Delta y_2\) (Dy2) from the face’s center, and these two faces have half-lengths of \(\Delta x_{3}\) (Dx3) and \(\Delta x_{4}\) (Dx4).

The face at \(+ \Delta z\) is twisted with respect to the one at \(- \Delta z\) of an angle defined by \(\phi Twist\). The tilt angle \(\alpha\) defines the angle with respect to the y axis from the centre of the top and bottom trapezoids. It transforms the two trapezoids from isosceles to scalene.

The constructor fills the GeoTwistedTrap with these values and the accessors return them.

The GeoTwistedTrap shape — Figure: GeoTwistedTrap object, representing a twisted trapezoid.

Logical Volumes¶

GeoLogVol¶

//=== GeoLogVol ===

  // Constructor:
  GeoLogVol ( const std::string & Name, 
              const GeoShape * Shape, 
              const GeoMaterial * Material)

  // Public Methods:
  const std::string & getName () const
  const GeoShape * getShape () const
  const GeoMaterial * getMaterial () const

A GeoLogVol is an agglomeration of a name, a shape, and a material. These constituents are provided as arguments to the constructor, which increments the reference count of both the material and the shape. These reference counts are decremented when the GeoLogVol is destroyed.

The GeoLogVol provides const access to its constituents through the three access methods list above.

Physical Volumes¶

Physical volumes are objects that have a single logical volume and list of daughters. These daughters can have several types:

Physical volume.
Physical volume property nodes, such as name tags, or transformations.
Parametrizations of physical volumes.

These types of daughters are referred to collectively as GeoGraphNodes. Physical volumes and graph nodes are the building blocks of the geometry graph. The geometry graph is a specification of a physical volume tree, which, when traversed at a later time, appears to consist of physical volumes within other physical volumes.

Unlike other geometry modelers, in GeoModel physical volumes live within other physical volumes and not within logical volumes. This simplifies tree traversal.

In GeoModel there are two main types of physical volumes, GeoPhysVol and GeoFullPhysVol. These in turn each have an interface class, GeoVPhysVol and GeoVFullPhysVol⁵. The user needs to be concerned only with the classes GeoPhysVol and GeoFullPhysVol. The former is generally used for nondescript pieces of detector geometry whose absolute position in space is not accessed often; while the latter is used typically for active detector components whose absolution position in space is used frequently within reconstruction, or digitization or hit creation. GeoFullPhysVol has a method for caching important information like absolute transformation of the piece with respect to the global coordinates, default transformation, and the name.

GeoPhysVol¶

// GeoPhysVol
  //Constructor:
    GeoPhysVol (const GeoLogVol * LogVol)
  //Public Methods:
    void add (GeoGraphNode * graphNode)
  //Public Methods from GeoVPhysVol
    bool isShared() const
    Query<unsigned int> indexOf (PVConstLink daughter) const
    PVConstLink getParent () const
    const GeoLogVol * getLogVol () const
    unsigned int getNChildVols () const
    PVConstLink  getChildVol (unsigned int index) const
    GeoTrf::Transform3D getXToChildVol (unsigned int index) const
    GeoTrf::Transform3D getDefXToChildVol (unsigned int index) const
    std::string getNameOfChildVol (unsigned int i) const
    Query<unsigned int> getIdOfChildVol() const
    void apply (GeoVolumeAction * action) const
    unsigned int getNChildVolAndST() const
    GeoTrf::Transform3D getX    (const GeoVAlignmentStore* store=nullptr) const
    GeoTrf::Transform3D getDefX (const GeoVAlignmentStore* store=nullptr) const
    unsigned int getNChildNodes() const
    const GeoGraphNode * const * getChildNode (unsigned int i) const
    const GeoGraphNode * const * findChildNode (const GeoGraphNode *n) const
  //Public Methods from GeoGraphNode
    void exec (GeoNodeAction * action)
    void dockTo (GeoVPhysVol* pv)

GeoPhysVol (const GeoLogVol * LogVol) Constructs the physical volume from the logical volume. The reference count of the logical volume is incremented, and will be decremented again when the physical volume is destroyed.

void add (GeoGraphNode * graphNode) Adds a graph node to the physical volume. The reference count of the graph node is incremented.

bool isShared() const Accessor to determine whether the physical volume is shared; i.e, used more than once in the geometry description.

Query<unsigned int> indexOf (PVConstLink daughter) const Accessor to determine the index of a daughter physical volume, in other words, in position within the list of daughters. The result only counts physical volumes as daughters, not their properties.

PVConstLink getParent () const Returns the parent physical volume. In case the parent is not unique (i.e., if the physical volume is shared), return NULL.

const GeoLogVol * getLogVol () const Returns the logical volume.

unsigned int getNChildVols () const Returns the number of child volumes. This includes only physical volumes and does not count property nodes. It does, however, include virtual physical volumes from a parametrization.

PVConstLink getChildVol (unsigned int index) const Returns the specified child volume.

GeoTrf::Transform3D getXToChildVol (unsigned int index) const Returns the transformation to the specified child volume. The transformation is relative to this object; it is not an absolute transformation to a global coordinate system.

GeoTrf::Transform3D getDefXToChildVol (unsigned int index) const Returns the default transformation of the specified child volume, relative to this object.

std::string getNameOfChildVol (unsigned int i) const Returns the name of the child volume, relative to this object.

Query<unsigned int> getIdOfChildVol() const Returns the identifier of the child volume.

void apply (GeoVolumeAction * action) const Applies a volume action to the volume. This action normally recursively visits each daughter volume.

unsigned int getNChildVolAndST() const Returns the number of child physical volumes and serial transformers.

GeoTrf::Transform3D getX (const GeoVAlignmentStore* store=nullptr) const Returns the transformation of the given physical volume to its parent physical volume. If the given physical volume is shared, then an exception is thrown.

GeoTrf::Transform3D getDefX (const GeoVAlignmentStore* store=nullptr) const Returns the default transformation of the given physical volume to its parent physical volume. If the given physical volume is shared, then an exception is thrown.

unsigned int getNChildNodes() const Returns the number of child graph nodes.

const GeoGraphNode * const * getChildNode (unsigned int i) const Returns the child graph node, relative to this object.

const GeoGraphNode * const * findChildNode (const GeoGraphNode *n) const Checks if the object contains child node n. If it does, then the function returns the pointer to n, otherwise it returns nullptr.

void exec (GeoNodeAction * action) Applies a node action to the volume. This action normally recursively visits each graph node in the geometry graph and includes handler functions even for property nodes.

void dockTo (GeoVPhysVol* pv) Caches pv as a pointer to the parent physical volume.

GeoFullPhysVol¶

// GeoFullPhysVol
  //Constructor:
    GeoFullPhysVol (const GeoLogVol * LogVol)
  //Public Methods:
    void add (GeoGraphNode * graphNode)
    GeoFullPhysVol* clone(bool attached=true)
    const GeoFullPhysVol* cloneOrigin() const
    void clear()
  //Public Methods from GeoVFullPhysVol
    const GeoTrf::Transform3D & getAbsoluteTransform () const
    const GeoTrf::Transform3D & getDefAbsoluteTransform () const
    void clearPositionInfo () 
    const std::string &  getAbsoluteName () const
    Query<unsigned int> getId () const
  //Public Methods from GeoVPhysVol
    bool isShared() const
    Query<unsigned int> indexOf (PVConstLink daughter) const
    PVConstLink getParent () const
    const GeoLogVol * getLogVol () const
    unsigned int getNChildVols () const
    PVConstLink  getChildVol (unsigned int index) const
    GeoTrf::Transform3D getXToChildVol (unsigned int index) const
    GeoTrf::Transform3D getDefXToChildVol (unsigned int index) const
    std::string getNameOfChildVol (unsigned int i) const
    Query<unsigned int> getIdOfChildVol() const
    void apply (GeoVolumeAction * action) const
    unsigned int getNChildVolAndST() const
    GeoTrf::Transform3D getX    (const GeoVAlignmentStore* store=nullptr) const
    GeoTrf::Transform3D getDefX (const GeoVAlignmentStore* store=nullptr) const
    unsigned int getNChildNodes() const
    const GeoGraphNode * const * getChildNode (unsigned int i) const
    const GeoGraphNode * const * findChildNode (const GeoGraphNode *n) const
  //Public Methods from GeoGraphNode
    void exec (GeoNodeAction * action)
    void dockTo (GeoVPhysVol* pv)

GeoFullPhysVol (const GeoLogVol * LogVol) Constructs the full physical volume from the logical volume. The reference count of the logical volume is incremented, and will be decremented again when the physical volume is destroyed.

void add (GeoGraphNode * graphNode) Adds a graph node to the full physical volume. The reference count of the graph node is incremented.

GeoFullPhysVol* clone(bool attached=true) Clones full physical volume, and returns a pointer to the cloned instance.

If the attached argument is true, then all cloned volumes are meant to stay identical to their clone origin for the entire lifetime. No further modifications are permitted either in origin, or its clones. I
If the attached argument is false, further modifications in clone origin and its clones are permitted.

const GeoFullPhysVol* cloneOrigin() const Returns a pointer to the full physical volume this object has been cloned from, otherwise returns nullptr.

void clear() Drop the tree under this node. This method breaks consistency of cloned volumes!

const GeoTrf::Transform3D & getAbsoluteTransform () const Returns the absolute transform with respect to global coordinate system.

const GeoTrf::Transform3D & getDefAbsoluteTransform () const Retuns the default absolute transform with respect to the global coordinate system.

void clearPositionInfo () Clears the position information cache. Users do not normally ever need to do this. The cache is automatically cleared by the geometry system whenever a change in alignment is detected.

const std::string & getAbsoluteName () const Returns the absolute name of the volume. This is a “/” separated string of names whose substrings represent physical volumes along the path from the world physical volume down to this volume.

Query<unsigned int> getId () const Returns an integer identifier for labeling purposes.

bool isShared() const Accessor to determine whether the full physical volume is shared; i.e, used more than once in the geometry description. Given full physical volumes cannot be shared, this method is expected to only return false.