StationXPositionMatrix.h

Go to the documentation of this file.

#ifndef _CachedXShowerRegeneratorAG_StationPositionMatrix_h_
#define _CachedXShowerRegeneratorAG_StationPositionMatrix_h_

#include <utl/MathConstants.h>
#include <sdet/Station.h>
#include <sevt/Station.h>


namespace CachedXShowerRegeneratorAG {

  class StationInfo {

  public:
    StationInfo(const sdet::Station& dStation, sevt::Station& eStation,
                const double phi, const double dphi,
                const double r, const double r1, const double r2,
                const double area) :
      fDetStation(&dStation),
      fEvtStation(&eStation),
      fR(r),
      fR1(r1),
      fR2(r2),
      fResamplingArea(area)
    {
      SetPhiRange(phi, dphi);
    }

    bool IsIn(const double phi, const double r) const
    { return IsPhiIn(phi) && IsRIn(r); }

    const sdet::Station& GetDetStation() const { return *fDetStation; }

    sevt::Station& GetEvtStation() const { return *fEvtStation; }

    double GetResamplingArea() const { return fResamplingArea; }

    double GetPhi1() const { return fPhi1; }

    double GetPhi2() const { return fPhi2; }

    double GetR() const { return fR; }

    double GetR1() const { return fR1; }

    double GetR2() const { return fR2; }

    void Dump() const;

  private:
    void
    SetPhiRange(const double phi, const double dphi)
    {
      using namespace utl;
      fPhi1 = phi - dphi;
      fPhi2 = phi + dphi;
      if (fPhi1 < -kPi) {
        if (fPhi2 > kPi) {
          fPhi1 = -kPi;
          fPhi2 = kPi;
        } else
          fPhi1 += 2*kPi;
      } else if (fPhi2 > kPi)
        fPhi2 -= 2*kPi;
    }

    bool
    IsPhiIn(const double phi)
      const
    {
      if (fPhi1 < fPhi2)
        return fPhi1 <= phi && phi <= fPhi2;
      else
        return fPhi1 <= phi || phi <= fPhi2;
    }

    bool IsRIn(const double r) const
    { return fR1 <= r && r <= fR2; }

    const sdet::Station* fDetStation;
    sevt::Station* fEvtStation;
    bool fPhiCrossing;
    double fPhi1;
    double fPhi2;
    double fR;
    double fR1;
    double fR2;
    double fResamplingArea;
  };


  using namespace std;
  using namespace utl;

  class StationPositionMatrix {
  public:
    typedef vector<StationInfo> StationInfoList;
    typedef vector<const StationInfo*> StationInfoPtrList;

    StationPositionMatrix(const double phiGranularity, const double rGranularity) :
      fPhiGranularity(phiGranularity),
      fRGranularity(rGranularity),
      fNPhi(0),
      fPhiStep(0),
      fNR(0),
      fR1(0),
      fRStep(0)
    { }

    void
    PushBack(const sdet::Station& dStation, sevt::Station& eStation,
             const double phi, const double dphi,
             const double r, const double r1, const double r2,
             const double area)
    {
      const StationInfo info(dStation, eStation, phi, dphi, r, r1, r2, area);
      fStations.push_back(info);
    }

    void CreateMatrix(const bool useSpatialStationMatrix = true);

    const StationInfoList& GetStationList() const
    { return fStations; }

    double GetMinR() const { return fR1; }

    const StationInfoPtrList&
    GetStationList(const double phi, const double r)
      const
    {
      const int iR = GetRIndex(r);
      if (iR < 0 || iR >= fNR)
        return fEmptyStationInfoPtrList;
      const int iPhi = GetPhiIndex(phi);
      return fStationMatrix[iPhi][iR];
    }

    void Clear();

    void DumpStats() const;

  private:
    int
    GetPhiIndex(const double phi)
      const
    {
      const int i = int((phi + utl::kPi) / fPhiStep);
      return (i < fNPhi) ? i : fNPhi - 1;
    }

    int GetRIndex(const double r) const
    { return int((r - fR1) / fRStep); }

    void Resize(const int nPhi, const int nR);

    const double fPhiGranularity;
    const double fRGranularity;

    int fNPhi;
    double fPhiStep;
    int fNR;
    double fR1;
    double fRStep;

    StationInfoList fStations;

    typedef vector<vector<StationInfoPtrList> > StationMatrix;
    StationMatrix fStationMatrix;

    StationInfoPtrList fEmptyStationInfoPtrList;
  };

}


#endif