KinkVariables.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 <Math/Vector3D.h>
#include <Math/Vector4D.h>
 
namespace Belle2 {
  class Particle;
  class Kink;
  class MCParticle;
  class Helix;
 
  namespace Variable {
 
    //-----------------------------------------------
    // Helper Functions
 
    Helix kinkDaughterHelixAtKinkVertex(const Kink* kink);
 
    ROOT::Math::XYZVector kinkDaughterMomentumAtKinkVertex(const Kink* kink);
 
    Helix kinkMotherHelixAtKinkVertex(const Kink* kink);
 
    ROOT::Math::XYZVector kinkMotherMomentumAtKinkVertex(const Kink* kink);
 
    double kinkDaughterMomentumAndCosThetaInMotherRF(const Particle* part, Const::ChargedStable motherType,
                                                     Const::ChargedStable daughterType, bool returnCosTheta);
 
    ROOT::Math::PxPyPzEVector kinkMotherMCP4AtDecayVertex(const MCParticle* p);
 
    double kinkDaughterMCMomentumAndCosThetaInMotherRF(const Particle* part, bool returnCosTheta);
 
    //-----------------------------------------------
    // MEASURED VARIABLES
    // Kink General Variables
 
    double kinkVertexX(const Particle* part);
 
    double kinkVertexY(const Particle* part);
 
    double kinkVertexZ(const Particle* part);
 
    double kinkFilterID(const Particle* part);
 
    double kinkCombinedFitResultFlag(const Particle* part);
 
    double kinkCombinedFitResultFlagBit1(const Particle* part);
 
    double kinkCombinedFitResultFlagBit2(const Particle* part);
 
    double kinkCombinedFitResultFlagBit3(const Particle* part);
 
    double kinkCombinedFitResultFlagBit4(const Particle* part);
 
    double kinkSplitTrackDistanceAtVertexFlag(const Particle* part);
 
    double kinkNumberOfReassignedHits(const Particle* part);
 
    double kinkIsSameCharge(const Particle* part);
 
    // Kink Decay Kinematics
 
    double kinkDaughterMomentumInMotherRF(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRF(const Particle* part);
 
    double kinkDaughterMomentumInMotherRFKPi(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRFKPi(const Particle* part);
 
    double kinkDaughterMomentumInMotherRFKMu(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRFKMu(const Particle* part);
 
    double kinkDaughterMomentumInMotherRFPiMu(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRFPiMu(const Particle* part);
 
    double kinkDaughterMomentumInMotherRFMuE(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRFMuE(const Particle* part);
 
    // Kink Daughter Measured Track Parameters
 
    Manager::FunctionPtr kinkDaughterTrack(const std::vector<std::string>& arguments);
 
    Manager::FunctionPtr kinkDaughterInitTrack(const std::vector<std::string>& arguments);
 
    double kinkDaughterTrackD0AtKinkVertex(const Particle* part);
 
    double kinkDaughterTrackZ0AtKinkVertex(const Particle* part);
 
    double kinkDaughterPtAtKinkVertex(const Particle* part);
 
    double kinkDaughterPzAtKinkVertex(const Particle* part);
 
    double kinkDaughterPAtKinkVertex(const Particle* part);
 
    // Kink Mother Measured Track Parameters
 
    Manager::FunctionPtr kinkMotherInitTrack(const std::vector<std::string>& arguments);
 
    double kinkMotherTrackD0AtKinkVertex(const Particle* part);
 
    double kinkMotherTrackZ0AtKinkVertex(const Particle* part);
 
    double kinkMotherPtAtKinkVertex(const Particle* part);
 
    double kinkMotherPzAtKinkVertex(const Particle* part);
 
    double kinkMotherPAtKinkVertex(const Particle* part);
 
    //-----------------------------------------------
    // Check if the particle is a part of any Kink
 
    double particleIsInKink(const Particle* part);
 
    double particleIsMotherInKink(const Particle* part);
 
    double particleIsDaughterInKink(const Particle* part);
 
    double particleIsSplitKink(const Particle* part);
 
    //-----------------------------------------------
    // MC VARIABLES
 
    // Kink from track pair MC variables
 
    double kinkPairIsMCRelated(const Particle* part);
 
    double kinkPairIsClone(const Particle* part);
 
    double kinkPairIsReal(const Particle* part);
 
    double kinkPairIsDecayInFlight(const Particle* part);
 
    double kinkPairIsHadronScattering(const Particle* part);
 
    // Kink from track pair MC kinematics
 
    double kinkDaughterMomentumInMotherRFMC(const Particle* part);
 
    double kinkDaughterCosThetaInMotherRFMC(const Particle* part);
 
    // Kink from track pair daughter MC variables
 
    Manager::FunctionPtr kinkPairDaughterMC(const std::vector<std::string>& arguments);
 
    // Kink from track pair mother MC variables
 
    const MCParticle* kinkPairMotherMCParticle(const Particle* part);
 
    Manager::FunctionPtr kinkPairMotherMC(const std::vector<std::string>& arguments);
 
    double kinkPairMotherMCPXAtDecayVertex(const Particle* part);
 
    double kinkPairMotherMCPYAtDecayVertex(const Particle* part);
 
    double kinkPairMotherMCPZAtDecayVertex(const Particle* part);
 
    double kinkPairMotherMCPTAtDecayVertex(const Particle* part);
 
    double kinkPairMotherMCPAtDecayVertex(const Particle* part);
 
    double kinkPairMotherMCEAtDecayVertex(const Particle* part);
 
  }
} // Belle2 namespace