HDetGeomPar

class HDetGeomPar : public HParSet

    public:

                            HDetGeomPar(const char* name, const char* title, const char* context, const char* detectorName)
                            HDetGeomPar(const HDetGeomPar&)
                    virtual ~HDetGeomPar()
                       void addRefVolume(HGeomCompositeVolume*, const Int_t)
             static TClass* Class()
               virtual void clear()
              virtual Int_t getCompNum(const TString&)
                      Int_t getMaxModules()
                      Int_t getMaxSectors()
              virtual Int_t getModNumInComp(const TString&)
              virtual Int_t getModNumInMod(const TString&)
               HModGeomPar* getModule(const Int_t, const Int_t)
               HModGeomPar* getModule(const Int_t)
                      Int_t getNumComponents()
                      Int_t getNumModules()
                      Int_t getNumRefModules()
      HGeomCompositeVolume* getRefVolume(const Int_t)
              virtual Int_t getSecNum(const TString&)
                       void getSector(TObjArray*, const Int_t)
               HGeomShapes* getShapes()
             virtual Bool_t init(HParIo*, Int_t*)
            virtual TClass* IsA() const
                     Bool_t isFirstInitialization()
               HDetGeomPar& operator=(const HDetGeomPar&)
               virtual void printParam()
                       void setNotFirstInit()
               virtual void ShowMembers(TMemberInspector& insp, char* parent)
               virtual void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)
              virtual Int_t write(HParIo*)

Data Members

    protected:

        TObjArray* modules        linear array of all modules (type HModGeomPar)
        TObjArray* refVolumes     array of module types (type HGeomCompositeVolume)
             Int_t maxSectors     maximum number of sectors
             Int_t maxModules     maximum number of modules in a sector
             Int_t numComponents  number of components in a sector 
      HGeomShapes* shapes         ! pointer to the shape classes
            Bool_t isFirstInit    ! kTRUE before first initialization

Class Description

 HGeomDetPar

 Container class for the basic geometry parameters of a detector

 This container can hold the information about the sizes and positions of
 volumes forming a geometry tree with 2 levels: modules and components in
 these modules.

 The information is stored in 2 arrays.
 The array "modules" is a linear array of maxSectors*maxModules pointers to
 detector modules (type HModGeomPar) each having a name and a lab
 transformation which describes the position and orientation of the internal
 module coordinate system relative to the cave coordinate system.
 Each module has a pointer to a reference module describing the type of this
 module. These module types (objects of class HGeomCompositeVolume) are
 stored in the second array "refVolumes". (Normally the modules in the six
 sectors are identical and the information has to be stored only once. Only
 their position is different.)
 Each reference module is a volume with a detector dependent number of
 components which are volumes themselves. Each volume has a name, a shape, a
 mother, a shape dependant number of points describing the size and a
 transformation. The transformation of a module describes the detector
 coordinate system (ideal position in a sector) and the transformation of a
 component shows the position and orientation relative to  this detector
 coordinate system.

 inline functions of class HDetGeomPar:

   Int_t getNumComponents()
       returns the number of components in a module
   Int_t getMaxSectors()
       returns the maximum number of sectors
   Int_t getMaxModules()
       returns the maximum number of modules
   HGeomShapes* getShapes()
       return the pointer to the shape classes

 virtual functions of class HDetGeomPar which have to be implemented by the
 detector classes:
   virtual Bool_t init(HParIo*,Int_t*)
       initilizes the container from an input
   virtual Int_t write(HParIo*)
       writes the container to an output
   virtual Int_t getSecNum(const TString&)
       retrieves the sector number from the name of a module
   virtual Int_t getModNumInMod(const TString&) {return -1;}
       retrieves the module number from the name of a module
   virtual Int_t getModNumInComp(const TString&) {return -1;}
       retrieves the module number from the name of a component
   virtual Int_t getCompNum(const TString&) {return -1;}
       retrieves the component number from the name of a component

 inline functions of class HModGeomPar:

   void setVolume(HGeomCompositeVolume* p)
       sets the pointer to the reference volume
   HGeomCompositeVolume* getRefVolume()
       returns a pointer to the reference volume
   HGeomTransform& getLabTransform()
       returns the lab transformation of a module
   const Text_t* getRefName() const
       sets the name of the reference volume

 The constructor creates an array of maxSectors*maxModules pointers of
 type HModGeomPar
 The pointers to modules, which are not active (taken from the setup),
 are NULL-pointers.
 It creates also an array of size maxModules, which is filled which the
 reference modules during the first initialisation

 destructor deletes the arrays

 returns the maximum number of the modules

 returns the maximum number of the reference modules

 returns a pointer to the module with index m in sector with index s

 returns a pointer to the module at position n in the array

 fills the given array with the pointers to all modules in the sector with
 index s

 returns a pointer to the reference module with index m

 adds the given reference volume at postion n in the array refVolumes

 clears the parameter container completely as long as it was not
   initialized completly
 otherwise it clears only the module transformation, but not the
   reference volume and its inner parts
 This function is virtual and could be overloaded in the derived class if needed.

 prints the parameters
 This function is virtual and could be overloaded in the derived class if
 needed.

 Stream an object of class HDetGeomPar.

Inline Functions

               Int_t getNumComponents()
               Int_t getMaxSectors()
               Int_t getMaxModules()
              Bool_t isFirstInitialization()
                void setNotFirstInit()
              Bool_t init(HParIo*, Int_t*)
               Int_t write(HParIo*)
               Int_t getSecNum(const TString&)
               Int_t getModNumInMod(const TString&)
               Int_t getModNumInComp(const TString&)
               Int_t getCompNum(const TString&)
        HGeomShapes* getShapes()
             TClass* Class()
             TClass* IsA() const
                void ShowMembers(TMemberInspector& insp, char* parent)
                void StreamerNVirtual(TBuffer& b)
         HDetGeomPar HDetGeomPar(const HDetGeomPar&)
        HDetGeomPar& operator=(const HDetGeomPar&)