Parameterisation.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2013-2024  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_StructureFunctions_Parameterisation_h
#define CepGen_StructureFunctions_Parameterisation_h
 
#include <memory>
 
#include "CepGen/StructureFunctions/SigmaRatio.h"
 
namespace cepgen {
  namespace strfun {
    class Parameterisation : public NamedModule<Parameterisation> {
    public:
      explicit Parameterisation(const ParametersList&);
      virtual ~Parameterisation() = default;
 
      static ParametersDescription description();  
 
      friend std::ostream& operator<<(std::ostream&, const Parameterisation&);
 
      inline const sigrat::Parameterisation* sigmaRatio() const { return r_ratio_.get(); }
 
      Parameterisation& operator()(double /*xbj*/, double /*q2*/);
 
      double F2(double xbj, double q2);  
      double FL(double xbj, double q2);  
      double W1(double xbj, double q2);  
      double W2(double xbj, double q2);
      double FE(double xbj, double q2);  
      double FM(double xbj, double q2);  
      double F1(double xbj, double q2);  
 
      struct Arguments {
        inline bool operator==(const Arguments& oth) const { return xbj == oth.xbj && q2 == oth.q2; }
        inline bool valid() const { return q2 >= 0. && xbj >= 0. && xbj < 1.; }
        friend std::ostream& operator<<(std::ostream&, const Arguments&);
        double xbj{-1.}, q2{-1.};
      };
      struct Values {
        void clear() { f2 = 0., fl = 0., w1 = 0., w2 = 0., f2 = 0., fm = 0.; }
        friend std::ostream& operator<<(std::ostream&, const Values&);
 
        double f2{0.};  
        double fl{0.};  
 
        // alternative quantities
        double w1{0.};  
        double w2{0.};
        double fe{0.};  
        double fm{0.};  
      };
 
    protected:
      virtual void eval() = 0;  
 
      virtual Parameterisation& computeFL(double xbj, double q2);
      virtual Parameterisation& computeFL(double xbj, double q2, double r);
 
      Parameterisation& clear();  
 
      //-- fill in the structure functions values
      Parameterisation& setF1F2(double f1, double f2);
      Parameterisation& setF2(double f2);
      Parameterisation& setFL(double fl);
      Parameterisation& setW1(double w1);
      Parameterisation& setW2(double w2);
      Parameterisation& setFE(double fe);
      Parameterisation& setFM(double fm);
 
      double tau(double xbj, double q2) const;
      double gamma2(double xbj, double q2) const;
 
    private:
      const std::unique_ptr<sigrat::Parameterisation> r_ratio_;
 
    protected:
      const double mp_;      
      const double mp2_;     
      const double mx_min_;  
 
      Arguments args_;  
 
    private:
      Values vals_;
      bool fl_computed_{false};
    };
  }  // namespace strfun
}  // namespace cepgen
 
#endif