library: libGeomPainter #include "TGeoChecker.h"

# TGeoChecker

class description - source file - inheritance tree (.pdf)

## class TGeoChecker : public TObject

| Inheritance Chart:

`TObject`

<-

`TGeoChecker`

        public:

                          TGeoChecker()
                          TGeoChecker(TGeoManager* geom)
                          TGeoChecker(const char* treename, const char* filename)
                          TGeoChecker(const TGeoChecker&)
                  virtual ~TGeoChecker()
                     void CheckGeometry(Int_t nrays, Double_t startx, Double_t starty, Double_t startz) const
                     void CheckOverlaps(const TGeoVolume* vol, Double_t ovlp = 0.1, Option_t* option = "") const
                     void CheckPoint(Double_t x = 0, Double_t y = 0, Double_t z = 0, Option_t* option = "")
                 Double_t CheckVoxels(TGeoVolume* vol, TGeoVoxelFinder* voxels, Double_t* xyz, Int_t npoints)
           static TClass* Class()
          virtual TClass* IsA() const
                    TH2F* LegoPlot(Int_t ntheta = 60, Double_t themin = 0., Double_t themax = 180., Int_t nphi = 90, Double_t phimin = 0., Double_t phimax = 360., Double_t rmin = 0., Double_t rmax = 9999999, Option_t* option = "")
             TGeoChecker& operator=(const TGeoChecker&)
                     void PrintOverlaps() const
                     void RandomPoints(TGeoVolume* vol, Int_t npoints, Option_t* option)
                     void RandomRays(Int_t nrays, Double_t startx, Double_t starty, Double_t startz)
                TGeoNode* SamplePoints(Int_t npoints, Double_t& dist, Double_t epsil, const char* g3path)
                     void ShootRay(Double_t* start, Double_t dirx, Double_t diry, Double_t dirz, Double_t* array, Int_t& nelem, Int_t& dim, Double_t* enpoint = 0) const
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)
                     void Test(Int_t npoints, Option_t* option)
                     void TestOverlaps(const char* path)
                   Bool_t TestVoxels(TGeoVolume* vol, Int_t npoints = 1000000)
                 Double_t Weight(Double_t precision = 0.01, Option_t* option = "v")

### Data Members

        private:

          TGeoManager* fGeoManager  pointer to geometry manager
           TGeoVolume* fVsafe       volume to which a safety sphere node was added

## Class Description

       Geometry checking package.

     TGeoChecker class provides several geometry checking methods. There are two
     types of tests that can be performed. One is based on random sampling or
     ray-tracing and provides a visual check on how navigation methods work for
     a given geometry. The second actually checks the validity of the geometry
     definition in terms of overlapping/extruding objects. Both types of checks
     can be done for a given branch (starting with a given volume) as well as for
     the geometry as a whole.

     1. TGeoChecker::CheckPoint(Double_t x, Double_t y, Double_t z)

     This method can be called direcly from the TGeoManager class and print a
     report on how a given point is classified by the modeller: which is the
     full path to the deepest node containing it, and the (under)estimation
     of the distance to the closest boundary (safety).

     2. TGeoChecker::RandomPoints(Int_t npoints)

     Can be called from TGeoVolume class. It first draws the volume and its
     content with the current visualization settings. Then randomly samples points
     in its bounding box, plotting in the geometry display only the points
     classified as belonging to visible volumes.

     3. TGeoChecker::RandomRays(Int_t nrays, Double_t startx, starty, startz)

     Can be called and acts in the same way as the previous, but instead of points,
     rays having random isotropic directions are generated from the given point.
     A raytracing algorithm propagates all rays untill they exit geometry, plotting
     all segments crossing visible nodes in the same color as these.

     4. TGeoChecker::Test(Int_t npoints)

     Implementation of TGeoManager::Test(). Computes the time for the modeller
     to find out "Where am I?" for a given number of random points.

     5. TGeoChecker::LegoPlot(ntheta, themin, themax, nphi, phimin, phimax,...)

     Implementation of TGeoVolume::LegoPlot(). Draws a spherical radiation length
     lego plot for a given volume, in a given theta/phi range.

     6. TGeoChecker::Weigth(Double_t precision)

     Implementation of TGeoVolume::Weigth(). Estimates the total weigth of a given
     volume by matrial sampling. Accepts as input the desired precision.

     Overlap checker
    -----------------

      -> add it from the doc.

TGeoChecker()

     Default constructor

TGeoChecker(TGeoManager *geom)

     Constructor for a given geometry

TGeoChecker(const char * /*treename*/, const char * /*filename*/)

     constructor

~TGeoChecker()

     Destructor

void CheckGeometry(Int_t nrays, Double_t startx, Double_t starty, Double_t startz) const

     Shoot nrays with random directions from starting point (startx, starty, startz)
     in the reference frame of this volume. Track each ray until exiting geometry, then
     shoot backwards from exiting point and compare boundary crossing points.

void CheckOverlaps(const TGeoVolume *vol, Double_t ovlp, Option_t * /*option*/) const

     Check illegal overlaps for volume VOL within a limit OVLP.

void PrintOverlaps() const

     Print the current list of overlaps held by the manager class.

void CheckPoint(Double_t x, Double_t y, Double_t z, Option_t *)

    --- Draw point (x,y,z) over the picture of the daughers of the volume containing this point.
       Generates a report regarding the path to the node containing this point and the distance to
       the closest boundary.

TH2F* LegoPlot(Int_t ntheta, Double_t themin, Double_t themax, Int_t nphi, Double_t phimin, Double_t phimax, Double_t /*rmin*/, Double_t /*rmax*/, Option_t *option)

     Generate a lego plot fot the top volume, according to option.

void RandomPoints(TGeoVolume *vol, Int_t npoints, Option_t *option)

     Draw random points in the bounding box of a volume.

void RandomRays(Int_t nrays, Double_t startx, Double_t starty, Double_t startz)

     Randomly shoot nrays from point (startx,starty,startz) and plot intersections
     with surfaces for current top node.

TGeoNode* SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char* g3path)

     shoot npoints randomly in a box of 1E-5 arround current point.
     return minimum distance to points outside
     make sure that path to current node is updated
     get the response of tgeo

void ShootRay(Double_t *start, Double_t dirx, Double_t diry, Double_t dirz, Double_t *array, Int_t &nelem, Int_t &dim, Double_t *endpoint) const

     Shoot one ray from start point with direction (dirx,diry,dirz). Fills input array
     with points just after boundary crossings.
       Int_t array_dimension = 3*dim;

void Test(Int_t npoints, Option_t *option)

     Check time of finding "Where am I" for n points.

void TestOverlaps(const char* path)

    --- Geometry overlap checker based on sampling.

Double_t Weight(Double_t precision, Option_t *option)

     Estimate weight of top level volume with a precision SIGMA(W)/W
     better than PRECISION. Option can be "v" - verbose (default).

Double_t CheckVoxels(TGeoVolume *vol, TGeoVoxelFinder *voxels, Double_t *xyz, Int_t npoints)

     count voxel timing

Bool_t TestVoxels(TGeoVolume *vol, Int_t npoints)

     Returns optimal voxelization type for volume vol.
       kFALSE - cartesian
       kTRUE  - cylindrical

### Inline Functions

                 TClass* Class()
                 TClass* IsA() const
                    void ShowMembers(TMemberInspector& insp, char* parent)
                    void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
             TGeoChecker TGeoChecker(const TGeoChecker&)
            TGeoChecker& operator=(const TGeoChecker&)

Author: Andrei Gheata 01/11/01
Last update: root/geom:$Name: $:$Id: TGeoChecker.cxx,v 1.33 2005/04/25 07:53:27 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *