AlphaS.h

// -*- C++ -*-
//
// This file is part of LHAPDF
// Copyright (C) 2012-2016 The LHAPDF collaboration (see AUTHORS for details)
//
#pragma once
#ifndef LHAPDF_AlphaS_H
#define LHAPDF_AlphaS_H

#include "LHAPDF/Utils.h"
#include "LHAPDF/Exceptions.h"
#include "LHAPDF/KnotArray.h"

namespace LHAPDF {

  class AlphaS {
  public:

    AlphaS();

    virtual ~AlphaS() {};



    double alphasQ(double q) const { return alphasQ2(q*q); }

    virtual double alphasQ2(double q2) const = 0;





    int numFlavorsQ(double q) const { return numFlavorsQ2(q*q); }

    virtual int numFlavorsQ2(double q2) const;

    double quarkMass(int id) const;

    void setQuarkMass(int id, double value);

    double quarkThreshold(int id) const;

    void setQuarkThreshold(int id, double value);

    int orderQCD() { return _qcdorder; }

    void setOrderQCD(int order) { _qcdorder = order; }

    void setMZ(double mz) { _mz = mz; }

    void setAlphaSMZ(double alphas) { _alphas_mz = alphas; }

    void setMassReference(double mref) { _mreference = mref; _customref = true; }

    void setAlphaSReference(double alphas) { _alphas_reference = alphas; _customref = true; }

    virtual void setLambda(unsigned int, double) {};


    enum FlavorScheme { FIXED, VARIABLE };

    virtual std::string type() const = 0;

    void setFlavorScheme(FlavorScheme scheme, int nf = -1);

    FlavorScheme flavorScheme() const { return _flavorscheme; }


  protected:



    double _beta(int i, int nf) const;

    std::vector<double> _betas(int nf) const;



  protected:

    int _qcdorder;

    double _mz;

    double _alphas_mz;

    double _mreference;

    double _alphas_reference;

    bool _customref;

    std::map<int, double> _quarkmasses, _flavorthresholds;

    FlavorScheme _flavorscheme;

    int _fixflav;

  };



  class AlphaS_Analytic : public AlphaS {
  public:

    std::string type() const { return "analytic"; }

    double alphasQ2(double q2) const;

    int numFlavorsQ2(double q2) const;

    void setLambda(unsigned int i, double lambda);


  private:

    double _lambdaQCD(int nf) const;

    void _setFlavors();


    std::map<int, double> _lambdas;

    int _nfmax;
    int _nfmin;

  };



  class AlphaS_Ipol : public AlphaS {
  public:

    std::string type() const { return "ipol"; }

    double alphasQ2(double q2) const;

    void setQValues(const std::vector<double>& qs);

    void setQ2Values(const std::vector<double>& q2s) { _q2s = q2s; }

    void setAlphaSValues(const std::vector<double>& as) { _as = as; }


  private:

    double _interpolateCubic(double T, double VL, double VDL, double VH, double VDH) const;
    double _ddq_central( size_t i ) const;
    double _ddq_forward( size_t i ) const;
    double _ddq_backward( size_t i ) const;

    void _setup_grids() const;


    mutable std::map<double, AlphaSArray> _knotarrays;

    std::vector<double> _q2s;
    std::vector<double> _as;

  };



  class AlphaS_ODE : public AlphaS {
  public:

    std::string type() const { return "ode"; }

    double alphasQ2( double q2 ) const;

    void setMZ( double mz ) { _mz = mz; _calculated = false; }

    void setAlphaSMZ( double alphas ) { _alphas_mz = alphas; _calculated = false; }

    void setMassReference( double mref ) { _mreference = mref; _calculated = false; _customref = true; }

    void setAlphaSReference( double alphas ) { _alphas_reference = alphas; _calculated = false; _customref = true; }

    void setQValues(const std::vector<double>& qs);

    void setQ2Values( std::vector<double> q2s ) { _q2s = q2s; _calculated = false; }


  private:

    double _derivative(double t, double y, const std::vector<double>& beta) const;

    double _decouple(double y, double t, unsigned int ni, unsigned int nf) const;

    void _rk4(double& t, double& y, double h, const double allowed_change, const vector<double>& bs) const;

    void _solve(double q2, double& t, double& y, const double& allowed_relative, double h, double accuracy) const;

    void _interpolate() const;


    mutable std::vector<double> _q2s;

    mutable bool _calculated;

    mutable AlphaS_Ipol _ipol;

  };


}
#endif