StEEmcGenericPointMaker.h

#ifndef __StEEmcGenericPointMaker_h__
#define __StEEmcGenericPointMaker_h__

#include "StMaker.h"

#include <vector>
#include <map>

#include "StEEmcPool/StEEmcA2EMaker/StEEmcA2EMaker.h"
#include "StEEmcPool/StEEmcClusterMaker/StEEmcGenericClusterMaker.h"

#include "StEEmcPoint.h"
//#include "StEvent/StEmcPoint.h"

#include "StEEmcUtil/EEmcGeom/EEmcGeomSimple.h"
#include "StEEmcUtil/StEEmcSmd/EEmcSmdGeom.h"
#include "StEEmcUtil/EEmcSmdMap/EEmcSmdMap.h"

class TH1F;
class TH2F;

class StEEmcGenericPointMaker : public StMaker
{
public:
  StEEmcGenericPointMaker(const Char_t *name="EEmcPointMaker", const StEEmcA2EMaker *a2e=NULL, const StEEmcGenericClusterMaker *cl=NULL );
  virtual ~StEEmcGenericPointMaker(){ /* nada */ };

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

  StEEmcPointVec_t &points() { return mPoints ; }
  const StEEmcPointVec_t &points() const { return mPoints ; }
  StEEmcPointVec_t &smdPoints() { return mSmdPoints; }
  const StEEmcPointVec_t &smdPoints() const { return mSmdPoints; }
  StEEmcPointVec_t &towerPoints() { return mTowerPoints;} 
  const StEEmcPointVec_t &towerPoints() const { return mTowerPoints;} 

  Int_t numberOfPoints() const { return mPoints.size(); }
  Int_t numberOfSmdPoints() const { return mSmdPoints.size(); }
  Int_t numberOfTowerPoints() const { return mTowerPoints.size(); }

  StEEmcPoint &point( Int_t ipoint ) { return mPoints[ipoint]; }
  const StEEmcPoint &point( Int_t ipoint ) const { return mPoints[ipoint]; }
  StEEmcPoint &smdPoint( Int_t ipoint ) { return mSmdPoints[ipoint]; }
  const StEEmcPoint &smdPoint( Int_t ipoint ) const { return mSmdPoints[ipoint]; }
  StEEmcPoint &towerPoint( Int_t ipoint ) { return mTowerPoints[ipoint]; }
  const StEEmcPoint &towerPoint( Int_t ipoint ) const { return mTowerPoints[ipoint]; }

  void addPoint(const StEEmcPoint &point );
  void addSmdPoint(const StEEmcPoint &point );
  void addTowerPoint(const StEEmcPoint &point );

  StEEmcPointVec_t &points(const StEEmcCluster &cluster ) { return (*(mCluster2points.find(cluster.key()))).second; }
  const StEEmcPointVec_t &points(const StEEmcCluster &cluster ) const { return (*(mCluster2points.find(cluster.key()))).second; }
  Int_t numberOfPoints(const StEEmcCluster &c ) const { return (Int_t)(*(mCluster2points.find(c.key()))).second.size(); }

  StEEmcCluster &cluster(const StEEmcPoint &point ){ return (*(mPoint2cluster.find(point.key()))).second; }

protected:

  Int_t mKey;
  Int_t nextPointId(){ return mKey++; }

  const StEEmcA2EMaker            *mEEanalysis;                            
  const StEEmcGenericClusterMaker *mEEclusters;                            
  StEEmcPointVec_t mPoints;                                          
  StEEmcPointVec_t mSmdPoints;                                       
  StEEmcPointVec_t mTowerPoints;                                     
  StEEmcPointVec_t buildSmdPoints(Int_t sector, const StEEmcSmdClusterVec_t &u, const StEEmcSmdClusterVec_t &v); 
  StEEmcPointVec_t buildTowerPoints(Int_t sector, const StEEmcClusterVec_t &c );                           
  StEEmcPointVec_t buildPoints( const StEEmcClusterVec_t &towerClusters, const StEEmcSmdClusterVec_t &u, const StEEmcSmdClusterVec_t &v );   
  const EEmcGeomSimple *mEEtow; 
  const EEmcSmdGeom    *mEEsmd; 
  const EEmcSmdMap     *mEEmap; 
  void fillStEvent();

  TH1F *hNumberOfPoints; 
  TH1F *hEnergyOfPoints;
  TH2F *hDistributionOfPoints;

  TH1F *hTotalEnergy[6];       
  TH1F *hTotalPointEnergy[6];  
  std::map< Int_t, StEEmcPointVec_t > mCluster2points;
  std::map< Int_t, StEEmcCluster    > mPoint2cluster;

  ClassDef(StEEmcGenericPointMaker,1);
};

#endif