PndPidCandidate.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".              *
//****************************************************************************

#ifndef PNDPIDCANDIDATE_H
#define PNDPIDCANDIDATE_H
//                                                                      //
// PndPidCandidate                                                      //
//                                                                      //
// Definition of the Panda pid candidate.                                //
//                                                                      //
// Author: Klaus Goetzen, GSI, 12.06.08                                  //
// Copyright (C) 2008, GSI Darmstadt.                                    //
//                                                                      //

#include <iostream>

#include <assert.h>

#include "FairTimeStamp.h"
#include "TArrayI.h"
#include "TMatrixD.h"
#include "TVector3.h"
#include "TLorentzVector.h"
#include "PndTrack.h"

// class VAbsPidInfo;

//  ========================================================================
//  ===== PndPidCandidate - Class definig the AOD interface           ====
//  ========================================================================

class PndPidCandidate : public FairTimeStamp {

 public:
  PndPidCandidate();
  PndPidCandidate(Int_t charge, TVector3 &pos, TLorentzVector &p4, TMatrixD &cov7);
  PndPidCandidate(Int_t charge, TVector3 &pos, TLorentzVector &p4);

  ~PndPidCandidate();

  // ************************
  // ACCESSOR METHODS
  // ************************

  // ************************
  // basic properties:
  // ************************

  Int_t GetCharge() const { return fCharge; }
  TVector3 GetPosition() const { return TVector3(fXposition, fYposition, fZposition); }
  TVector3 GetMomentum() const { return TVector3(fXmomentum, fYmomentum, fZmomentum); }
  Double_t GetEnergy() const { return fEnergy; }
  TLorentzVector GetLorentzVector() const { return TLorentzVector(fXmomentum, fYmomentum, fZmomentum, fEnergy); }

  TVector3 GetFirstHit() const { return TVector3(fFirstHitX, fFirstHitX, fFirstHitX); }
  TVector3 GetLastHit() const { return TVector3(fLastHitX, fLastHitY, fLastHitZ); }

  const Float_t *GetErrorP7() const { return fErrP7; }
  const Float_t *GetParams() const { return fParams; }
  const Float_t *GetCov() const { return fCov; }
  TMatrixD &Cov7() const;
  TMatrixD &P4Cov() const;
  Int_t GetMcIndex() const { return fMcIndex; }
  Int_t GetTrackIndex() const { return fTrackIndex; }
  Int_t GetTrackBranch() const { return fTrackBranch; }
  PndTrack::TrackType GetTrackType() const { return fTrackType; }

  // ************************
  // detector specific stuff
  // ************************

  // MVD
  Float_t GetMvdDEDX() const { return fMvdDEDX; }
  Int_t GetMvdHits() const { return fMvdHits; }
  // const Int_t* GetMvdHitIndexArray()  {return fMvdHitIndexArray.GetArray();}

  // STT
  Float_t GetSttMeanDEDX() const { return fSttMeanDEDX; }
  Int_t GetSttHits() const { return fSttHits; }
  // const Int_t* GetSttHitIndexArray()  {return fSttHitIndexArray.GetArray();}

  // GEM
  Int_t GetGemHits() const { return fGemHits; }

  // TOF
  Float_t GetTofStopTime() const { return fTofStopTime; }
  Float_t GetTofM2() const { return fTofM2; }
  Float_t GetTofTrackLength() const { return fTofTrackLength; }
  Float_t GetTofQuality() const { return fTofQuality; }
  Int_t GetTofIndex() const { return fTofIndex; }
  Float_t GetTofBeta() const { return (fTofStopTime > 0. && fTofTrackLength > 0.) ? fTofTrackLength / (30. * fTofStopTime) : -1.; }

  // Barrel DIRC
  Float_t GetDrcThetaC() const { return fDrcThetaC; }
  Float_t GetDrcThetaCErr() const { return fDrcThetaCErr; }
  Float_t GetDrcQuality() const { return fDrcQuality; }
  Int_t GetDrcNumberOfPhotons() const { return fDrcNumberOfPhotons; }
  Int_t GetDrcIndex() const { return fDrcIndex; }

  // Disc DIRC
  Float_t GetDiscThetaC() const { return fDiscThetaC; }
  Float_t GetDiscThetaCErr() const { return fDiscThetaCErr; }
  Float_t GetDiscQuality() const { return fDiscQuality; }
  Int_t GetDiscNumberOfPhotons() const { return fDiscNumberOfPhotons; }
  Int_t GetDiscIndex() const { return fDiscIndex; }

  // RICH
  Float_t GetRichThetaC() const { return fRichThetaC; }
  Float_t GetRichThetaCErr() const { return fRichThetaCErr; }
  Float_t GetRichQuality() const { return fRichQuality; }
  Int_t GetRichNumberOfPhotons() const { return fRichNumberOfPhotons; }
  Int_t GetRichIndex() const { return fRichIndex; }

  // EMC
  Float_t GetEmcRawEnergy() const { return fEmcRawEnergy; }
  Float_t GetEmcCalEnergy() const { return fEmcCalEnergy; }
  Float_t GetEmcQuality() const { return fEmcQuality; }
  Int_t GetEmcNumberOfCrystals() const { return fEmcNumberOfCrystals; }
  Int_t GetEmcNumberOfBumps() const { return fEmcNumberOfBumps; }
  Int_t GetEmcModule() const { return fEmcModule; }
  Int_t GetEmcIndex() const { return fEmcIndex; }
  Float_t GetEmcTimeStamp() const { return fEmcTimeStamp; }

  // EMC Cluster properties.
  Double_t GetEmcClusterZ20() const { return fEmcZ20; }
  Double_t GetEmcClusterZ53() const { return fEmcZ53; }
  Double_t GetEmcClusterLat() const { return fEmcLat; }
  Double_t GetEmcClusterE1() const { return fEmcE1; }
  Double_t GetEmcClusterE9() const { return fEmcE9; }
  Double_t GetEmcClusterE25() const { return fEmcE25; }

  // MUO
  Int_t GetMuoNumberOfLayers() const { return fMuoNumberOfLayers; }
  Float_t GetMuoProbability() const { return fMuoProbability; }
  Float_t GetMuoQuality() const { return fMuoQuality; }
  Float_t GetMuoIron() const { return fMuoIron; }
  Float_t GetMuoMomentumIn() const { return fMuoMomentumIn; }
  Int_t GetMuoModule() const { return fMuoModule; }
  Int_t GetMuoHits() const { return fMuoHits; }
  Int_t GetMuoIndex() const { return fMuoIndex; }

  // Tracking

  Int_t GetDegreesOfFreedom() const { return fDegreesOfFreedom; }
  Int_t GetFitStatus() const { return fFitStatus; }
  Float_t GetChiSquared() const { return fChiSquared; }
  Int_t GetPidHypo() const { return fPidHyp; }

  // ************************
  // MODIFIER METHODS
  // ************************

  void Lock() { fLocked = true; }
  void Unlock() { fLocked = false; }
  bool IsLocked() { return fLocked; }

  // ************************
  // basic properties:
  // ************************

  void SetCharge(Int_t charge) { fCharge = charge; }
  void SetPosition(TVector3 &pos)
  {
    fXposition = pos.X();
    fYposition = pos.Y();
    fZposition = pos.Z();
  }
  void SetMomentum(TVector3 &mom)
  {
    fXmomentum = mom.X();
    fYmomentum = mom.Y();
    fZmomentum = mom.Z();
  }
  void SetEnergy(Double_t en) { fEnergy = (Float_t)en; }
  void SetLorentzVector(TLorentzVector &p4);

  void SetFirstHit(TVector3 &pos)
  {
    fFirstHitX = pos.X();
    fFirstHitY = pos.Y();
    fFirstHitZ = pos.Z();
  }
  void SetLastHit(TVector3 &pos)
  {
    fLastHitX = pos.X();
    fLastHitY = pos.Y();
    fLastHitZ = pos.Z();
  }

  void SetCov7(const TMatrixD &cov7);
  void SetP4Cov(const TMatrixD &covP4);
  void SetMcIndex(int idx) { fMcIndex = idx; }
  void SetTrackIndex(int idx) { fTrackIndex = idx; }
  void SetTrackBranch(int idx) { fTrackBranch = idx; }
  void SetTrackType(PndTrack::TrackType type) { fTrackType = type; }

  void SetHelixParams(Double_t *par)
  {
    if (par != 0)
      for (int i = 0; i < 5; i++)
        fParams[i] = (Float_t)par[i];
  }
  void SetHelixCov(Double_t *cov)
  {
    if (cov != 0)
      for (int i = 0; i < 15; i++)
        fCov[i] = (Float_t)cov[i];
  }

  // ************************
  // detector specific stuff
  // ************************

  // MVD
  void SetMvdDEDX(Double_t val) { fMvdDEDX = (Float_t)val; }
  void SetMvdHits(Int_t val) { fMvdHits = val; }
  // void  SetMvdHitIndexArray(Int_t n, Int_t* arr)  { fMvdHits=n; fMvdHitIndexArray.Set(n,arr);}

  // STT
  void SetSttMeanDEDX(Double_t val) { fSttMeanDEDX = (Float_t)val; }
  void SetSttHits(Int_t val) { fSttHits = val; }
  // void  SetSttHitIndexArray(Int_t n, Int_t* arr)  { fSttHits=n; fSttHitIndexArray.Set(n,arr);}

  void SetGemHits(Int_t val) { fGemHits = val; }
  // TOF
  void SetTofStopTime(Double_t val) { fTofStopTime = (Float_t)val; }
  void SetTofM2(Double_t val) { fTofM2 = (Float_t)val; }
  void SetTofTrackLength(Double_t val) { fTofTrackLength = val; }
  void SetTofQuality(Double_t val) { fTofQuality = val; }
  void SetTofIndex(Int_t val) { fTofIndex = val; }

  // Barrel DIRC
  void SetDrcThetaC(Double_t val) { fDrcThetaC = (Float_t)val; }
  void SetDrcThetaCErr(Double_t val) { fDrcThetaCErr = (Float_t)val; }
  void SetDrcQuality(Double_t val) { fDrcQuality = (Float_t)val; }
  void SetDrcNumberOfPhotons(Int_t val) { fDrcNumberOfPhotons = val; }
  void SetDrcIndex(Int_t val) { fDrcIndex = val; }

  // Disc DIRC
  void SetDiscThetaC(Double_t val) { fDiscThetaC = (Float_t)val; }
  void SetDiscThetaCErr(Double_t val) { fDiscThetaCErr = (Float_t)val; }
  void SetDiscQuality(Double_t val) { fDiscQuality = (Float_t)val; }
  void SetDiscNumberOfPhotons(Int_t val) { fDiscNumberOfPhotons = val; }
  void SetDiscIndex(Int_t val) { fDiscIndex = val; }

  // RICH
  void SetRichThetaC(Double_t val) { fRichThetaC = (Float_t)val; }
  void SetRichThetaCErr(Double_t val) { fRichThetaCErr = (Float_t)val; }
  void SetRichQuality(Double_t val) { fRichQuality = (Float_t)val; }
  void SetRichNumberOfPhotons(Int_t val) { fRichNumberOfPhotons = val; }
  void SetRichIndex(Int_t val) { fRichIndex = val; }

  // EMC
  void SetEmcRawEnergy(Double_t val) { fEmcRawEnergy = (Float_t)val; }
  void SetEmcCalEnergy(Double_t val) { fEmcCalEnergy = (Float_t)val; }
  void SetEmcQuality(Double_t val) { fEmcQuality = (Float_t)val; }
  void SetEmcNumberOfCrystals(Int_t val) { fEmcNumberOfCrystals = val; }
  void SetEmcNumberOfBumps(Int_t val) { fEmcNumberOfBumps = val; }
  void SetEmcModule(Int_t val) { fEmcModule = val; }
  void SetEmcIndex(Int_t val) { fEmcIndex = val; }

  void SetEmcClusterZ20(Double_t val) { fEmcZ20 = val; }
  void SetEmcClusterZ53(Double_t val) { fEmcZ53 = val; }
  void SetEmcClusterLat(Double_t val) { fEmcLat = val; }
  void SetEmcClusterE1(Double_t val) { fEmcE1 = val; }
  void SetEmcClusterE9(Double_t val) { fEmcE9 = val; }
  void SetEmcClusterE25(Double_t val) { fEmcE25 = val; }

  void SetEmcTimeStamp(Double_t val) { fEmcTimeStamp = val; }

  // MUO
  void SetMuoNumberOfLayers(Int_t val) { fMuoNumberOfLayers = val; }
  void SetMuoProbability(Double_t val) { fMuoProbability = (Float_t)val; }
  void SetMuoQuality(Double_t val) { fMuoQuality = (Float_t)val; }
  void SetMuoIron(Double_t val) { fMuoIron = (Float_t)val; }
  void SetMuoMomentumIn(Double_t val) { fMuoMomentumIn = (Float_t)val; }
  void SetMuoModule(Int_t val) { fMuoModule = val; }
  void SetMuoHits(Int_t val) { fMuoHits = val; }
  void SetMuoIndex(Int_t val) { fMuoIndex = val; }

  // Tracking
  void SetDegreesOfFreedom(Int_t val) { fDegreesOfFreedom = val; }
  void SetFitStatus(Int_t val) { fFitStatus = val; }
  void SetChiSquared(Double_t val) { fChiSquared = (Float_t)val; }
  void SetPidHypo(int hyp) { fPidHyp = hyp; }
  void SetDefault();
  void PrintOn(std::ostream &o) const;

 protected:
  // Candidate lock
  Bool_t fLocked;

  // the basic params
  Char_t fCharge;      // The electrical charge
  Float_t fXposition,  // The origin in x
    fYposition,        // The origin in y
    fZposition;        // The origin in z
  Double_t fXmomentum, // The momentum in x
    fYmomentum,        // The momentum in y
    fZmomentum,        // The momentum in z
    fEnergy;           // The total energy

  Float_t fFirstHitX, fFirstHitY, fFirstHitZ;

  Float_t fLastHitX, fLastHitY, fLastHitZ;

  Int_t fMcIndex;     // MC truth index
  Int_t fTrackIndex;  // PndTrack index
  Int_t fTrackBranch; // index of PndTrack TClonesArray
  PndTrack::TrackType fTrackType = PndTrack::TrackType::kUndefined; // type of PndTrack (forward, barrel, combined)
  Float_t fErrP7[28]; // The symmetric 7*7 error matrix
  Float_t fParams[5]; // The helix fit parameters
  Float_t fCov[15];   // The helix error matrix

  // detector quantities
  // MVD
  Float_t fMvdDEDX;
  Int_t fMvdHits;
  // TArrayI    fMvdHitIndexArray;

  // STT
  Float_t fSttMeanDEDX;
  Int_t fSttHits;
  // TArrayI    fSttHitIndexArray;

  // GEM
  Int_t fGemHits;

  // TOF
  Float_t fTofStopTime;
  Float_t fTofM2;
  Float_t fTofTrackLength;
  Float_t fTofQuality;
  Int_t fTofIndex;

  // Barrel DIRC
  Float_t fDrcThetaC;
  Float_t fDrcThetaCErr;
  Float_t fDrcQuality;
  Int_t fDrcNumberOfPhotons;
  Int_t fDrcIndex;

  // Disc DIRC
  Float_t fDiscThetaC;
  Float_t fDiscThetaCErr;
  Float_t fDiscQuality;
  Int_t fDiscNumberOfPhotons;
  Int_t fDiscIndex;

  // RICH
  Float_t fRichThetaC;
  Float_t fRichThetaCErr;
  Float_t fRichQuality;
  Int_t fRichNumberOfPhotons;
  Int_t fRichIndex;

  // EMC
  Float_t fEmcRawEnergy;
  Float_t fEmcCalEnergy;
  Float_t fEmcQuality;
  Float_t fEmcTimeStamp; 
  Int_t fEmcNumberOfCrystals;
  Int_t fEmcNumberOfBumps;
  Int_t fEmcModule;
  Int_t fEmcIndex;
  Double_t fEmcZ20;
  Double_t fEmcZ53;
  Double_t fEmcLat;
  Double_t fEmcE1;
  Double_t fEmcE9;
  Double_t fEmcE25;

  // MUO
  Int_t fMuoNumberOfLayers;
  Float_t fMuoProbability;
  Float_t fMuoQuality;
  Float_t fMuoIron;
  Float_t fMuoMomentumIn;
  Int_t fMuoModule;
  Int_t fMuoHits;
  Int_t fMuoIndex;

  // Tracking
  Int_t fDegreesOfFreedom;
  Int_t fFitStatus;
  Float_t fChiSquared;
  Int_t fPidHyp;

  ClassDef(PndPidCandidate, 6) // Abstract base class for MicroDST candidates
};

std::ostream &operator<<(std::ostream &o, const PndPidCandidate &);

#endif