PndFTSCAMCPoint.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

//-*- Mode: C++ -*-
// ************************************************************************
// This file is property of and copyright by the ALICE HLT Project        *
// ALICE Experiment at CERN, All rights reserved.                         *
// See cxx source for full Copyright notice                               *
//                                                                        *
//*************************************************************************

#ifndef PNDFTSCAMCPOINT_H
#define PNDFTSCAMCPOINT_H

#include "PndFTSCADef.h"
#include <vector>

#include <iostream>
using std::istream;
using std::ostream;

class PndFtsPoint;

class PndFTSCAMCPoint {
 public:
  PndFTSCAMCPoint();

  float X() const { return fX; }
  float Y() const { return fY; }
  float Z() const { return fZ; }
  float Sx() const { return fSx; }
  float Sy() const { return fSy; }
  float Sz() const { return fSz; }
  float Time() const { return fTime; }
  int ISlice() const { return fISlice; }
  int TrackID() const { return fTrackID; }

  void SetX(float v) { fX = v; }
  void SetY(float v) { fY = v; }
  void SetZ(float v) { fZ = v; }
  void SetSx(float v) { fSx = v; }
  void SetSy(float v) { fSy = v; }
  void SetSz(float v) { fSz = v; }
  void SetTime(float v) { fTime = v; }
  void SetISlice(int v) { fISlice = v; }
  void SetTrackID(int v) { fTrackID = v; }

  static bool Compare(const PndFTSCAMCPoint &p1, const PndFTSCAMCPoint &p2) { return (p1.fTrackID < p2.fTrackID); }

 protected:
  float fX;     //* global X position
  float fY;     //* global Y position
  float fZ;     //* global Z position
  float fSx;    //* slice X position
  float fSy;    //* slice Y position
  float fSz;    //* slice Z position
  float fTime;  //* time
  int fISlice;  //* slice number
  int fTrackID; //* mc track number
};

class PndFTSCALocalMCPoint {
 public:
  PndFTSCALocalMCPoint(){};
  ~PndFTSCALocalMCPoint(){};

  void SetPoint(PndFtsPoint *ppp, Double_t qq);
  PndFTSCALocalMCPoint &operator=(const PndFTSCALocalMCPoint &rhs);

  float X() const { return fX; } // global coordinates
  float Y() const { return fY; }
  float Z() const { return fZ; }
  float Px() const { return fPx; }
  float Py() const { return fPy; }
  float Pz() const { return fPz; }
  float QP() const { return fQP; }
  int ISlice() const { return fISlice; }
  int IRow() const { return fIRow; }
  int TrackI() const { return fTrackI; }
  int TrackID() const { return fTrackID; }

  float Angle() const { return fAngle; }
  float Err2Z() const { return fErr2Z; }
  float Err2Y() const { return fErr2Y; }

  void SetX(float v) { fX = v; }
  void SetY(float v) { fY = v; }
  void SetZ(float v) { fZ = v; }
  void SetPx(float v) { fPx = v; }
  void SetPy(float v) { fPy = v; }
  void SetPz(float v) { fPz = v; }
  void SetQP(float v) { fQP = v; }
  void SetISlice(int v) { fISlice = v; }
  void SetIRow(int v) { fIRow = v; }
  void SetTrackI(int v) { fTrackI = v; }
  void SetTrackID(int v) { fTrackID = v; }

  void SetAngle(float v) { fAngle = v; }
  void SetErr2Z(float v) { fErr2Z = v; }
  void SetErr2Y(float v) { fErr2Y = v; }

  void RotateXY(float alpha);

  static bool Compare(const PndFTSCALocalMCPoint &p1, const PndFTSCALocalMCPoint &p2) { return (p1.fTrackID < p2.fTrackID); }

  friend ostream &operator<<(ostream &out, const PndFTSCALocalMCPoint &a);
  friend istream &operator>>(istream &in, PndFTSCALocalMCPoint &a);

 protected:
  float fX;  //* local X position
  float fY;  //* local Y position
  float fZ;  //* local Z position
  float fPx; //* local momentum projection - Px
  float fPy;
  float fPz;
  float fQP; //* Q/P

  float fAngle;         // angle of the module
  float fErr2Z, fErr2Y; // errors for correspondent measurement
  int fISlice;          //* slice number
  int fIRow;
  int fTrackI;  //* mc track index
  int fTrackID; //* mc track simulation ID
 public:
  std::vector<int> fHits;
};

#endif