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 <Math/Vector3D.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);

    ROOT::Math::XYZVector 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);

    ROOT::Math::XYZVector 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);

    ROOT::Math::XYZVector 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);
 
  }
}