Particle.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012-2019 - Belle II Collaboration                        *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Anze Zupanc, Marko Staric, Christian Pulvermacher,       *
 *               Sam Cunliffe, Torben Ferber                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/RelationsObject.h>
#include <framework/gearbox/Const.h>
#include <mdst/dataobjects/ECLCluster.h>
 
#include <TVector3.h>
#include <TLorentzVector.h>
#include <TMatrixFSymfwd.h>
 
#include <vector>
 
class TClonesArray;
 
namespace Belle2 {
  // forward declarations
  class KLMCluster;
  class Track;
  class TrackFitResult;
  class MCParticle;
  class PIDLikelihood;
  class V0;
 
  class Particle : public RelationsObject {
 
  public:
 
    enum EParticleSourceObject {
      c_Undefined  = 0,
      c_Track      = 1,
      c_ECLCluster = 2,
      c_KLMCluster = 3,
      c_V0         = 4,
      c_MCParticle = 5,
      c_Composite  = 6
    };
 
    enum EFlavorType {
      c_Unflavored = 0, 
      c_Flavored = 1, 
    };
 
    enum {c_DimPosition = 3, c_DimMomentum = 4, c_DimMatrix = 7,
          c_SizeMatrix = c_DimMatrix * (c_DimMatrix + 1) / 2
         };
 
    enum {c_Px, c_Py, c_Pz, c_E, c_X, c_Y, c_Z};
 
    enum PropertyFlags {
      c_Ordinary = 0, 
      c_IsUnspecified = 1, 
      c_IsIgnoreRadiatedPhotons = 2, 
      c_IsIgnoreIntermediate = 4, 
      c_IsIgnoreMassive = 8, 
      c_IsIgnoreNeutrino = 16, 
      c_IsIgnoreGamma = 32, 
      c_IsIgnoreBrems = 64, 
      c_IsIgnoreMisID = 128, 
      c_IsIgnoreDecayInFlight = 256, 
    };
 
    Particle();
 
    Particle(const TLorentzVector& momentum, const int pdgCode);
 
    Particle(const TLorentzVector& momentum,
             const int pdgCode,
             EFlavorType flavorType,
             const EParticleSourceObject particleType,
             const unsigned mdstIndex);
 
    Particle(const TLorentzVector& momentum,
             const int pdgCode,
             EFlavorType flavorType,
             const std::vector<int>& daughterIndices,
             TClonesArray* arrayPointer = nullptr);
 
    Particle(const TLorentzVector& momentum,
             const int pdgCode,
             EFlavorType flavorType,
             const std::vector<int>& daughterIndices,
             int properties,
             TClonesArray* arrayPointer = nullptr);
 
    Particle(const TLorentzVector& momentum,
             const int pdgCode,
             EFlavorType flavorType,
             const std::vector<int>& daughterIndices,
             int properties,
             const std::vector<int>& daughterProperties,
             TClonesArray* arrayPointer = nullptr);
 
    Particle(const Track* track,
             const Const::ChargedStable& chargedStable);
 
    [[deprecated("Please use the constructor without the chargedStableUsedForFit")]]
    Particle(const int trackArrayIndex,
             const TrackFitResult* trackFit,
             const Const::ChargedStable& chargedStable,
             const Const::ChargedStable& chargedStableUsedForFit);
 
    Particle(int trackArrayIndex, const TrackFitResult* trackFit,
             const Const::ChargedStable& chargedStable);
 
    explicit Particle(const ECLCluster* eclCluster,
                      const Const::ParticleType& type = Const::photon);
 
    explicit Particle(const KLMCluster* klmCluster, const int pdgCode = Const::Klong.getPDGCode());
 
    explicit Particle(const MCParticle* MCparticle);
 
    ~Particle();
 
  public:
 
    // setters
 
    void set4Vector(const TLorentzVector& p4)
    {
      m_px = p4.Px();
      m_py = p4.Py();
      m_pz = p4.Pz();
      m_mass = p4.M();
    }
 
    void setVertex(const TVector3& vertex)
    {
      m_x = vertex.X();
      m_y = vertex.Y();
      m_z = vertex.Z();
    };
 
    void setMomentumVertexErrorMatrix(const TMatrixFSym& errMatrix);
 
    void setPValue(float pValue)
    {
      m_pValue = pValue;
    }
 
    void setProperty(const int properties)
    {
      m_properties = properties;
    }
 
    void updateMomentum(const TLorentzVector& p4,
                        const TVector3& vertex,
                        const TMatrixFSym& errMatrix,
                        float pValue)
    {
      set4Vector(p4);
      setVertex(vertex);
      setMomentumVertexErrorMatrix(errMatrix);
      m_pValue = pValue;
    }
 
    void updateMass(const int pdgCode);
 
    void appendDaughter(const Particle* daughter, const bool updateType = true);
 
    void appendDaughter(int particleIndex, const bool updateType = true)
    {
      if (updateType) {
        // is it a composite particle or fsr corrected?
        m_particleSource = c_Composite;
      }
      m_daughterIndices.push_back(particleIndex);
      m_daughterProperties.push_back(Particle::PropertyFlags::c_Ordinary);
    }
 
    void removeDaughter(const Particle* daughter, const bool updateType = true);
 
    // getters
 
    int getPDGCode(void) const
    {
      return m_pdgCode;
    }
 
    float getCharge(void) const;
 
    EFlavorType getFlavorType() const
    {
      return m_flavorType;
    }
 
    EParticleSourceObject getParticleSource() const
    {
      return m_particleSource;
    }
 
    unsigned getMdstArrayIndex(void) const
    {
      return m_mdstIndex;
    }
 
    int getProperty() const
    {
      return m_properties;
    }
 
    float getMass() const
    {
      return m_mass;
    }
 
    //float getMassError() const;
 
    float getPDGMass(void) const;
 
    float getEnergy() const
    {
      return sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz + m_mass * m_mass);
    }
 
    TLorentzVector get4Vector() const
    {
      TLorentzVector vec;
      vec.SetXYZM(m_px, m_py, m_pz, m_mass);
      return vec;
    }
 
    TVector3 getMomentum() const
    {
      return TVector3(m_px, m_py, m_pz);
    };
 
    float getMomentumMagnitude() const
    {
      return sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
    };
 
    float getP() const
    {
      return sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz);
    };
 
    float getPx() const
    {
      return m_px;
    }
 
    float getPy() const
    {
      return m_py;
    }
 
    float getPz() const
    {
      return m_pz;
    }
 
    TVector3 getVertex() const
    {
      return TVector3(m_x, m_y, m_z);
    };
 
    float getX() const
    {
      return m_x;
    }
 
    float getY() const
    {
      return m_y;
    }
 
    float getZ() const
    {
      return m_z;
    }
 
    float getPValue() const
    {
      return m_pValue;
    }
 
    TMatrixFSym getMomentumVertexErrorMatrix() const;
 
    TMatrixFSym getMomentumErrorMatrix() const;
 
    TMatrixFSym getVertexErrorMatrix() const;
 
    float getCosHelicity(const Particle* mother = nullptr) const;
 
    float getCosHelicityDaughter(unsigned iDaughter, unsigned iGrandDaughter = 0) const;
 
    float getAcoplanarity() const;
 
 
    int getMdstSource() const;
 
    unsigned getNDaughters(void) const
    {
      return m_daughterIndices.size();
    }
 
    const std::vector<int>& getDaughterIndices() const
    {
      return m_daughterIndices;
    }
 
    const std::vector<int>& getDaughterProperties() const
    {
      return m_daughterProperties;
    }
 
    const Particle* getDaughter(unsigned i) const;
 
    bool forEachDaughter(const std::function<bool(const Particle*)>& function,
                         bool recursive = true, bool includeSelf = true) const;
 
    std::vector<Belle2::Particle*> getDaughters() const;
    //Need namespace qualifier because ROOT CINT has troubles otherwise
 
    std::vector<const Belle2::Particle*> getFinalStateDaughters() const;
    //Need namespace qualifier because ROOT CINT has troubles otherwise
 
    std::vector<int> getMdstArrayIndices(EParticleSourceObject type) const;
 
    bool overlapsWith(const Particle* oParticle) const;
 
    bool isCopyOf(const Particle* oParticle, bool doDetailedComparison = false) const;
 
    const Track* getTrack() const;
 
    const TrackFitResult* getTrackFitResult() const;
 
    const V0* getV0() const;
 
    const PIDLikelihood* getPIDLikelihood() const;
 
    const ECLCluster* getECLCluster() const;
 
    double getECLClusterEnergy() const;
 
    const KLMCluster* getKLMCluster() const;
 
    const MCParticle* getMCParticle() const;
 
    virtual std::string getName() const;
 
    virtual std::string getInfoHTML() const;
 
    void print() const;
 
    std::vector<std::string> getExtraInfoNames() const;
 
    void removeExtraInfo();
 
    float getExtraInfo(const std::string& name) const;
 
    bool hasExtraInfo(const std::string& name) const;
 
    int getExtraInfoMap() const
    {
      return !m_extraInfo.empty() ? m_extraInfo[0] : -1;
    }
 
    unsigned int getExtraInfoSize() const
    {
      return m_extraInfo.size();
    }
 
    void writeExtraInfo(const std::string& name, const float value);
 
    void setExtraInfo(const std::string& name, float value);
 
    void addExtraInfo(const std::string& name, float value);
 
    TClonesArray* getArrayPointer() const
    {
      if (!m_arrayPointer)
        m_arrayPointer = RelationsObject::getArrayPointer();
      return m_arrayPointer;
    }
 
    int getPDGCodeUsedForFit()
    {
      return std::abs(m_pdgCodeUsedForFit);
    }
 
    bool wasExactFitHypothesisUsed() const
    {
      return std::abs(m_pdgCodeUsedForFit) == std::abs(m_pdgCode);
    }
 
    ECLCluster::EHypothesisBit getECLClusterEHypothesisBit() const
    {
      const int pdg = abs(getPDGCode());
      if ((pdg == Const::photon.getPDGCode())
          or (pdg == Const::electron.getPDGCode())
          or (pdg == Const::muon.getPDGCode())
          or (pdg == Const::pion.getPDGCode())
          or (pdg == Const::kaon.getPDGCode())
          or (pdg == Const::proton.getPDGCode())
          or (pdg == Const::deuteron.getPDGCode())) {
        return ECLCluster::EHypothesisBit::c_nPhotons;
      } else if ((pdg == Const::Klong.getPDGCode())
                 or (pdg == Const::neutron.getPDGCode())) {
        return ECLCluster::EHypothesisBit::c_neutralHadron;
      } else {
        return ECLCluster::EHypothesisBit::c_none;
      }
    }
 
    const Particle* getParticleFromGeneralizedIndexString(const std::string& generalizedIndex) const;
 
 
  private:
 
    // persistent data members
    int m_pdgCode;  
    int m_pdgCodeUsedForFit = 0; 
    float m_mass;   
    float m_px;     
    float m_py;     
    float m_pz;     
    float m_x;      
    float m_y;      
    float m_z;      
    float m_errMatrix[c_SizeMatrix] = {}; 
    float m_pValue;   
    std::vector<int> m_daughterIndices;  
    EFlavorType m_flavorType;  
    EParticleSourceObject m_particleSource;  
    unsigned m_mdstIndex;  
    int m_properties; 
    std::vector<int> m_daughterProperties; 
    int m_identifier = -1;
 
    std::vector<float> m_extraInfo;
 
    // transient data members
    mutable TClonesArray* m_arrayPointer; 
 
    // private methods
    void setMomentumPositionErrorMatrix(const TrackFitResult* trackFit);
 
    void resetErrorMatrix();
 
    void storeErrorMatrix(const TMatrixFSym& errMatrix);
 
    void fillFSPDaughters(std::vector<const Belle2::Particle*>& fspDaughters) const;
 
    // TODO: this can be optimized for speed
    void fillDecayChain(std::vector<int>& decayChain) const;
 
    void setFlavorType();
 
    void setMdstArrayIndex(const int arrayIndex);
 
    int generatePDGCodeFromCharge(const int chargedSign, const Const::ChargedStable& chargedStable);
 
    ClassDef(Particle, 12); 
    // v8: added identifier, changed getMdstSource
    // v9: added m_pdgCodeUsedForFit
    // v10: added m_properties
    // v11: added m_daughterProperties
    // v12: renamed EParticleType m_particleType to EParticleSourceObject m_particleSource
 
    friend class ParticleSubset;
  };
 
} // end namespace Belle2