StEEmcPoint.h

#ifndef __StEEmcPoint_h__
#define __StEEmcPoint_h__

#include "TObject.h"
#include "TVector3.h"

#include "StEEmcPool/StEEmcA2EMaker/StEEmcTower.h"
#include "StEEmcPool/StEEmcClusterMaker/StEEmcCluster.h"
#include "StEEmcPool/StEEmcClusterMaker/StEEmcSmdCluster.h"

class StEmcPoint;

class StEEmcPoint : public TObject {
public:

  StEEmcPoint();
  StEEmcPoint( const StEEmcPoint &p );
  virtual ~StEEmcPoint(){ /* nada */ };

  void position( const TVector3 &p ) { mPosition=p; }
  void energy( Float_t e, Int_t layer=0 ) { mEnergy[layer]=e; }
  void fraction ( Float_t f ) { mFraction=f; }
  void tower( const StEEmcTower &t, Float_t w=1. ) { mTowers.push_back(t); mWeights.push_back(w); }
  void cluster( const StEEmcSmdCluster &c, Int_t plane ) {
    mSmdClusters[plane]=c;
    mSector=c.sector();
    if (plane==0)
        mU=c.mean();
    else
        mV=c.mean();
  }

  void cluster( const StEEmcCluster &c, Int_t layer){ mTowerClusters[layer].push_back(c); }

  StEEmcClusterVec_t &clusters(Int_t layer){ return mTowerClusters[layer]; }
  const StEEmcClusterVec_t &clusters(Int_t layer) const { return mTowerClusters[layer]; }

  void numberOfRelatives( Int_t r ) { mRelatives=r; }

  const TVector3 &position() const { return mPosition; }
  Float_t  fraction() const { return mFraction; }
  Float_t  energy(Int_t layer=0) const { return mEnergy[layer]; }
  Int_t numberOfTowers() const { return (Int_t)mTowers.size(); }
  const StEEmcTower &tower(Int_t t) const { return mTowers[t]; }
  Float_t weight(Int_t t) const { return mWeights[t]; }
  StEEmcSmdCluster &cluster(Int_t c) { return mSmdClusters[c]; } 
  const StEEmcSmdCluster &cluster(Int_t c) const { return mSmdClusters[c]; } 

  Int_t numberOfRelatives() const { return mRelatives; }

  StEmcPoint *stemc();

  Int_t sector() const { return mSector; }
  void sector(Int_t s){ mSector=s; }

  Float_t sigma() const { return mSigma; }
  void sigma(Float_t s) { mSigma=s; }
  
  Float_t u() const { return mU; }
  void u(Float_t uu){ mU=uu; }

  Float_t v() const { return mV; }
  void v(Float_t vv){ mV=vv; }

  Float_t residueU() const { return mResidueU; }
  void residueU(Float_t r){ mResidueU=r; }
  Float_t residueV() const { return mResidueV; }
  void residueV(Float_t r){ mResidueV=r; }
  
  void print() const;
  
  Bool_t operator<( const StEEmcPoint &other ) const { return this->energy() < other.energy(); }  
  Bool_t chiSquare( const StEEmcPoint &other ) const;

  Int_t key() const { return mKey; }
  void  key( Int_t k ) { mKey = k; }

  Float_t asymmetry() const {
    Float_t esum=cluster(0).energy()+cluster(1).energy();
    Float_t edif=cluster(0).energy()-cluster(1).energy();
    if(esum>0.)
        return edif/esum;
    return 9.0E9;
  }

  Float_t chisquared() const {
    Float_t edif = ( mSmdClusters[0].energy() - mSmdClusters[1].energy() );
    Float_t esum = ( mSmdClusters[0].energy() + mSmdClusters[1].energy() );
    Float_t nmip = 1000.0*esum / 1.3;
    if ( nmip > 0. ) return (edif*edif)/nmip;
    return -1.0;
  }

protected:
  TVector3 mPosition;
  Float_t mEnergy[4];
  Float_t mFraction;

  Int_t   mSector;
  Float_t mSigma;
  Float_t mU;
  Float_t mV;
  Float_t mResidueU;
  Float_t mResidueV;
 
  StEEmcSmdCluster mSmdClusters[2];

  std::vector< StEEmcClusterVec_t > mTowerClusters;

  StEEmcTowerVec_t mTowers;       
  std::vector<Float_t> mWeights;  

  Int_t mRelatives;

  StEmcPoint *mEmcPoint;

  Int_t mKey;

  ClassDef(StEEmcPoint,1);

};

typedef std::vector<StEEmcPoint> StEEmcPointVec_t;

inline Bool_t chiSquare( const StEEmcPoint &me, const StEEmcPoint &other ) { return me.chiSquare( other ); }

inline Bool_t Asymmetry( const StEEmcPoint &me, const StEEmcPoint &other ){ 
  return TMath::Abs(me.asymmetry()) < TMath::Abs(other.asymmetry()); 
}

#endif