EEezAnalysis

class EEezAnalysis : public TObject

    private:

      void InitStrips()
      void InitTowers()
      void InitTowerStrips()

    public:

                         EEezAnalysis()
                         EEezAnalysis(const EEezAnalysis&)
                 virtual ~EEezAnalysis()
                    void addMask(unsigned int)
                    void addSmdHit(Int_t sec, Int_t plane, Int_t strip, Float_t adc)
                    void addTowerHit(Int_t sec, Int_t sub, Int_t eta, Float_t adc, Int_t idet = 0)
          static TClass* Class()
            virtual void Clear(Option_t* opts)
                    void Fill(EEfeeRawEvent* eevent)
                    void Fill(EEeventDst* dst)
                    void forceTower(const Char_t* tow, Float_t etow = 0., Float_t epre1 = 0., Float_t epre2 = 0., Float_t epost = 0.)
                    TH2F getHistogram()
              EEezTower* getHitTower(Int_t ihit)
      EEezTowerPtrVec_t* getHitTowers()
                   Int_t getNHitTowers()
                   Int_t getNSeedTowers()
        EEezSectorStats* getSectorStats(Int_t sec)
                 Float_t getSeedEnergy()
              EEezTower* getSeedTower(Int_t iseed)
      EEezTowerPtrVec_t* getSeedTowers()
              EEezStrip* getStrip(Int_t sector, Int_t plane, Int_t strip)
              EEezTower* getTower(Int_t index)
              EEezTower* getTower(Int_t sec, Int_t sub, Int_t eta)
                    void Init()
                    void InitGeometry()
         virtual TClass* IsA() const
                    void Make(EEfeeRawEvent* eevent)
                    void Make(EEeventDst* dst)
                   Int_t Make(StMuEmcCollection* emc)
                    void print()
                    void RestoreIndices()
                    void Save(EEezAnalysis* analysis)
                    void setDb(EEmcDb* db)
                    void setHotTower(const Char_t* tow = "05TA01")
                    void setSeedEnergy(Float_t e = 0.7)
            virtual void ShowMembers(TMemberInspector& insp, char* parent)
            virtual void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)

Data Members

    private:

                                                              TRandom* m_Random              
                                                             EEmcDb* m_EEmcDb              ! 
                                                           EEmcSmdMap* m_EEmcSmdMap          
                                                             EEezTower m_Towers[720]         
                                                             EEezStrip m_Strips[12][2][288]  
                                                     EEezTowerPtrVec_t m_HitTowers           
                                                               Float_t m_SeedEnergy          
                                                     EEezTowerPtrVec_t m_SeedTowers          
      map<string,int,less<string>,allocator<pair<const string,int> > > m_HotTowers           
                                                     EEezStripPtrVec_t m_HitUStrips          
                                                     EEezStripPtrVec_t m_HitVStrips          
                                                            EEezTower* m_HighTower           Tower w/ highest ADC response 
                                                            EEezStrip* m_HighUStrip          U Strip w/ highest ADC response 
                                                            EEezStrip* m_HighVStrip          V Strip w/ highest ADC response
                                                      EEezSectorStats* m_SectorStats[12]     Tracks sector-based statistics
      map<string,int,less<string>,allocator<pair<const string,int> > > m_IndexFromName       
                                                          unsigned int m_StatMask            

Class Description

 EEezAnalysis

 Author: Jason C. Webb <jwebb@iucf.indiana.edu>

 The EEezAnalysis class is the main workhorse of the analysis code.
 It is responsible for taking the raw data from the ezTree, making
 the connection  to the database to obtain and correct for pedestals
 and gains, and packing the data into the EEezTower objects. To keep
 the EEezTower class as simple  as possible, all of the geometry
 information carried by the towers is initialized from the EEezAnalysis
 class. This has the side effect of making the cluster finder fairly
 independent of the EEMC geometry.

 The EEezAnalysis class has privately-held arrays to hold all detector
 elements: <br>
  EEezTower m_Towers[720];
  EEezStrip m_Strips[12][2][288];

 Several inline member functions are available which provide direct
 access to the m_Towers array through pointers. Each element in
 m_Towers contains pointers to neighboring towers, and to the
 appropriate strips in the m_Strips array.

 One accesses the data stored in the m_Towers array by calling member
 functions of EEezAnalysis. These member functions return pointers into
 the m_Towers array. One should tread lightly, as any changes you make
 to a tower will be made for all running code which uses this instance
 of EEezAnalysis. (This is why I have not told you about all of the
 "set" methods on towers and strips!)

 NOTE: One may place this class into an StMaker and use it to analyse
 muDst's.  An example of this may be found in

 StRoot/StEEmcPool/StMuEEmcClusterMaker

 Constructor

 Eliminates tower/strip/pre/postshower detectors which have
 the specified bit set in the database.  The following bits
 have been defined in StEEmcDbMaker/cstructs/eemcConstDB.hh

 #define EEMCSTAT_ONLPED   0x0001 // only pedestal
 #define EEMCSTAT_STKBT    0x0002 // sticky lower bits
 #define EEMCSTAT_HOTHT    0x0004 // hot for HT trigger
 #define EEMCSTAT_HOTJP    0x0008 // hot for JP trigger
 #define EEMCSTAT_OUTPI0   0x0010 // hot in pi0 analysis
 #define EEMCSTAT_HOTSTR   0x0020 // hot esmd strip

 Once a mask has been set, it cannot be unset in the same analysis.

 Note that any detector with a nonzero "fail" bit will
 always be eliminated.

 Given the index (0-719) of an EEmc Tower, return a pointer to
 the EEezTower within the internal array.

 Given the sector (0-11), subsector (0-4) and etabin (0-11), return
 a pointer to the appropriate EEezTower within the internal array.

 A bad idea, will probably delete in near future.

 Clear out towers and strips... as an optimization, we
 only clear out those towers and strips which have been
 hit.

 Takes as input a EEfeeRawEvent (most likely a branch from
 an ezTree), and fills the m_Towers and m_Strips arrays
 with ADC and reconstructed energy response.

 As with the Fill(EEfeeRawEvent *event) method, except that it
 takes as input an EEeventDst, useful for direct processing
 of fzd files.  Currently this method populates the tower
 channels only.

 Creates a 2D eta vs phi plot from the tower readouts.

 Main initialization routine.

 Initialize the geometrical relations between towers and strips

 For each tower, access the EEmcSmdMap to determine the range
 of U and V strips which are nominally associated with each
 tower.  It then calls addUStrip() and addVStrip() on the tower
 to add pointers to these strips.

 Additionally, access the EEmcSmdMap to determine the list of
 towers which share the U and V strips.  These towers are
 added to the SMD-shared-tower lists kept by each tower.

 Initializes the m_Strips array

 Reinitializes the tower indices if they get lost.  Shouldn't be needed.

 Initializes the geometric description of the towers in the m_Towers
 array.  Loops over all towers, and sets their index, and sets pointers
 to all neighboring towers.

 Save() provides a method for copying the current state of the
 EEezAnalysis object.  It may or may not be useful at some point,
 and is kept for now.

 Will do something eventually.

 Public method used to add a tower hit.  Handles ADC --> energy
 conversion, storing seed towers, etc...  It's a public method so
 that external wrapper functions may be used to fill the m_Towers
 array for each event.

 Will eventually be moved into the loop in "Fill".

 Adds a hit to the specified SMD strip.  Handles ADC --> energy
 conversion, storing seed towers, etc...  It's a public method so
 that external wrapper functions may be used to fill the m_Towers
 array for each event.

 Will eventually be moved into the loop in "Fill".

 Initialize the pointer to the eemc database maker

 Loop over all hits in the EMC collection and add them to our
 internal array of EEezTowers.

Inline Functions

                      void Make(EEeventDst* dst)
                     Int_t Make(StMuEmcCollection* emc)
                      void setHotTower(const Char_t* tow = "05TA01")
                      void setSeedEnergy(Float_t e = 0.7)
                   Float_t getSeedEnergy()
        EEezTowerPtrVec_t* getHitTowers()
                     Int_t getNHitTowers()
                EEezTower* getHitTower(Int_t ihit)
        EEezTowerPtrVec_t* getSeedTowers()
                     Int_t getNSeedTowers()
                EEezTower* getSeedTower(Int_t iseed)
                EEezStrip* getStrip(Int_t sector, Int_t plane, Int_t strip)
          EEezSectorStats* getSectorStats(Int_t sec)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
              EEezAnalysis EEezAnalysis(const EEezAnalysis&)
                      void ~EEezAnalysis()