TimeDependentVariables.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 <vector>
#include <string>
#include <analysis/VariableManager/Manager.h>
#include <framework/geometry/B2Vector3.h>
 
namespace Belle2 {
  class Particle;
 
  namespace Variable {
 
 
    double particleTagVx(const Particle* particle);
 
    double particleTagVy(const Particle* particle);
 
    double particleTagVz(const Particle* particle);
 
    double getY4Sx(const Particle* part);
 
    double getY4Sy(const Particle* part);
 
    double getY4Sz(const Particle* part);
 
    double getSigBdecayTime(const Particle* part);
 
    double getTagBdecayTime(const Particle* part);
 
    double getDeltaT3D(const Particle* part);
 
    double particleTruthTagVx(const Particle* particle);
 
    double particleTruthTagVy(const Particle* particle);
 
    double particleTruthTagVz(const Particle* particle);
 
    double particleTagVpVal(const Particle* particle);
 
    double particleTagVNTracks(const Particle* particle);
 
    double particleTagVNTracks(const Particle* particle);
 
    double particleTagVNDF(const Particle* particle);
 
    double particleTagVChi2(const Particle* particle);
 
    double particleTagVChi2IP(const Particle* particle);
 
 
    double particleTagVxErr(const Particle* particle);
 
    double particleTagVyErr(const Particle* particle);
 
    double particleTagVzErr(const Particle* particle);
 
    double particleDeltaT(const Particle* particle);
 
    double particleDeltaTBelle(const Particle* particle);
 
 
    double particleDeltaTErr(const Particle* particle);
 
    double particleDeltaTRes(const Particle* particle);
 
    double particleMCDeltaTau(const Particle* particle);
 
    double particleMCDeltaT(const Particle* particle);
 
    double particleMCDeltaL(const Particle* particle);
 
 
    double particleDeltaZ(const Particle* particle);
 
    double particleDeltaZErr(const Particle* particle);
 
    double particleDeltaB(const Particle* particle);
 
    double particleDeltaBErr(const Particle* particle);
 
    double vertexBoostDirection(const Particle* particle);
 
    double vertexOrthogonalBoostDirection(const Particle* particle);
 
    double vertexTruthBoostDirection(const Particle* particle);
 
    double vertexTruthOrthogonalBoostDirection(const Particle* particle);
 
    double vertexErrBoostDirection(const Particle* particle);
 
    double vertexErrOrthBoostDirection(const Particle* particle);
 
 
 
    double tagVBoostDirection(const Particle* particle);
 
    double tagVOrthogonalBoostDirection(const Particle* particle);
 
    double tagVTruthBoostDirection(const Particle* particle);
 
    double tagVTruthOrthogonalBoostDirection(const Particle* particle);
 
    double tagVErrBoostDirection(const Particle* particle);
 
    double tagVErrOrthogonalBoostDirection(const Particle* particle);
 
    double particleCosThetaBoostDirection(const Particle* part);
 
    double particleInternalTagVMCFlavor(const Particle* particle);
 
    double tagTrackMomentum(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackMomentumX(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackMomentumY(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackMomentumZ(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackD0(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackZ0(const Particle* part, const std::vector<double>& trackIndex);
 
    double particleTagVNFitTracks(const Particle* particle);
 
    double tagTrackRaveWeight(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackDistanceToConstraint(const Particle* part, const std::vector<double>& trackIndex);
 
 
    double tagTrackDistanceToConstraintErr(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackDistanceToConstraintSignificance(const Particle* part, const std::vector<double>& trackIndex);
 
 
    double tagVDistanceToConstraint(const Particle* part);
 
    double tagVDistanceToConstraintErr(const Particle* part);
 
    double tagVDistanceToConstraintSignificance(const Particle* part);
 
 
    double tagTrackDistanceToTagV(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackDistanceToTagVErr(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackDistanceToTagVSignificance(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueDistanceToTagV(const Particle* part, const std::vector<double>& trackIndex);
 
    B2Vector3D tagTrackTrueVecToTagV(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueVecToTagVX(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueVecToTagVY(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueVecToTagVZ(const Particle* part, const std::vector<double>& trackIndex);
 
    B2Vector3D tagTrackTrueMomentum(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueMomentumX(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueMomentumY(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueMomentumZ(const Particle* part, const std::vector<double>& trackIndex);
 
    B2Vector3D tagTrackTrueOrigin(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueOriginX(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueOriginY(const Particle* part, const std::vector<double>& trackIndex);
 
    double tagTrackTrueOriginZ(const Particle* part, const std::vector<double>& trackIndex);
 
    int fitTruthStatus(const Particle* part);
 
    int rollbackStatus(const Particle* part);
 
    //**********************************
    //Meta variables
    //**********************************
 
    typedef double (*TagTrFPtr)(const Particle*, const std::vector<double>&);
 
    Manager::FunctionPtr tagTrackAverage(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackMax(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackMin(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackSum(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackAverageSquares(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackWeightedAverage(const std::vector<std::string>& variable);
 
    Manager::FunctionPtr tagTrackWeightedAverageSquares(const std::vector<std::string>& variable);
 
  }
}