StEEmcIUSmdCluster.h

#ifndef __StEEmcIUSmdCluster_h__
#define __StEEmcIUSmdCluster_h__

#include <cassert>
#include <TObject.h>
#include "StEEmcPool/StEEmcA2EMaker/StEEmcStrip.h"
#include "StEEmcPool/StEEmcA2EMaker/StEEmcTower.h"

class StEmcCluster;

class StEEmcIUSmdCluster : public TObject {

 public:

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

  StEEmcIUSmdCluster ( const StEEmcIUSmdCluster &c );

  void add( StEEmcStrip strip, Float_t weight=1.0 );

  Int_t key(){ return mKey; }
  Int_t key()const { return mKey; }

  void  key(Int_t k){ mKey=k; }
  
  Float_t energy();
  Float_t energy()const;
  Float_t mean();
  Float_t mean()const;
  Float_t sigma();
  Float_t sigma()const;

  void mean(Float_t x){ mMean=x; }
  void sigma(Float_t s){ mSigma=s; }
  void energy( Float_t e){ mEnergy=e; }

  Float_t energy( Int_t nmax, Option_t *opts="mean" );
  Float_t sigma( Int_t nmax, Option_t *opts="mean" );

  /*
  Float_t energy3(){ return energy(3,"seed"); }
  Float_t energy5(){ return energy(5,"seed"); }
  Float_t sigma3(){ return sigma(3,"seed"); }
  Float_t sigma5(){ return sigma(5,"seed"); }
  */

  Int_t size();

  StEEmcTowerVec_t towers();
  Int_t numberOfMatchedTowers();
  StEEmcTower tower(Int_t t);

  Bool_t operator>( StEEmcIUSmdCluster &other );

  Int_t numberOfStrips(){ return (Int_t)mStrips.size(); }

  StEEmcStrip strip(Int_t s){ return mStrips[s]; }

  StEEmcStrip seed(){ assert(mStrips.size()>0); return mStrips[0]; } 

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

  StEmcCluster *stemc();
  void stemc( StEmcCluster *c ){ mEmcCluster = c; }
  void print();

 private:
 protected:
  
  Int_t mKey;

  StEEmcStripVec_t mStrips;         
  std::vector<Float_t> mWeights;    

  Int_t mSize;  

  Float_t mEnergy;

  Float_t mSumXW;
  Float_t mSumX2W;

  Float_t mMean;
  Float_t mSigma;
  Int_t   mPlane;
  Int_t   mSector;

  StEEmcTowerVec_t mMatchedTowers;  

  StEmcCluster *mEmcCluster;

  ClassDef(StEEmcIUSmdCluster,1);

};

inline Float_t StEEmcIUSmdCluster::energy(){ return mEnergy; }
inline Float_t StEEmcIUSmdCluster::mean(){ return mMean; }
inline Float_t StEEmcIUSmdCluster::sigma(){ return mSigma; }

inline Float_t StEEmcIUSmdCluster::energy()const{ return mEnergy; }
inline Float_t StEEmcIUSmdCluster::mean()const{ return mMean; }
inline Float_t StEEmcIUSmdCluster::sigma()const{ return mSigma; }

inline Int_t StEEmcIUSmdCluster::size(){ return (Int_t)mSize; }

inline StEEmcTowerVec_t StEEmcIUSmdCluster::towers(){ return mMatchedTowers; }
inline Int_t            StEEmcIUSmdCluster::numberOfMatchedTowers(){ return (Int_t)mMatchedTowers.size(); }
inline StEEmcTower      StEEmcIUSmdCluster::tower(Int_t t){ return mMatchedTowers[t]; }
inline Bool_t           StEEmcIUSmdCluster::operator>(StEEmcIUSmdCluster &other){ return (this->energy() > other.energy()); }


inline Bool_t inner( const StEEmcIUSmdCluster &me, const StEEmcIUSmdCluster &you) { return me.mean()<you.mean(); } 
inline Bool_t outer( const StEEmcIUSmdCluster &me, const StEEmcIUSmdCluster &you) { return me.mean()>you.mean(); }
inline Bool_t Energy( const StEEmcIUSmdCluster &me, const StEEmcIUSmdCluster &you) { return me.energy()>you.energy(); }
inline Bool_t Key(const StEEmcIUSmdCluster &me, const StEEmcIUSmdCluster &you) { return me.key()<you.key(); }



typedef std::vector<StEEmcIUSmdCluster> StEEmcIUSmdClusterVec_t;

#endif