FitVars.h

Go to the documentation of this file.

#pragma once

#include <limits>

#include "CAFAna/Core/IFitVar.h"
#include "CAFAna/Core/StanTypedefs.h"

namespace ana
{
  /// \f$ \theta_{13} \f$
  class FitTheta13: virtual public IFitVar
  {
    public:
      FitTheta13() : IFitVar("th13", "#theta_{13}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
  };

  /// \f$ \theta_{13} \f$
  extern const FitTheta13 kFitTheta13;

  //----------------------------------------------------------------------

  /// \f$ \sin^22\theta_{13} \f$
  class FitSinSq2Theta13: virtual public IConstrainedFitVar
  {
    public:
      FitSinSq2Theta13() : IConstrainedFitVar("ss2th13", "sin^{2}2#theta_{13}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 1;};
  };

  /// \f$ \sin^22\theta_{13} \f$
  extern const FitSinSq2Theta13 kFitSinSq2Theta13;

  //----------------------------------------------------------------------

  /// \f$ \delta_{CP}/\pi \f$
  class FitDeltaInPiUnits: virtual public StanFitSupport<IFitVar>
  {
    public:
      FitDeltaInPiUnits() : StanFitSupport<IFitVar>("delta(pi)", "#delta / #pi") {};

      stan::math::var GetValue(const osc::IOscCalcAdjustableStan* osc) const override;
      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
      void SetValue(osc::IOscCalcAdjustableStan* osc, stan::math::var val) const override;
  };

  /// \f$ \delta_{CP}/\pi \f$
  extern const FitDeltaInPiUnits kFitDeltaInPiUnits;

  //----------------------------------------------------------------------

  /// \f$ \sin^2\theta_{23} \f$
  class FitSinSqTheta23: virtual public StanFitSupport<IConstrainedFitVar>
  {
    public:
      FitSinSqTheta23()
        : StanFitSupport<IConstrainedFitVar>("ssth23", "sin^{2}#theta_{23}")
      {}

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      stan::math::var GetValue(const osc::IOscCalcAdjustableStan* osc) const override;

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
      void SetValue(osc::IOscCalcAdjustableStan* osc, stan::math::var val) const override;

      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 1;};
  };

  /// \f$ \sin^2\theta_{23} \f$
  extern const FitSinSqTheta23 kFitSinSqTheta23;

  //----------------------------------------------------------------------
  /// \f$ \sin^2\theta_{23} Upper Octant\f$
  class FitSinSqTheta23UpperOctant: virtual public StanFitSupport<IConstrainedFitVar>
  {
    public:
      FitSinSqTheta23UpperOctant()
        : StanFitSupport<IConstrainedFitVar>("ssth23_uo", "sin^{2}#theta_{23} Upper Octant")
      {}

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      stan::math::var GetValue(const osc::IOscCalcAdjustableStan* osc) const override;

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
      void SetValue(osc::IOscCalcAdjustableStan* osc, stan::math::var val) const override;

      double LowLimit() const override  {return 0.5;};
      double HighLimit() const override  {return 1;};
  };

  /// \f$ \sin^2\theta_{23} UpperOctant \f$
  extern const FitSinSqTheta23UpperOctant kFitSinSqTheta23UpperOctant;

  //----------------------------------------------------------------------
  /// \f$ \sin^2\theta_{23} Lower Octant\f$
  class FitSinSqTheta23LowerOctant: virtual public StanFitSupport<IConstrainedFitVar>
  {
    public:
      FitSinSqTheta23LowerOctant()
        : StanFitSupport<IConstrainedFitVar>("ssth23_lo", "sin^{2}#theta_{23} Lower Octant")
      {}

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      stan::math::var GetValue(const osc::IOscCalcAdjustableStan* osc) const override;

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
      void SetValue(osc::IOscCalcAdjustableStan* osc, stan::math::var val) const override;

      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 0.5;};
  };

  /// \f$ \sin^2\theta_{23} Lower Octant \f$
  extern const FitSinSqTheta23LowerOctant kFitSinSqTheta23LowerOctant;

  //----------------------------------------------------------------------

  /// \f$ \sin^22\theta_{23} \f$
  class FitSinSq2Theta23: virtual public IConstrainedFitVar
  {
    public:
      FitSinSq2Theta23() : IConstrainedFitVar("ss2th23", "sin^{2}2#theta_{23}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;


      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 1;};
  };

  /// \f$ \sin^22\theta_{23} \f$
  extern const FitSinSq2Theta23 kFitSinSq2Theta23;

  //----------------------------------------------------------------------

  /// \f$ \Delta m^2_{32} \f$
  class FitDmSq32: virtual public IConstrainedFitVar
  {
  public:
    FitDmSq32() : IConstrainedFitVar("dmsq32", "#Deltam^{2}_{32}") {};

    double GetValue(const osc::IOscCalcAdjustable* osc) const override;
    void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

    // "1eV^2 splitting should be enough for anyone"
    // OscCalcPMNS freaks out at large splittings
    double LowLimit() const override  {return -1;};
    double HighLimit() const override  {return +1;};
  };

  /// \f$ \Delta m^2_{32} \f$
  extern const FitDmSq32 kFitDmSq32;

  //-------------------------------------------------------------------------

  /// \f$ \Delta m^2_{32}\times10^3{\rm eV}^2 \f$
  class FitDmSq32Scaled: virtual public StanFitSupport<IConstrainedFitVar>
  {
    public:
      FitDmSq32Scaled()
        : StanFitSupport<IConstrainedFitVar>("dmsq32scaled", "#Deltam^{2}_{32} (10^{-3} eV^{2})")
      {}

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      stan::math::var GetValue(const osc::IOscCalcAdjustableStan* osc) const override;

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;
      void SetValue(osc::IOscCalcAdjustableStan* osc, stan::math::var val) const override;

      // "1eV^2 splitting should be enough for anyone"
      // OscCalcPMNS freaks out at large splittings
      double LowLimit() const override  {return -1000;};
      double HighLimit() const override  {return +1000;};
  };

  /// \f$ \Delta m^2_{32}\times10^3{\rm eV}^2 \f$
  extern const FitDmSq32Scaled kFitDmSq32Scaled;

  //---------------------------------------------------------------------
  class FitDmSq32NormalHierarchy: virtual public IConstrainedFitVar
  {
    public:
      FitDmSq32NormalHierarchy() : IConstrainedFitVar("dmsq32NH", "#Deltam^{2}_{32} NH") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      // constrain this var to Normal Hierarchy and within a reasonable range
      // in eV
      double LowLimit() const override  {return 0;};
      double HighLimit() const override  { return 0.05;};
  };
  extern const FitDmSq32NormalHierarchy kFitDmSq32NormalHierarchy;

  //---------------------------------------------------------------------
  class FitDmSq32ScaledNH: virtual public IConstrainedFitVar
  {
    public:
      FitDmSq32ScaledNH() : IConstrainedFitVar("dmsq32ScaledNH", "#Deltam^{2}_{32} NH (10^{-3} eV^{2})") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      // vonstrain this var to Normal Hierarchy and within a reasonable range in 10^-3 eV
      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 50;};
  };
  extern const FitDmSq32ScaledNH kFitDmSq32ScaledNH;

  //----------------------------------------------------------------------
  class FitDmSq32ScaledIH: virtual public IConstrainedFitVar
  {
    public:
      FitDmSq32ScaledIH() : IConstrainedFitVar("dmsq32ScaledIH", "#Deltam^{2}_{32} IH (10^{-3} eV^{2})") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      // vonstrain this var to Normal Hierarchy and within a reasonable range in 10^-3 eV
      double LowLimit() const override  {return -50;};
      double HighLimit() const override  {return 0;};
  };
  extern const FitDmSq32ScaledIH kFitDmSq32ScaledIH;

  //---------------------------------------------------------------------
  class FitDmSq32InvertedHierarchy: virtual public IConstrainedFitVar
  {
    public:
      FitDmSq32InvertedHierarchy() : IConstrainedFitVar("dmsq32IH", "#Deltam^{2}_{32} IH") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      // constrain this var to Normal Hierarchy and within a reasonable range
      // in eV
      double LowLimit() const override  {return -0.05;};
      double HighLimit() const override  { return 0;};
  };
  extern const FitDmSq32InvertedHierarchy kFitDmSq32InvertedHierarchy;


  //----------------------------------------------------------------------

  /// \f$ \tan^2\theta_{12} \f$
  class FitTanSqTheta12: virtual public IConstrainedFitVar
  {
    public:
      FitTanSqTheta12() : IConstrainedFitVar("tsth12", "tan^{2}#theta_{12}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return std::numeric_limits<double>::max();};
  };

  /// \f$ \tan^2\theta_{12} \f$
  extern const FitTanSqTheta12 kFitTanSqTheta12;

  //----------------------------------------------------------------------

  /// \f$ \sin^22\theta_{12} \f$
  class FitSinSq2Theta12: virtual public IConstrainedFitVar
  {
    public:
      FitSinSq2Theta12() : IConstrainedFitVar("ss2th12", "sin^{2}2#theta_{12}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      double LowLimit() const override  {return 0;};
      double HighLimit() const override  {return 1;};
  };

  /// \f$ \sin^22\theta_{12} \f$
  extern const FitSinSq2Theta12 kFitSinSq2Theta12;

  //----------------------------------------------------------------------

  /// \f$ \Delta m^2_{21} \f$
  class FitDmSq21: virtual public IConstrainedFitVar
  {
    public:
      FitDmSq21() : IConstrainedFitVar("dmsq21", "#Deltam^{2}_{21}") {};

      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override;

      // "1eV^2 splitting should be enough for anyone"
      // OscCalcPMNS freaks out at large splittings
      double LowLimit() const override  {return -1;};
      double HighLimit() const override  {return +1;};
  };

  /// \f$ \Delta m^2_{21} \f$
  extern const FitDmSq21 kFitDmSq21;
} // namespace