HDetector

class HDetector : public TNamed

    public:

                         HDetector()
                         HDetector(Text_t* name, Text_t* title)
                         HDetector(const HDetector&)
                 virtual ~HDetector()
            virtual void activateParIo(HParIo*)
      virtual HCategory* buildCategory(Cat_t)
          virtual HTask* buildTask(Text_t*, Option_t*)
          static TClass* Class()
                   Int_t getMaxComponents()
                   Int_t getMaxModules()
                   Int_t getMaxSectors()
           virtual Int_t getModule(Int_t sector, Int_t mod)
          virtual Int_t* getModules()
          virtual Bool_t init()
         virtual TClass* IsA() const
                  Bool_t isSectorActive(Int_t sector)
              HDetector& operator=(const HDetector&)
                    void print()
            virtual void setMaxSectors(Int_t sec = 6)
            virtual void setModules(Int_t sec, Int_t* modules)
            virtual void ShowMembers(TMemberInspector& insp, char* parent)
            virtual void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)
          virtual Bool_t write(HParIo*)

Data Members

    protected:

         Int_t maxSectors     maximum number of sectors (-1 for detectors outside any sector)
         Int_t maxModules     maximum number of modules per sector
         Int_t maxComponents  maximum number of components per module
      TArrayI* modules        Module's array.

Class Description

  HDetector

  class to store the actual setup of a detector

  The setup is defined in the macro via the memberfuntion
  setModules(Int_t sector,Int_t* modules). The array must
  have the size of the maximum mumber of modules in a
  sector for this detector. If the module if not active the
  according number is 0.
  e.g. for Mdc:   Int_t mod[4]={1,2,0,0};
                  mdc.setModules(0,mod);
       This activates the modules 1 and 2 in sector 0
  Detectors without a sector wise segmentation as e.g. the Start detector
  use sector = -1.

  It also holds the intelligence to build tasks related to this particular
  detector as well as to create data structures for it.

  This intelligence is stored in the functions: buildTask() and
  buildCategory() and has the form of compiled C++ code.

  The function HTask *HDetector::buildTask(Text_t *task, Option_t *opt)
  builds a task object corresponding to the task identified by the string
  "task". This can be an atomic task (a HReconstructor) or a set of them, in
  this case the tasks will be packed in a HTaskSet so that buildTask() returns
  a pointer to that HTaskSet. "opt" is a string where extra options can be
  given; the available options differ from detector to detector.

  The function HCategory* HDetector::buildCategory(Cat_t cat) uses the
  setup information in the HDetector to build a category object. The category
  class and it's setup will be defined by "cat"; i.e. the HDetector has built
  in the information of which category subclass is recommended for each kind
  of data.

Constructor

Constructor with name

Destructor

 stores the modules givven in 'm' as active modules in sector 's'
 may be called with s=-1 for detectors not belonging to a sector

 returns a linear array of all modules

 returns the number of the module in a sector
 may be called with s=-1 for detectors not belonging to a sector
 returns 0 if this module is not active

 Returns true if any module in the sector "sector" is set active.

 prints the detector setup

Inline Functions

              Int_t getMaxSectors()
              Int_t getMaxModules()
              Int_t getMaxComponents()
               void setMaxSectors(Int_t sec = 6)
             Bool_t init()
             Bool_t write(HParIo*)
               void activateParIo(HParIo*)
             HTask* buildTask(Text_t*, Option_t*)
         HCategory* buildCategory(Cat_t)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
          HDetector HDetector(const HDetector&)
         HDetector& operator=(const HDetector&)