StAssociationMaker/EMC/StEmcAssociationMaker.h

#ifndef STAR_StEmcAssociationMaker_HH
#define STAR_StEmcAssociationMaker_HH

#define NDETECTORS 4

#ifndef StMaker_H
#include "StMaker.h"
#include "TMatrix.h"
#endif

#include <map>
#include <utility>
#if !defined(ST_NO_NAMESPACES)
using std::multimap;
using std::pair;
#endif

class StEmcRawHit;
class StEmcCluster;
class StEmcPoint;
class StMcTrack;
class StMcCalorimeterHit;

class StEmcAssociation
{
  private:
    StMcTrack        *mTrack;
  public:
                     StEmcAssociation(StMcTrack *t);
    virtual          ~StEmcAssociation();
    const StMcTrack* getTrack() const           { return mTrack; }   
    ClassDef(StEmcAssociation, 1)
};

class StEmcClusterAssociation:public StEmcAssociation
{
  private:
    StEmcCluster     *mCluster;
    float            mFTrack;
    float            mFEmc;
  public:
                     StEmcClusterAssociation(StMcTrack*, StEmcCluster*, float,float);
    virtual          ~StEmcClusterAssociation();
    const StEmcCluster* getCluster() const      { return mCluster; }  
    float            getFractionTrack() const   { return mFTrack; }   
    float            getFractionCluster() const { return mFEmc; }     
    ClassDef(StEmcClusterAssociation, 1)
};
class StEmcPointAssociation:public StEmcAssociation
{
  private:
    StEmcPoint       *mPoint;
    int              mAssocType;
  public:
                     StEmcPointAssociation(StMcTrack*, StEmcPoint*, int);
    virtual          ~StEmcPointAssociation();
    const StEmcPoint*getPoint() const           { return mPoint; }      
    int              getAssociation() const     { return mAssocType; }  
    int              getAssociation(int det)    { return (det>0 && det<=NDETECTORS) ? ((mAssocType&(1<<(det-1)))!=0): 0; } 
    ClassDef(StEmcPointAssociation, 1)
};

// define basic multimap structures

#ifndef __CINT__
struct compEmcTrack   { bool operator()(const StMcTrack* a, const StMcTrack* b) const {return a<b; } };
struct compEmcHit     { bool operator()(const StEmcRawHit* a, const StEmcRawHit* b) const {return a<b; }};
struct compEmcCluster { bool operator()(const StEmcCluster* a, const StEmcCluster* b) const {return a<b; }};
struct compEmcPoint   { bool operator()(const StEmcPoint* a, const StEmcPoint* b) const {return a<b; }};
// define maps and iterators
typedef  multimap<const StMcTrack*, const StEmcClusterAssociation*, compEmcTrack>      multiEmcTrackCluster;
typedef  multimap<const StEmcCluster*, const StEmcClusterAssociation*, compEmcCluster> multiEmcClusterTrack;
typedef  multimap<const StMcTrack*, const StEmcPointAssociation*, compEmcTrack>        multiEmcTrackPoint;
typedef  multimap<const StEmcPoint*, const StEmcPointAssociation*, compEmcPoint>       multiEmcPointTrack;
//defining iterators
typedef  multiEmcTrackCluster::iterator      multiEmcTrackClusterIter; 
typedef  multiEmcClusterTrack::iterator      multiEmcClusterTrackIter; 
typedef  multiEmcTrackPoint::iterator        multiEmcTrackPointIter;   
typedef  multiEmcPointTrack::iterator        multiEmcPointTrackIter;   
typedef  multiEmcTrackCluster::value_type    multiEmcTrackClusterValue; 
typedef  multiEmcClusterTrack::value_type    multiEmcClusterTrackValue; 
typedef  multiEmcTrackPoint::value_type      multiEmcTrackPointValue;   
typedef  multiEmcPointTrack::value_type      multiEmcPointTrackValue;   
#else
class multiEmcTrackCluster;
class multiEmcClusterTrack;
class multiEmcTrackPoint;
class multiEmcPointTrack;
class multiEmcTrackClusterIter;
class multiEmcClusterTrackIter;
class multiEmcTrackPointIter;
class multiEmcPointTrackIter;
class multiEmcTrackClusterValue;
class multiEmcClusterTrackValue;
class multiEmcTrackPointValue;
class multiEmcPointTrackValue;
#endif


class StEmcAssociationMaker : public StMaker
{
  public:
                                StEmcAssociationMaker(const char* name="EmcAssoc");
         virtual                ~StEmcAssociationMaker();
                 Int_t          Init();
                 Int_t          Make();
                 Int_t          Finish();
                 void           Clear(const char*);
                 
                 void           printMaps();
                 void           printTracks();
         
         multiEmcTrackCluster*  getTrackClusterMap(Int_t i)      { if(i>0 && i<=NDETECTORS) return mTrackCluster[i-1]; else return NULL; } 
         multiEmcTrackCluster*  getTrackClusterMap(const char*);  
         multiEmcClusterTrack*  getClusterTrackMap(Int_t i)      { if(i>0 && i<=NDETECTORS) return mClusterTrack[i-1]; else return NULL; } 
         multiEmcClusterTrack*  getClusterTrackMap(const char*);  
         multiEmcTrackPoint*    getTrackPointMap()               { return mTrackPoint;} 
         multiEmcPointTrack*    getPointTrackMap()               { return mPointTrack;} 
                 Int_t          getDetNum(const char*);          
                 
                 void           setPrint(Bool_t a)               {mPrint = a;} 
         
         
  protected: 
         virtual Float_t        dEToEnergy(StMcCalorimeterHit*,Int_t);
                 Bool_t         mPrint;
                 
         multiEmcTrackCluster*  mTrackCluster[NDETECTORS];
         multiEmcClusterTrack*  mClusterTrack[NDETECTORS];
         multiEmcTrackPoint*    mTrackPoint;
         multiEmcPointTrack*    mPointTrack;
   ClassDef(StEmcAssociationMaker, 1)
};

#endif

/*******************************************************************************/

---