PndCAHits.h

Go to the documentation of this file.

//-*- Mode: C++ -*-
// *****************************************************************************
//                                                                             *
// @Autors: I.Kulakov; M.Zyzak; I.Kisel                                        *
// @e-mail: I.Kulakov@gsi.de; M.Zyzak@gsi.de; I.Kisel@compeng.uni-frankfurt.de *
//                                                                             *
// *****************************************************************************

#ifndef PNDCAHITS_H
#define PNDCAHITS_H

#include <vector>
using std::vector;

#include "PndCADef.h"
#include "PndCAGBHit.h"
#include "PndCATES.h"
#include "PndCAParameters.h"

class PndCAHit {
 public:
  PndCAHit() {}
  PndCAHit(PndCAGBHit &h, int id)
    : fIStation(h.IRow()), fId(id), fErr2X1(h.Err2X1()), fErrX12(h.ErrX12()), fErr2X2(h.Err2X2()), fR(h.R()), fErr2R(h.Err2R()), fErr2A(h.Err2A()), fIsLeft(h.IsLeft()),
      fAngle(h.Angle()), fCAHit(&h)
  {
    h.GetLocalX0X1X2(fX0, fX1, fX2);
  };
  char IStation() const { return fIStation; }
  void SetId(int id) { fId = id; }
  int Id() const { return fId; };

  float_v X1Corrected(float_v sinPhi) const;

  float X0() const { return fX0; }
  float X1() const { return fX1; }
  float X2() const { return fX2; }

  float Err2X1() const { return fErr2X1; }
  float ErrX12() const { return fErrX12; }
  float Err2X2() const { return fErr2X2; }

  float R() const { return fR; }
  float DR() const { return fDR; }
  float U() const { return fU; }
  float Err2R() const { return fErr2R; }
  float Err2A() const { return fErr2A; }

  bool IsLeft() const { return fIsLeft; }
  int ISec() const { return fISec; }

  float Angle() const { return fAngle; }

  bool IsUsed() const { return fCAHit->IsUsed(); }
  void SetAsUsed() { fCAHit->SetAsUsed(); }

  // comparison of hits on one station, needed for std::sort, returns true if a must be before b.
  friend bool operator<(const PndCAHit &a, const PndCAHit &b)
  {
    if (a.fIStation >= PndCAParameters::NMVDStations)
      return (a.Angle() < b.Angle()) || ((a.Angle() == b.Angle()) && (a.X1() < b.X1()));
    else
      return a.X2() / abs(a.X0()) < b.X2() / abs(b.X0()); // check why x0 < 0 is possible
  }

  // private:
  char fIStation; // index of the station
  int fId;        // index of hits in an input array

  float fX1, fX2, fX0;             // local coordinates. fX2 is vertical, along radial direction
  float fErr2X1, fErrX12, fErr2X2; // errors squared

  float fR;
  float fErr2R;
  float fErr2A; // error along the tube
  float fU, fDR;
  bool fIsLeft; // left side or right side
  int fISec;

  float fAngle; // direction of hit station. Angle between normal and vertical axis. This angle defines local CS of the hit

  PndCAGBHit *fCAHit;
};

inline float_v PndCAHit::X1Corrected(float_v sinPhi) const
{
  const float_v xCorr = fR - fR * rsqrt(1 - sinPhi * sinPhi);
  //  xCorr /= cos(3.f/180.f*3.141592); // currently neglect stereo angle
  return (fIsLeft) ? fX1 + xCorr : fX1 - xCorr;
}

template <typename T>
class PndCAElementsOnStation;

template <>
class PndCAElementsOnStation<PndCAHit> : public vector<PndCAHit> {
 public:
  char &IStation() { return fISta; }
  const char &IStation() const { return fISta; }

 private:
  char fISta;
};

class PndCAHits { // same as in PndCAStationArray
 public:
  typedef PndCAHit T;

  PndCAElementsOnStation<T> &OnStation(char i)
  {
    assert((unsigned char)i < fElement.size());
    return fElement[i];
  }
  const PndCAElementsOnStation<T> &OnStation(char i) const
  {
    assert((unsigned char)i < fElement.size());
    return fElement[i];
  }
  const PndCAElementsOnStation<T> &OnStationConst(char i) const
  {
    assert((unsigned char)i < fElement.size());
    return fElement[i];
  }
  PndCAElementsOnStation<T> &operator[](char i)
  {
    assert((unsigned char)i < fElement.size());
    return fElement[i];
  }
  const PndCAElementsOnStation<T> &operator[](char i) const
  {
    assert((unsigned char)i < fElement.size());
    return fElement[i];
  }

  PndCAHits() {}
  PndCAHits(int nSta, int nHitsPerStation = 1)
  {
    fElement.resize(nSta);
    for (int i = 0; i < nSta; ++i) {
      fElement[i].IStation() = i;
      fElement[i].reserve(nHitsPerStation);
    }
  }

  T &operator[](PndCATES i) { return fElement[i.s][i.e]; }
  const T &operator[](PndCATES i) const { return fElement[i.s][i.e]; }

  char NStations() const { return fElement.size(); }

  void Add(const T &hit)
  {
    const int iSta = hit.IStation();
    fElement[iSta].push_back(hit);
  }

  void Sort()
  {
    for (unsigned int i = 0; i < fElement.size(); ++i) {
      PndCAElementsOnStation<T> &hits = fElement[i];
      std::sort(hits.begin(), hits.end());
    }
  }

  void Clean()
  { // remove used hits
    for (unsigned int i = 0; i < fElement.size(); ++i) {
      PndCAElementsOnStation<T> &hits = fElement[i];
      PndCAElementsOnStation<T> tmp;
      tmp.IStation() = i;
      // tmp.reserve( hits.size() );
      for (unsigned int iH = 0; iH < hits.size(); ++iH) {
        if (hits[iH].IsUsed())
          continue;
        tmp.push_back(hits[iH]);
      }
      hits.clear();
      hits = tmp;
      tmp.clear();
    }
  }

 protected:
  vector<PndCAElementsOnStation<T>> fElement; // hits on stations
};

#endif