BParticle.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <TObject.h>
#include <TClonesArray.h>
 
enum SIMPLEPID {PHOTON, ELECTRON, PION, MUON, KAON, PROTON, JPSI, D, DSTAR, B, PHI, LAMBDA0, DEUTERON, ALL };
 
class BParticle : public TObject {
 
private:
  float m_px; 
  float m_py; 
  float m_pz; 
  float m_e;  
  float m_charge;  
  SIMPLEPID m_pid;  
  float m_logL_e;  
  float m_logL_mu;  
  float m_logL_pi;  
  float m_logL_k;  
  float m_logL_p;  
  float m_logL_d;  
public:
  BParticle() {};
  BParticle(const BParticle&) = default;
  BParticle& operator+=(const BParticle&);
 
  BParticle(float px, float py, float pz, float energy, float charge, SIMPLEPID pid,
            float logL_e = 0, float logL_mu = 0, float logL_pi = 0, float logL_k = 0, float logL_p = 0, float logL_d = 0);
 
  ~BParticle() {};
 
 
  float px() const { return m_px; };
  float py() const { return m_py; };
  float pz() const { return m_pz; };
  float e() const { return m_e; };
  float GetMomentum() const { return sqrt(m_px * m_px + m_py * m_py + m_pz * m_pz); };
  float GetTransverseMomentum() const { return sqrt(m_px * m_px + m_py * m_py); };
  float charge() const { return m_charge; };
 
  SIMPLEPID pid() const { return m_pid; };
  float logL_e() const { return m_logL_e; };
  float logL_mu() const { return m_logL_mu; };
  float logL_pi() const { return m_logL_pi; };
  float logL_k() const { return m_logL_k; };
  float logL_p() const { return m_logL_p; };
  float logL_d() const { return m_logL_d; };
  float GetLogL(SIMPLEPID pid);
  float GetPID(SIMPLEPID pid);
  float GetBinPID(SIMPLEPID pid1, SIMPLEPID pid2);
 
  float GetMass(SIMPLEPID pid);
  float GetMass();
 
  void SetEnergyFromMass(float mass);
  void SetEnergyFromPid();
  void SetPid(SIMPLEPID pid) { m_pid = pid; };
 
  int InMassRange(float mlower, float mupper) { float m = GetMass(); if (m >= mlower && m <= mupper) return 1; else return 0; };
 
  BParticle& operator=(const BParticle&  p)
  {
    m_px = p.px();
    m_py = p.py();
    m_pz = p.pz();
    m_e  = p.e();
    m_charge  = p.charge();
    m_pid  =  p.pid();
    m_logL_e = p.logL_e();
    m_logL_mu = p.logL_mu();
    m_logL_pi = p.logL_pi();
    m_logL_k = p.logL_k();
    m_logL_p = p.logL_p();
    m_logL_d = p.logL_d();
    return *this;
  };
 
  ClassDef(BParticle, 2)    // Simple particle class
};
 
int SelectParticles(TClonesArray* pin, int charge, SIMPLEPID type, TClonesArray* pout);
 
int CombineParticles(TClonesArray* plist1, TClonesArray* plist2, int same, float masslow, float massup, SIMPLEPID pid,
                     TClonesArray* pout);