UtilStrip.h

Go to the documentation of this file.

#ifndef UtilStrip_h
#define UtilStrip_h

#include <vector>
#include <set>

class AtmosStrip;
class SetStrip;
class DStrip;
class StripDList;
class StripCluster;

namespace UtilStrip {
  std::vector<int> GangedStrips(int strip, int end);
  std::vector<int> GangedStripsEast(int strip);
  std::vector<int> GangedStripsWest(int strip);
  std::vector<int> GangedStripsNegative(int strip);
  std::vector<int> GangedStripsPositive(int strip);

  double SumEnergy(std::set<SetStrip>);
  int NStrips(std::set<SetStrip>);
  int NDigits(std::set<SetStrip>);
}

inline std::vector<int> UtilStrip::GangedStrips(int strip, int end) {
  if(end==0) return UtilStrip::GangedStripsNegative(strip);
  else return UtilStrip::GangedStripsPositive(strip);
}

inline std::vector<int> UtilStrip::GangedStripsEast(int strip) {
  return UtilStrip::GangedStripsNegative(strip);
}

inline std::vector<int> UtilStrip::GangedStripsWest(int strip) {
  return UtilStrip::GangedStripsPositive(strip);
}

class SetStrip {
 public:
  SetStrip(int i, double d, bool b) {TCIndex=i;Energy=d;DoubleEnded=b;}
  SetStrip(int i, const AtmosStrip *strip);

  unsigned int TCIndex;
  double Energy;
  bool DoubleEnded;

  //Operators needed for std::set operations
  friend bool operator<(const SetStrip &s1, const SetStrip &s2) {
    return (s1.TCIndex < s2.TCIndex);
  }
  friend bool operator==(const SetStrip &s1, const SetStrip &s2) {
    return (s1.TCIndex == s2.TCIndex);
  }
  friend bool operator!=(const SetStrip &s1, const SetStrip &s2) {
    return (s1.TCIndex != s2.TCIndex);
  }
  friend bool operator>(const SetStrip &s1, const SetStrip &s2) {
    return (s1.TCIndex > s2.TCIndex);
  }
};

class StripCluster {
 public:
  StripCluster() {Clear();}
  void Clear();

  void AddStripDList(const StripDList &sdl);

  std::set<SetStrip> Strips;

  //Accumulate for Centroid and RMS calculation
  unsigned int NStrips;
  double SumU, SumV, SumZ, SumSqU, SumSqV, SumSqZ;

  double CentU() {return SumU/(double)NStrips;}
  double CentV() {return SumV/(double)NStrips;}
  double CentZ() {return SumZ/(double)NStrips;}

  double RMSU();
  double RMSV();
  double RMSZ();

  //Same as above but weighted by PE
  double SumPE;
  double WSumU, WSumV, WSumZ, WSumSqU, WSumSqV, WSumSqZ;

  double WCentU() {return WSumU/SumPE;}
  double WCentV() {return WSumV/SumPE;}
  double WCentZ() {return WSumZ/SumPE;}

  double WRMSU();
  double WRMSV();
  double WRMSZ();

  //Sort in reverse by number of strips
  friend bool operator<(const StripCluster &scl1, const StripCluster &scl2)
    {return(scl1.NStrips > scl2.NStrips);}
    //{return(scl1.SumWeights > scl2.SumWeights);}

};

class StripDList {
 public:
  StripDList(int i);

  unsigned int TCIndex;

  bool SetInCluster();
  bool InCluster;
  unsigned int ClusterCount;

  double U, V, Z;

  double PE;

  std::vector<DStrip> VecDStrip;
  friend bool operator< (const StripDList &sdl1, const StripDList &sdl2);
  friend bool operator==(const StripDList &sdl1, const StripDList &sdl2);
  friend bool operator!=(const StripDList &sdl1, const StripDList &sdl2);
};

class DStrip {
 public:
  DStrip(unsigned int i, double d) {
    Disp = d;
    TCIndex = i;
  }

  unsigned int TCIndex;//Index in the primary TClonesArray
  double Disp;

  friend bool operator<(const DStrip &ds1, const DStrip &ds2)
    {return(ds1.Disp < ds2.Disp);}
  friend bool operator==(const DStrip &ds1, const DStrip &ds2)
    {return(ds1.TCIndex == ds2.TCIndex);}
  friend bool operator!=(const DStrip &ds1, const DStrip &ds2)
    {return(ds1.TCIndex != ds2.TCIndex);}
};

#endif

---