StEEmcClusterMaker.h

#ifndef __StEEmcClusterMaker_h__
#define __StEEmcClusterMaker_h__

#include "StMaker.h"
#include "StEEmcCluster.h"
#include "StEEmcSmdCluster.h"
#include "StEEmcA2EMaker.h"
#include "TString.h"
#include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"
#include "StEEmcUtil/EEmcSmdMap/EEmcSmdMap.h"
#include "StEEmcUtil/StEEmcSmd/EEmcSmdGeom.h"

#include <map>

class StEEmcClusterMaker : public StMaker {

 public:

  StEEmcClusterMaker( const Char_t *name = "mEEclusters" );
  ~StEEmcClusterMaker(){ /* 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 setSeedFloor( Float_t f=2.0 ); 

  Int_t numberOfClusters(Int_t sec, Int_t layer);
  Int_t numberOfSmdClusters(Int_t sec, Int_t plane);

  StEEmcCluster cluster(Int_t sec, Int_t layer, Int_t index);
  StEEmcSmdCluster smdcluster(Int_t sec, Int_t plane, Int_t index);


  StEEmcCluster cluster( StEmcCluster *cl ){ return mEtoEE[ cl ]; }
  StEEmcSmdCluster smdcluster( StEmcCluster *cl ){ return mEtoEEsmd[ cl ]; }

  StEEmcClusterVec_t clusters( Int_t sec, Int_t layer );
  StEEmcSmdClusterVec_t smdclusters( Int_t sec, Int_t plane ); 

  void setFillStEvent(){ mFillStEvent=true; }

  void suppress(){ mSuppress=true; } 

  void print();

 private:
 protected:

  Int_t mClusterId;

  Bool_t mSuppress; 

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

  std::vector< std::vector< StEEmcClusterVec_t > > mTowerClusters;
  std::vector< std::vector< StEEmcSmdClusterVec_t > > mSmdClusters;

  Int_t mNumberOfClusters[6]; 

  Float_t mSeedEnergy[6];
  Int_t mMaxExtent; 
  Float_t mSeedFloor; 

  Bool_t buildTowerClusters();

  Bool_t buildSmdClusters();

  void fillStEvent();

  Bool_t verifyStEvent();

  EEmcGeomSimple *mEEtow;
  EEmcSmdGeom    *mEEsmd;
  EEmcSmdMap     *mEEmap;

  TString mAnalysisName;
  StEEmcA2EMaker *mEEanalysis;

  Bool_t mFillStEvent;

  std::map< StEmcCluster *, StEEmcCluster > mEtoEE;       
  // ... and for smd clusters
  std::map< StEmcCluster *, StEEmcSmdCluster > mEtoEEsmd; 

  ClassDef(StEEmcClusterMaker,1);

};

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

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

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

inline StEEmcCluster StEEmcClusterMaker::cluster(Int_t s, Int_t l, Int_t i)
        { return mTowerClusters[s][l][i]; }
inline StEEmcSmdCluster StEEmcClusterMaker::smdcluster(Int_t s,Int_t p,Int_t i)
        { return mSmdClusters[s][p][i]; }

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

inline StEEmcSmdClusterVec_t StEEmcClusterMaker::smdclusters(Int_t s, Int_t l)
        { return mSmdClusters[s][l]; } 

#endif