StEEmcIUClusterMaker.h

#ifndef __StEEmcIUClusterMaker_h__
#define __StEEmcIUClusterMaker_h__

#include "StMaker.h"
#include "StEEmcIUCluster.h"
#include "StEEmcIUSmdCluster.h"
#include "StEEmcPool/StEEmcA2EMaker/StEEmcA2EMaker.h"
#include "TString.h"
#include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"
#include "StEEmcUtil/EEmcSmdMap/EEmcSmdMap.h"
#include "StEEmcUtil/StEEmcSmd/EEmcSmdGeom.h"

//#include "StEEmcSimulatorMaker/SlowSimUtil.h" 

#include <map>

class StEEmcIUClusterMaker : public StMaker { //, public SlowSimUtil {

 public:

  StEEmcIUClusterMaker( const Char_t *name = "mEEclusters" );
  ~StEEmcIUClusterMaker(){ /* nada */ };

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

  void analysis ( const Char_t *name );

  void seedEnergy( Float_t energy, Int_t layer=0 );  

  void setMaxExtent( Int_t m );  

  void setMinStrips( Int_t m ){ mMinStrips=m; }

  void setSeedFloor( Float_t f=2.0 ); 

  Int_t numberOfClusters(Int_t sec, Int_t layer);
  Int_t numberOfSmdClusters(Int_t sec, Int_t plane);
  Int_t TnumberOfSmdClusters(Int_t sec, Int_t plane);
  //return the difference of two u clusters' centroid
  //float diffOf2uclusters();
  //float diffOf2vclusters();
  //return the number of seed in u plan all sectors
  int numberOfUseed();
  int numberOfVseed();
  int UStripWidth();
  int VStripWidth();
  float Tenergyoftower();
  float Tenergyofp1();
  float Tenergyofp2();
  float Tenergyofp3();
  float Tenergyofsmdu();
  float Tenergyofsmdv();
  float UAmplitude();
  float VAmplitude();

  StEEmcIUCluster cluster(Int_t sec, Int_t layer, Int_t index);
  StEEmcIUSmdCluster smdcluster(Int_t sec, Int_t plane, Int_t index);


  StEEmcIUCluster cluster( StEmcCluster *cl ){ return mEtoEE[ cl ]; }
  StEEmcIUSmdCluster smdcluster( StEmcCluster *cl ){ return mEtoEEsmd[ cl ]; }

  StEEmcIUClusterVec_t clusters( Int_t sec, Int_t layer );
  StEEmcIUSmdClusterVec_t smdclusters( Int_t sec, Int_t plane ); 

  void setFillStEvent(){ mFillStEvent=true; }

  void suppress(Int_t n=0){ mSuppress=n; } 

  void skip(Bool_t s=true){ mSkip=s; }

  void loose(Bool_t l=true){ mLoose=l; }

  void print();

 private:
 protected:

  TH1D        *clusize;
  TH1D        *tclusize;
  TH1D        *cludis;
  Int_t mClusterId;
  
  Int_t mSuppress; 
  Bool_t mSkip;
  Bool_t mLoose;

  std::vector< std::vector< StEEmcTowerVec_t > > mSeedTowers;

  std::vector< std::vector< StEEmcIUClusterVec_t > > mTowerClusters;
  std::vector< std::vector< StEEmcIUSmdClusterVec_t > > mSmdClusters;
  std::vector< std::vector< StEEmcIUSmdClusterVec_t > > TmSmdClusters;

  Int_t mNumberOfClusters[6]; 
  Int_t TmNumberOfClusters[6]; 

  Float_t mSeedEnergy[6];
  Int_t mMaxExtent; 
  Int_t mMinStrips;
  Float_t mSeedFloor;
  //float UMeanclust;
  //float VMeanclust;
  int countUseed;
  int uswidth;
  int vswidth;
  float eeen;
  int countVseed;
  float uamp;
  float vamp;
  float ep1;
  float ep2;
  float ep3;
  float esmdu;
  float esmdv;
  Bool_t buildTowerClusters();

  Bool_t buildSmdClusters();

  void fillStEvent();

  Bool_t verifyStEvent();

  FILE *fout;
  FILE *fout2;
  
  // Geometry classes
  EEmcGeomSimple *mEEtow;  
  EEmcSmdGeom    *mEEsmd;  
  EEmcSmdMap     *mEEmap;  
  TString mAnalysisName;
  StEEmcA2EMaker *mEEanalysis;

  Bool_t mFillStEvent;

  std::map< StEmcCluster *, StEEmcIUCluster > mEtoEE;       
  std::map< StEmcCluster *, StEEmcIUSmdCluster > mEtoEEsmd; 

  ClassDef(StEEmcIUClusterMaker,1);

};

inline void StEEmcIUClusterMaker::analysis( const Char_t *name ){ mAnalysisName=name; }
inline void StEEmcIUClusterMaker::seedEnergy(Float_t energy, Int_t layer){ mSeedEnergy[layer]=energy; }

inline void StEEmcIUClusterMaker::setMaxExtent(Int_t m){ mMaxExtent=m; } 
inline void StEEmcIUClusterMaker::setSeedFloor(Float_t f){ mSeedFloor=f; } 

inline Int_t StEEmcIUClusterMaker::numberOfClusters(Int_t s, Int_t l) 
        { return (Int_t)mTowerClusters[s][l].size(); }
inline Int_t StEEmcIUClusterMaker::numberOfSmdClusters(Int_t s, Int_t p) 
        { return (Int_t)mSmdClusters[s][p].size(); }
inline Int_t StEEmcIUClusterMaker::TnumberOfSmdClusters(Int_t s, Int_t p) 
        { return (Int_t)TmSmdClusters[s][p].size(); }

inline StEEmcIUCluster StEEmcIUClusterMaker::cluster(Int_t s, Int_t l, Int_t i)
        { return mTowerClusters[s][l][i]; }
inline StEEmcIUSmdCluster StEEmcIUClusterMaker::smdcluster(Int_t s,Int_t p,Int_t i)
        { return mSmdClusters[s][p][i]; }

inline StEEmcIUClusterVec_t StEEmcIUClusterMaker::clusters(Int_t s, Int_t l)
        { return mTowerClusters[s][l]; }

inline StEEmcIUSmdClusterVec_t StEEmcIUClusterMaker::smdclusters(Int_t s, Int_t l)
        { return mSmdClusters[s][l]; } 
//inline float StEEmcIUClusterMaker::diffOf2uclusters() { return (float) abs(UMeanclust); }
//inline float StEEmcIUClusterMaker::diffOf2vclusters() { return (float) abs(VMeanclust); }
inline int StEEmcIUClusterMaker::numberOfUseed() { return (int) countUseed; }
inline int StEEmcIUClusterMaker::numberOfVseed() { return (int) countVseed; }
inline float StEEmcIUClusterMaker::Tenergyoftower() { return (float) eeen; }
inline int StEEmcIUClusterMaker::UStripWidth() { return (int) uswidth; }
inline int StEEmcIUClusterMaker::VStripWidth() { return (int) vswidth; }
inline float StEEmcIUClusterMaker::UAmplitude() { return (float) uamp; }
inline float StEEmcIUClusterMaker::VAmplitude() { return (float) vamp; }
inline float StEEmcIUClusterMaker::Tenergyofp1() { return (float) ep1; }
inline float StEEmcIUClusterMaker::Tenergyofp2() { return (float) ep2; }
inline float StEEmcIUClusterMaker::Tenergyofp3() { return (float) ep3; }
inline float StEEmcIUClusterMaker::Tenergyofsmdu() { return (float) esmdu; }
inline float StEEmcIUClusterMaker::Tenergyofsmdv() { return (float) esmdv; }
#endif