PIDVariables.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 <analysis/VariableManager/Manager.h>
 
#include <framework/gearbox/Const.h>
 
#include <vector>
#include <string>
 
namespace Belle2 {
  class Particle;
 
  namespace Variable {
 
 
    Manager::FunctionPtr pidLogLikelihoodValueExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidDeltaLogLikelihoodValueExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidPairProbabilityExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidProbabilityExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidLogarithmicProbabilityExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidMissingProbabilityExpert(const std::vector<std::string>& arguments);
 
    double particleID(const Particle* part);
 
    bool isPIDAvailable(const Particle* part);
 
    Manager::FunctionPtr isPIDAvailableFrom(const std::vector<std::string>& arguments);
 
    double electronID(const Particle* part);
 
    double muonID(const Particle* part);
 
    double pionID(const Particle* part);
 
    double kaonID(const Particle* part);
 
    double protonID(const Particle* part);
 
    double deuteronID(const Particle* part);
 
    double binaryPID(const Particle* part, const std::vector<double>& arguments);
 
    double electronID_noSVD(const Particle* part);
 
    double muonID_noSVD(const Particle* part);
 
    double pionID_noSVD(const Particle* part);
 
    double kaonID_noSVD(const Particle* part);
 
    double protonID_noSVD(const Particle* part);
 
    double deuteronID_noSVD(const Particle* part);
 
    double binaryPID_noSVD(const Particle* part, const std::vector<double>& arguments);
 
    double electronID_noTOP(const Particle* part);
 
    double binaryElectronID_noTOP(const Particle* part, const std::vector<double>& arguments);
 
    double electronID_noSVD_noTOP(const Particle* part);
 
    double binaryElectronID_noSVD_noTOP(const Particle* part, const std::vector<double>& arguments);
 
    double pionID_noARICHwoECL(const Particle* part);
 
    double kaonID_noARICHwoECL(const Particle* part);
 
    double binaryPID_noARICHwoECL(const Particle* part, const std::vector<double>& arguments);
 
    double antineutronID(const Particle* particle);
 
    Manager::FunctionPtr pidChargedBDTScore(const std::vector<std::string>& pdgCodeHyp);
 
    Manager::FunctionPtr pidPairChargedBDTScore(const std::vector<std::string>& arguments);
 
    double mostLikelyPDG(const Particle* part, const std::vector<double>& arguments);
 
    bool isMostLikely(const Particle* part, const std::vector<double>& arguments);
 
    double atcPIDBelle(const Particle*, const std::vector<double>& sigAndBkgHyp);
 
    double muIDBelle(const Particle*);
 
    double muIDBelleQuality(const Particle*);
 
    double eIDBelle(const Particle*);
 
    Manager::FunctionPtr pidWeightedLogLikelihoodValueExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidWeightedPairProbabilityExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidNeuralNetworkValueExpert(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr pidWeightedProbabilityExpert(const std::vector<std::string>& arguments);
 
 
    Manager::FunctionPtr weightedElectronID(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr weightedMuonID(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr weightedPionID(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr weightedKaonID(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr weightedProtonID(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr weightedDeuteronID(const std::vector<std::string>& arguments);
 
    double electronIDNN(const Particle* particle);
 
    double muonIDNN(const Particle* particle);
 
    double pionIDNN(const Particle* particle);
 
    double kaonIDNN(const Particle* particle);
 
    double protonIDNN(const Particle* particle);
 
    double deuteronIDNN(const Particle* particle);
 
    double klmMuonIDDNN(const Particle* part);
 
    Const::PIDDetectorSet parseDetectors(const std::vector<std::string>& arguments);
 
  }
} // Belle2 namespace