StEEmcIUPointMaker.h

#ifndef __StEEmcIUPointMaker_h__
#define __StEEmcIUPointMaker_h__

#include "StMaker.h"
#include "TString.h"
#include "StEEmcIUCluster.h"
#include "StEEmcIUSmdCluster.h"
#include "StEEmcIUPoint.h" 


#include <map>

class StEEmcA2EMaker;
class StEEmcIUClusterMaker;
class TH1F;
class TH2F;
class EEmcGeomSimple;
class EEmcSmdMap;
class EEmcSmdGeom; 

class StEEmcIUPointMaker : public StMaker {

 public:

  StEEmcIUPointMaker( const Char_t *name );
  ~StEEmcIUPointMaker(){ /* nada */ };

  Int_t Init();
  Int_t Make();
  void  Clear(Option_t *opts="");
  void analysis(const Char_t *name);
  void clusters(const Char_t *name);

  void towerThreshold( Float_t t) { mTowerThreshold=t; }

  void smdMatch( Float_t s ){ mSmdMatch = s; }
  //Int_t key(){ return mKey; }
  //Int_t key()const { return mKey; }

  //void  key(Int_t k){ mKey=k; }

  StEEmcIUPointVec_t points();
  Int_t numberOfPoints(); 
  StEEmcIUPoint point(Int_t ipoint); 

  StEEmcIUPointVec_t smdPoints();
  Int_t numberOfSmdPoints();
  StEEmcIUPoint smdPoint(Int_t ip); 

  Float_t energySeen(){ return mEseen; }

  void setFillStEvent(){ mFillStEvent=true; }

  void setEnergyMode(Int_t mode){ mEnergyMode=mode; }
  void setLimit(Int_t l){ mLimit=l; }


  StEEmcIUPoint point( StEmcPoint *p ){ return mEtoEE[p]; }


 private:
 protected:
  Int_t ukey;
  Int_t vkey;
 
  TString mNameAnalysis; 
  TString mNameClusters; 
  StEEmcA2EMaker     *mEEanalysis; 
  StEEmcIUClusterMaker *mEEclusters; 

  EEmcGeomSimple *mEEtow; 
  EEmcSmdGeom    *mEEsmd; 
  EEmcSmdMap     *mEEmap; 
  TH1F       *hZEratio;
  TH1F       *pointet;
  TH2F       *pointgeo;
  void fillStEvent();
  void verifyStEvent();

  StEEmcIUPointVec_t mPoints;  

  StEEmcIUPointVec_t mSmdPoints;  

  std::map< StEEmcIUSmdCluster, StEEmcIUPointVec_t > mUclusters2points; 
  std::map< StEEmcIUSmdCluster, StEEmcIUPointVec_t > mVclusters2points; 
  
  StEEmcIUPointVec_t buildSmdPoints( Int_t sector, StEEmcIUSmdClusterVec_t &u, StEEmcIUSmdClusterVec_t &v );
  Bool_t findPoints ( Int_t sector, 
                      StEEmcIUSmdClusterVec_t u, 
                      StEEmcIUSmdClusterVec_t v, 
                      StEEmcIUPointVec_t &p );

  void shareEnergy();
  void shareEnergySimple();
  void shareEnergySmd();
  void countRelatives();
  void removeCluster( StEEmcIUSmdClusterVec_t &clusters, Int_t key );

  Float_t  fracp2t( StEEmcIUPoint &p, StEEmcTower &t );

  Float_t mTowerThreshold;
  Float_t mSmdMatch;
  Float_t mEseen;
  Bool_t mFillStEvent;
  Int_t mEnergyMode;
  Int_t mLimit;

  std::map<StEmcPoint *, StEEmcIUPoint> mEtoEE;    

  ClassDef(StEEmcIUPointMaker,1);

};

inline void StEEmcIUPointMaker::analysis(const Char_t *n){ mNameAnalysis=n; }
inline void StEEmcIUPointMaker::clusters(const Char_t *n){ mNameClusters=n; }

inline StEEmcIUPointVec_t StEEmcIUPointMaker::points(){ return mPoints ; }
inline Int_t StEEmcIUPointMaker::numberOfPoints(){ return mPoints.size(); } 
inline StEEmcIUPoint StEEmcIUPointMaker::point(Int_t ip){ return mPoints[ip]; } 

inline StEEmcIUPointVec_t StEEmcIUPointMaker::smdPoints(){ return mSmdPoints; }
inline Int_t StEEmcIUPointMaker::numberOfSmdPoints(){ return mSmdPoints.size(); } 
inline StEEmcIUPoint StEEmcIUPointMaker::smdPoint(Int_t ip){ return mSmdPoints[ip]; } 
#endif