StEEmcSmdCluster.h

#ifndef __StEEmcSmdCluster_h__
#define __StEEmcSmdCluster_h__

#include <TObject.h>
#include "StEEmcStrip.h"
#include "StEEmcTower.h"

class StEmcCluster;

class StEEmcSmdCluster : public TObject {

 public:

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

  StEEmcSmdCluster ( const StEEmcSmdCluster &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;

  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>( StEEmcSmdCluster &other );

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

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

  Int_t plane(){ return mStrips[0].plane(); }
  Int_t sector(){ return mStrips[0].sector(); }

  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;

  StEEmcTowerVec_t mMatchedTowers;  

  StEmcCluster *mEmcCluster;

  ClassDef(StEEmcSmdCluster,1);

};

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

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

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

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


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



typedef std::vector<StEEmcSmdCluster> StEEmcSmdClusterVec_t;

#endif