StEEmcClusterMaker.h

#ifndef __StEEmcClusterMaker_h__
#define __StEEmcClusterMaker_h__

#include "StMaker.h"
#include "StEEmcCluster.h"
#include "StEEmcSmdCluster.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 StEEmcClusterMaker : public StMaker {
public:

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

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

  void analysis ( const Char_t *name ) { mAnalysisName=name; }

  void seedEnergy( Float_t energy, Int_t layer=0 ) { mSeedEnergy[layer]=energy; }

  void setMaxExtent( Int_t m ) { mMaxExtent=m; }

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

  void setSeedFloor( Float_t f=2.0 ) { mSeedFloor=f; } 

  Int_t numberOfClusters(Int_t sec, Int_t layer) const { return (Int_t)mTowerClusters[sec][layer].size(); }
  Int_t numberOfSmdClusters(Int_t sec, Int_t plane) const { return (Int_t)mSmdClusters[sec][plane].size(); }

  StEEmcCluster &cluster(Int_t sec, Int_t layer, Int_t index) { return mTowerClusters[sec][layer][index]; }
  const StEEmcCluster &cluster(Int_t sec, Int_t layer, Int_t index) const { return mTowerClusters[sec][layer][index]; }
  StEEmcSmdCluster &smdcluster(Int_t sec, Int_t plane, Int_t index) { return mSmdClusters[sec][plane][index]; }
  const StEEmcSmdCluster &smdcluster(Int_t sec, Int_t plane, Int_t index) const { return mSmdClusters[sec][plane][index]; }

  StEEmcCluster &cluster(const StEmcCluster *cl ){ return (*(mEtoEE.find(cl))).second; }
  const StEEmcCluster &cluster(const StEmcCluster *cl ) const { return (*(mEtoEE.find(cl))).second; }
  StEEmcSmdCluster &smdcluster(const StEmcCluster *cl ){ return (*(mEtoEEsmd.find(cl))).second; }
  const StEEmcSmdCluster &smdcluster(const StEmcCluster *cl ) const { return (*(mEtoEEsmd.find(cl))).second; }

  StEEmcClusterVec_t &clusters( Int_t sec, Int_t layer ) { return mTowerClusters[sec][layer]; }
  const StEEmcClusterVec_t &clusters( Int_t sec, Int_t layer ) const { return mTowerClusters[sec][layer]; }
  StEEmcSmdClusterVec_t &smdclusters( Int_t sec, Int_t plane ) { return mSmdClusters[sec][plane]; } 
  const StEEmcSmdClusterVec_t &smdclusters( Int_t sec, Int_t plane ) const { return mSmdClusters[sec][plane]; } 

  void setFillStEvent(){ mFillStEvent=true; }

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

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

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

  void print() const;

protected:

  Int_t mClusterId;
  
  Int_t mSuppress; 
  Bool_t mSkip;
  Bool_t mLoose;

  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; 
  Int_t mMinStrips;
  Float_t mSeedFloor; 

  virtual Bool_t buildTowerClusters();

  virtual Bool_t buildSmdClusters();

  void fillStEvent();

  Bool_t verifyStEvent() const;

  // Geometry classes
  const EEmcGeomSimple *mEEtow;  
  const EEmcSmdGeom    *mEEsmd;  
  const EEmcSmdMap     *mEEmap;  
  TString mAnalysisName;
  const StEEmcA2EMaker *mEEanalysis;

  Bool_t mFillStEvent;

  std::map<const StEmcCluster *, StEEmcCluster > mEtoEE;       
  std::map<const StEmcCluster *, StEEmcSmdCluster > mEtoEEsmd; 

  ClassDef(StEEmcClusterMaker,1);
};

#endif