Algorithms.h

Go to the documentation of this file.

#ifndef  ALGORITHM_ANALYZERS_H
#define  ALGORITHM_ANALYZERS_H
 
#include <cmath>
#include <vector>
 
#include "edm4hep/ReconstructedParticleData.h"
 
#include "FastJet/JetClustering.h"
 
//#include "TFitter.h"
#include "Math/Minimizer.h"
#include "ROOT/RVec.hxx"
 
namespace FCCAnalyses{
 
namespace Algorithms{
 
  struct sphericityFit {
  public:
    sphericityFit(const ROOT::VecOps::RVec<float> & arg_px,
                  const ROOT::VecOps::RVec<float> & arg_py,
                  const ROOT::VecOps::RVec<float> & arg_pz);
    float operator()(const double *par);
 
  private:
    ROOT::VecOps::RVec<float> _px; 
    ROOT::VecOps::RVec<float> _py; 
    ROOT::VecOps::RVec<float> _pz; 
  };
 
 
  struct minimize_sphericity {
  public:
    minimize_sphericity(std::string arg_minname="Minuit2",
                        std::string arg_algoname="Migrad",
                        int arg_maxcalls=100000,
                        float arg_tolerance=0.001);
    ROOT::VecOps::RVec<float> operator()(const ROOT::VecOps::RVec<float> & px,
                                         const ROOT::VecOps::RVec<float> & py,
                                         const ROOT::VecOps::RVec<float> & pz);
 
  private:
    char const *_minname; 
    char const *_algoname; 
    int _maxcalls; 
    float _tolerance; 
    ROOT::Math::Minimizer *_min; 
    double _step[3]={0.001,0.001,0.001};
    double _variable[3]={1.0,1.0,1.0};
  };
 
 
  struct thrustFit {
  public:
    thrustFit(const ROOT::VecOps::RVec<float> & arg_px,
          const ROOT::VecOps::RVec<float> & arg_py,
          const ROOT::VecOps::RVec<float> & arg_pz);
    float operator()(const double *par);
 
  private:
    ROOT::VecOps::RVec<float> _px; 
    ROOT::VecOps::RVec<float> _py; 
    ROOT::VecOps::RVec<float> _pz; 
  };
 
 
  struct minimize_thrust {
    minimize_thrust(std::string arg_minname="Minuit2",
                    std::string arg_algoname="Migrad",
                    int arg_maxcalls=100000,
                    float arg_tolerance=0.001);
    ROOT::VecOps::RVec<float> operator()(const ROOT::VecOps::RVec<float> & px,
                                         const ROOT::VecOps::RVec<float> & py,
                                         const ROOT::VecOps::RVec<float> & pz);
 
  private:
    char const *_minname; 
    char const *_algoname; 
    int _maxcalls;
    float _tolerance;
    ROOT::Math::Minimizer *_min; 
    double _step[3]={0.001,0.001,0.001};
    double _variable[3]={1.0,1.0,1.0};
  };
 
  struct calculate_thrust {
    calculate_thrust(){}
    ROOT::VecOps::RVec<float> operator()(const ROOT::VecOps::RVec<float>& px,
                                         const ROOT::VecOps::RVec<float>& py,
                                         const ROOT::VecOps::RVec<float>& pz);
 
    // Helper functions, to ease manipulation with the elements of internal array
    inline void mag2(float (&vec)[4]);
    inline float dot(float vec1[4], float vec2[4]);
    inline void cross(float (&vec)[4], float vec1[4], float vec2[4]);
    inline void unit(float (&vec)[4]);
    inline void plus(float (&vec)[4], float vecIn1[4], float vecIn2[4]);
    inline void minus(float (&vecOut)[4], float vecIn1[4], float vecIn2[4]);
    inline void copy(float (&vecOut)[4], float vecIn[4]);
  };
 
  struct getAxisCharge {
  public:
    getAxisCharge(bool arg_pos=0,
                  float arg_power=1);
    float operator() (const ROOT::VecOps::RVec<float> & angle,
                      const ROOT::VecOps::RVec<float> & charge,
                      const ROOT::VecOps::RVec<float> & px,
                      const ROOT::VecOps::RVec<float> & py,
                      const ROOT::VecOps::RVec<float> & pz);
  private:
    bool _pos; 
    float _power; 
  };
 
 
  struct getAxisMass {
  public:
    getAxisMass(bool arg_pos=0);
    float operator() (const ROOT::VecOps::RVec<float> & angle,
                      const ROOT::VecOps::RVec<float> & energy,
                      const ROOT::VecOps::RVec<float> & px,
                      const ROOT::VecOps::RVec<float> & py,
                      const ROOT::VecOps::RVec<float> & pz);
  private:
    bool _pos; 
  };
 
 
  struct getAxisEnergy {
  public:
    getAxisEnergy(bool arg_pos=0);
    ROOT::VecOps::RVec<float> operator() (const ROOT::VecOps::RVec<float> & angle,
                                          const ROOT::VecOps::RVec<float> & charge,
                                          const ROOT::VecOps::RVec<float> & energy);
    private:
      bool _pos; 
  };
 
 
  struct getAxisN {
  public:
    getAxisN(bool arg_pos=0);
    ROOT::VecOps::RVec<int> operator() (const ROOT::VecOps::RVec<float> & angle,
                                        const ROOT::VecOps::RVec<float> & charge);
  private:
    bool _pos; 
  };
 
 
  struct getThrustPointing {
  public:
    getThrustPointing(float arg_dir=1.);
    ROOT::VecOps::RVec<float> operator() (const ROOT::VecOps::RVec<float> & in,
                                          const ROOT::VecOps::RVec<float> & rp_e,
                                          const ROOT::VecOps::RVec<float> & thrust);
  private:
    float _dir;
  };
 
 
  ROOT::VecOps::RVec<float> getAxisCosTheta(const ROOT::VecOps::RVec<float> & axis,
                                            const ROOT::VecOps::RVec<float> & px,
                                            const ROOT::VecOps::RVec<float> & py,
                                            const ROOT::VecOps::RVec<float> & pz);
 
  float getAxisCosTheta(const ROOT::VecOps::RVec<float> & axis,
                        float px,
                        float py,
                        float pz);
 
  float getMass(const ROOT::VecOps::RVec<edm4hep::ReconstructedParticleData> & in);
 
  struct jets_TwoHemispheres {
      int m_sorted=0;       
      int m_recombination = 0;  
      jets_TwoHemispheres( int arg_sorted, int arg_recombination ) ; 
      JetClustering::FCCAnalysesJet operator() (
                                        const ROOT::VecOps::RVec<float> & RP_px,
                                        const ROOT::VecOps::RVec<float> & RP_py,
                                        const ROOT::VecOps::RVec<float> & RP_pz,
                                        const ROOT::VecOps::RVec<float> & RP_e,
                                        const ROOT::VecOps::RVec<float> & RP_costheta ) ;
  } ;
 
}//end NS Algorithms
 
}//end NS FCCAnalyses
#endif