StEEmcGenericClusterMaker.h

#ifndef __StEEmcGenericClusterMaker_h__
#define __StEEmcGenericClusterMaker_h__

#include "StMaker.h"
#include "StEEmcCluster.h"
#include "StEEmcSmdCluster.h"

class TH1F;
class TH2F;
class StEEmcA2EMaker;

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

#include <map>

#include "TRefArray.h"
#include "TClonesArray.h"

class TH1F;
class TH2F;

//#include "StEEmcClusterCollection.h"

class StMuTrack;
#include "StarClassLibrary/StPhysicalHelixD.hh"

class StEEmcGenericClusterMaker : public StMaker
{
public:

  StEEmcGenericClusterMaker( const Char_t *name, const StEEmcA2EMaker *a2e=NULL );
  virtual ~StEEmcGenericClusterMaker(){ /* nada */ }

  virtual Int_t Init();  

  virtual Int_t Make();

  void  makeHistograms();
  void  makeClusterMap();
  void  makeStEvent();
  void  makeTrackMap();

  virtual void  Clear(Option_t *opts="");

  void add(const StEEmcCluster &cluster);

  void add(const StEEmcSmdCluster &cluster) { 
    StEEmcSmdCluster c = cluster;
    c.key(nextClusterId()); 
    mSmdClusters[ c.sector() ][ c.plane() ].push_back( c ); 
    mNumberOfClusters[c.strip(0).plane()+4]++; 
  }

  void remove(const StEEmcCluster &cluster){ /* needs to be implemented */ }

  void remove(const StEEmcSmdCluster &cluster){ /* needs to be implemented */ }
    
  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]; }

  StEEmcCluster &cluster(Int_t sector, Int_t layer, Int_t index) { return mTowerClusters[sector][layer][index]; }
  const StEEmcCluster &cluster(Int_t sector, Int_t layer, Int_t index) const { return mTowerClusters[sector][layer][index]; }

  StEEmcSmdCluster &smdcluster(Int_t sector, Int_t plane, Int_t index) { if ( plane < 2 ) return mSmdClusters[sector][plane][index]; else assert(0); /* please specify an smd plane 0=U or 1=V */}
  const StEEmcSmdCluster &smdcluster(Int_t sector, Int_t plane, Int_t index) const { if ( plane < 2 ) return mSmdClusters[sector][plane][index]; else assert(0); /* please specify an smd plane 0=U or 1=V */}

  Int_t numberOfTracks(const StEEmcCluster &cluster) const { return (Int_t)(*(mClusterTrackMap.find(cluster.key()))).second.size(); }
  Int_t numberOfBackgroundTracks(const StEEmcCluster &cluster) const { return (Int_t)(*(mBackgroundTrackMap.find(cluster.key()))).second.size(); }

  StMuTrack *track(const StEEmcCluster &cluster, Int_t index) const { return (*(mClusterTrackMap.find(cluster.key()))).second[index]; }
  StMuTrack *backgroundTrack(const StEEmcCluster &cluster, Int_t index) const { return (*(mBackgroundTrackMap.find(cluster.key()))).second[index]; }

  Int_t numberOfClusters(Int_t sector, Int_t layer) const{
    if ( layer < 4 ) 
      return (Int_t)mTowerClusters[ sector ][ layer ].size();
    else if ( layer < 6 )
      return (Int_t)mSmdClusters[ sector ][ layer-4 ].size();
    else
      return -1;
  }
  Int_t numberOfClusters(Int_t layer) const{ return mNumberOfClusters[layer]; }
  Int_t numberOfClusters() const { return mClusterId; }

  struct EEmatch 
  {
    StEEmcClusterVec_t  tower;
    StEEmcClusterVec_t  pre1;
    StEEmcClusterVec_t  pre2;
    StEEmcClusterVec_t  post;
    StEEmcSmdClusterVec_t  smdu;
    StEEmcSmdClusterVec_t  smdv;
    StEEmcStripVec_t ustrips;
    StEEmcStripVec_t vstrips;
  };

  EEmatch &clusterMatch(const StEEmcCluster &c) { return mClusterMap[ c.key() ]; }
  const EEmatch &clusterMatch(const StEEmcCluster &c) const { return (*(mClusterMap.find(c.key()))).second; }

  Int_t lastClusterId() const { return mClusterId; }

  Int_t numberOfMatchingSmdClusters(const StEEmcCluster &cluster, Int_t plane ) const;

  StEEmcSmdCluster &matchingSmdCluster (const StEEmcCluster &cluster, Int_t plane, Int_t index );
  const StEEmcSmdCluster &matchingSmdCluster (const StEEmcCluster &cluster, Int_t plane, Int_t index ) const;

  void setTrackMatching( Float_t distance, Int_t layer ){ mClusterTrackSeparation[layer] = distance; }

  Bool_t extrapolateToZ( const StPhysicalHelixD &helix, const double z, TVector3 &r) const;

  void buildHistograms(const StEEmcCluster &cluster);

  Int_t nextClusterId() { return mClusterId++; }
  Int_t maxClusterId() const { return mClusterId; }

  virtual const char* GetCVS() const
                {static const char cvs[]="Tag $Name:  $ $Id: StEEmcGenericClusterMaker.h,v 1.8 2014/08/06 11:42:59 jeromel Exp $ built " __DATE__ " " __TIME__; return cvs;}

protected:

  // EEMC adc to energy
  const StEEmcA2EMaker *mEEanalysis;

  //  StEEmcClusterCollection *mCollection;

  // Keeps track of clusters
  Int_t mClusterId;

  // mTowerClusters[sec][layer] provides list of tower
  // clusters at specified layer in the given sector,
  // where the sector is determined by the seed tower.
  std::vector< std::vector< StEEmcClusterVec_t > > mTowerClusters;

  // mSmdClusters[sec][plane] provides a list of SMD
  // clusters in the given sector for the given plane
  std::vector< std::vector< StEEmcSmdClusterVec_t > > mSmdClusters;

  // keeps track of total number of clusters in each layer
  Int_t mNumberOfClusters[6];

  // Pointers to geometry classes
  const EEmcGeomSimple *mEEmcGeom;
  const EEmcSmdGeom    *mESmdGeom;
  const EEmcSmdMap     *mESmdMap;

  virtual Int_t buildTowerClusters(){ return kStOK; }
  virtual Int_t buildPreshowerClusters(){ return kStOK; }
  virtual Int_t buildPostshowerClusters(){ return kStOK; }
  virtual Int_t buildSmdClusters(){ return kStOK; }

  Bool_t match(const StEEmcCluster &c1, const StEEmcCluster &c2 ) const;
  Bool_t match(const StEEmcCluster &c1, const StEEmcSmdCluster &c2 ) const;
  Bool_t match(const StEEmcSmdCluster &c1, const StEEmcSmdCluster &c2 ) const;

  Bool_t match(const StEEmcCluster &c1, const StMuTrack *track ) const;
  Bool_t match(const StEEmcSmdCluster &c1, const StMuTrack *track ) const { return false; } /* needs to be implemented */  

  Bool_t matchBackgroundTrack(const StEEmcCluster &c1, const StMuTrack *track) const;

  Int_t mSmdMatchRange;

  // hash tables holding relationships between tower clusters and
  // pre/post and/or smd clusters

  // use mClusterMap[ cluster_key ] to grab all clusters which match
  // a given cluster.  All mappings are handled here.
  std::map< Int_t, EEmatch > mClusterMap;

  // use mClusterTrackMap[ cluster_key ] to grab all StMuTracks which
  // are matched to the cluster
  std::map< Int_t, std::vector< StMuTrack* > > mClusterTrackMap;
  std::map< Int_t, std::vector< StMuTrack* > > mBackgroundTrackMap;

  // use mTrackClusterMap[ track->id() ] to grab all clusters 
  // which match the given track (needs implementation)
  std::map< Int_t, EEmatch > mTrackClusterMap;

  // Maximum distance between clusters and tracks where they will
  // be associtated.  TPQRUV
  Float_t mClusterTrackSeparation[6];

  ClassDef(StEEmcGenericClusterMaker,1);
};

#endif