StEEmcIUPoint.h

#ifndef __StEEmcIUPoint_h__
#define __StEEmcIUPoint_h__

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

#include "StEEmcPool/StEEmcA2EMaker/StEEmcTower.h"
#include "StEEmcIUSmdCluster.h"

class StEmcPoint;

class StEEmcIUPoint : public TObject {

 public:

  StEEmcIUPoint();
  ~StEEmcIUPoint(){ /* nada */ };

  StEEmcIUPoint( const StEEmcIUPoint &p );

  void position( 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( StEEmcTower t, Float_t w=1. ) { mTowers.push_back(t); mWeights.push_back(w); }
  void cluster( StEEmcIUSmdCluster c, Int_t plane ){mSmdClusters[plane]=c;mSector=c.sector();}

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

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

  Int_t numberOfRelatives(){ return mRelatives; }

  StEmcPoint *stemc();

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

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

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

  Float_t residueU(){ return mResidueU; }
  void residueU(Float_t r){ mResidueU=r; }
  Float_t residueV(){ return mResidueV; }
  void residueV(Float_t r){ mResidueV=r; }
  

  void print();
  
  Bool_t operator<( const StEEmcIUPoint &other ) const; 
  Bool_t chiSquare( const StEEmcIUPoint &other ) const;

 private:
 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;
 
  StEEmcIUSmdCluster mSmdClusters[2];

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

  Int_t mRelatives;

  StEmcPoint *mEmcPoint;

  ClassDef(StEEmcIUPoint,1);

};

typedef std::vector<StEEmcIUPoint> StEEmcIUPointVec_t;

inline Bool_t StEEmcIUPoint::operator<( const StEEmcIUPoint &other ) const { return this->energy() < other.energy(); }  
inline Bool_t chiSquare( const StEEmcIUPoint &me, const StEEmcIUPoint &other ) { return me.chiSquare( other ); }

//line Int_t StEEmcIUPoint::sector(){ if ( mSmdClusters[0].sector()==mSmdClusters[1].sector() ) return mSmdClusters[0].sector(); else return -1; }

#endif