StEEmcA2EMaker.h

#ifndef __StEEmcA2EMaker_h__
#define __StEEmcA2EMaker_h__

#include <StMaker.h>
#include <TString.h>
#include <vector>

#include "StEEmcUtil/EEmcGeom/EEmcGeomDefs.h"
#include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"

#include "StEEmcTower.h"
#include "StEEmcStrip.h"

class StEEmcDb;
class StMuDstMaker;
class StEventMaker;

class StMuEmcCollection;
class StEmcCollection;

class StEEmcA2EMaker : public StMaker {

 public:
  
  StEEmcA2EMaker( const Char_t *name="mEEanalysis" );
  ~StEEmcA2EMaker(){ /* nada */ };

  Int_t Init();
  Int_t Make();
  void  Clear(Option_t *opts="");

  void threshold( Float_t cut, Int_t layer );

  void database( const Char_t *dbname );

  void source( const Char_t *name, Int_t type=0 ); 

  StEEmcTowerVec_t towers(Int_t layer=0){ return mHitTowers[layer]; }

  StEEmcStripVec_t strips(Int_t sec, Int_t pln ){ return mHitStrips[sec][pln]; }

  Int_t numberOfHitTowers(Int_t layer) { return (Int_t)mHitTowers[layer].size(); }

  StEEmcTower hittower( Int_t hit, Int_t layer ){ return mHitTowers[layer][hit]; } 

  StEEmcTower tower(Int_t index, Int_t layer=0) { return mTowers[index][layer]; }

  StEEmcTower tower(Int_t sector, Int_t subsector, Int_t etabin, Int_t layer=0){return tower(index(sector,subsector,etabin),layer);}

  StEEmcTower *tower( TVector3 &r, Int_t layer );
  
  Int_t phibin( Int_t sector, Int_t subsector ) { return sector * 5 + subsector; } 
  Int_t index( Int_t sector, Int_t subsector, Int_t etabin ) { return 12 * phibin(sector, subsector) + etabin; }  
  

  StEEmcTower hightower(Int_t layer=0);
  
  Int_t numberOfHitStrips(Int_t sector, Int_t plane ) { return (Int_t)mHitStrips[sector][plane].size(); }

  StEEmcStrip hitstrip(Int_t sec,Int_t pl, Int_t hit){ return (mHitStrips[sec][pl])[hit]; } 
  
  StEEmcStrip strip(Int_t sector, Int_t plane, Int_t strip) { return mStrips[sector][plane][strip]; }
  
  Float_t energy(Int_t sec, Int_t layer) { return mEnergy[sec][layer]; }
  Float_t energy(Int_t layer); 

  Int_t numberOfHits(Int_t sec, Int_t layer){ return mHits[sec][layer]; } 

  void scale(Float_t s){ mScale=s; }
  
  private:
  protected:
  
  Float_t mScale;
  Float_t mSigmaPed[6]; // cut nsigma > ped for [0-5]=[TPQRUV]
  TString mDbName;
  TString mInputName;
  Int_t mInputType;

  StEEmcDb      *mDbMaker;
  StMuDstMaker  *mMuDstMaker;
  StEventMaker  *mEventMaker;

  EEmcGeomSimple *mEEgeom;

  Bool_t readData();
  Bool_t readMuDst();    // 0
  Bool_t readStEvent();  // 1 (not implemented)
  Bool_t readEzt();      // 2 (not implemented)

  Bool_t fillFromMuDst( StMuEmcCollection *emc );
  Bool_t fillFromSt( StEmcCollection *emc );



  void addTowerHit(Int_t sec, Int_t sub, Int_t eta, Float_t adc, Int_t layer);
  void addSmdHit(Int_t sec, Int_t plane, Int_t str, Float_t adc );

  StEEmcTower mTowers[kEEmcNumSectors*kEEmcNumSubSectors*kEEmcNumEtas][4];
  StEEmcStrip mStrips[kEEmcNumSectors][kEEmcNumSmdUVs][kEEmcNumStrips];

  std::vector< StEEmcTowerVec_t > mHitTowers;

  StEEmcTower *mHighTower[4];

  std::vector< std::vector< StEEmcStripVec_t > > mHitStrips;


  Float_t mEnergy[kEEmcNumSectors][6];
  Int_t   mHits[kEEmcNumSectors][6]; 

  ClassDef(StEEmcA2EMaker,1);

};

inline void StEEmcA2EMaker::threshold(Float_t c, Int_t l){ mSigmaPed[l]=c; }
inline void StEEmcA2EMaker::database(const Char_t *name){ mDbName=name; }
inline void StEEmcA2EMaker::source(const Char_t *name, Int_t type){ mInputName=name; mInputType=type; }

inline StEEmcTower StEEmcA2EMaker::hightower(Int_t layer){ return *mHighTower[layer]; }


#endif