FitVarsCPT.h

Go to the documentation of this file.

#pragma once

#include "OscLib/OscCalcCPT.h" // for ENuSign
#include "CAFAna/Core/FwdDeclare.h"
#include "CAFAna/Vars/FitVars.h"

namespace ana
{

  //---------------------------------------------------------------------------
  /// FitDmSq32, but for one sign only
  class FitDmSq32CPT: public FitDmSq32
  {
    public:
      explicit FitDmSq32CPT(osc::ENuSign nuSign)
        : IConstrainedFitVar((nuSign==osc::ENuSign::kNu) ? "dmsq32_nu" : "dmsq32_nubar",
                             (nuSign==osc::ENuSign::kNu) ? "#Deltam^{2}_{32}"
                                                          : "#Delta#bar{m}^{2}_{32}"),
          fNuSign(nuSign)
      {}
      double GetValue(const osc::IOscCalcAdjustable* osc) const override;
      void SetValue(osc::IOscCalcAdjustable* osc,
                    double val) const override;
    protected:
      const osc::ENuSign fNuSign;
  };

  extern const FitDmSq32CPT kFitDmSq32nu;
  extern const FitDmSq32CPT kFitDmSq32bar;


  //---------------------------------------------------------------------------
  /// FitDmSq32Scaled, but for one sign only
  class FitDmSq32ScaledCPT: public FitDmSq32Scaled
  {
    public:
      explicit FitDmSq32ScaledCPT(osc::ENuSign nuSign)
        : StanFitSupport<IConstrainedFitVar>((nuSign==osc::ENuSign::kNu) ? "dmsq32scaled_nu" : "dmsq32scaled_nubar",
                                             (nuSign==osc::ENuSign::kNu) ? "#Deltam^{2}_{32} (10^{-3} eV^{2})"
                                                                         : "#Delta#bar{m}^{2}_{32} (10^{-3} eV^{2})"),
          fNuSign(nuSign)
      {}

      // make sure the inherited methods don't get shadowed
      using FitDmSq32Scaled::GetValue;
      using FitDmSq32Scaled::SetValue;

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

  extern const FitDmSq32ScaledCPT kFitDmSq32Scalednu;
  extern const FitDmSq32ScaledCPT kFitDmSq32Scaledbar;



  //---------------------------------------------------------------------------
  // rough boundary between oscillation maxima
  constexpr double kDmsq32Limit = 6e-3;

  /** FitDmSq32CPT, but constrained to a hierarchy
      (and away from the other oscillation maximum near 8e-3 eV^2) */
  class FitDmSq32CPTHierarchy: public FitDmSq32CPT
  {
    public:
      explicit FitDmSq32CPTHierarchy(osc::ENuSign nuSign, bool inverted=false)
        : IConstrainedFitVar( ((nuSign==osc::ENuSign::kNu) ? "dmsq32scaled_nu" : "dmsq32scaled_nubar")
                                + std::string(inverted ? "_IH" : "_NH"),
                              ((nuSign==osc::ENuSign::kNu) ? "#Deltam^{2}_{32} (10^{-3} eV^{2})"
                                                           : "#Delta#bar{m}^{2}_{32} (10^{-3} eV^{2})")
                                + std::string(inverted ? " IH" : " NH")),
          FitDmSq32CPT(nuSign), fInverted(inverted)
      {}

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override
      {
        FitDmSq32CPT::SetValue(osc, Clamp(val));
      }

      double LowLimit() const override {return !fInverted ? 0 : -kDmsq32Limit ;}
      double HighLimit() const override {return !fInverted ? kDmsq32Limit : 0 ;}
    protected:
      const bool fInverted;
  };

  extern const FitDmSq32CPTHierarchy kFitDmSq32nuNorm;
  extern const FitDmSq32CPTHierarchy kFitDmSq32barNorm;
  extern const FitDmSq32CPTHierarchy kFitDmSq32nuInv;
  extern const FitDmSq32CPTHierarchy kFitDmSq32barInv;

  //---------------------------------------------------------------------------
  /// FitDmSq21, but for one sign only
  class FitDmSq21CPT: public FitDmSq21
  {
    public:
      explicit FitDmSq21CPT(osc::ENuSign nuSign)
        : IConstrainedFitVar((nuSign==osc::ENuSign::kNu) ? "dmsq21_nu" : "dmsq21_nubar",
                             (nuSign==osc::ENuSign::kNu) ? "#Deltam^{2}_{21}"
                                                          : "#Delta#bar{m}^{2}_{21}"),
          fNuSign(nuSign)
      {}

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

  extern const FitDmSq21CPT kFitDmSq21nu;
  extern const FitDmSq21CPT kFitDmSq21bar;

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

  /// FitSinSq2Theta23, but for one sign only
  class FitSinSq2Theta23CPT: public FitSinSq2Theta23
  {
    public:
      explicit FitSinSq2Theta23CPT(osc::ENuSign nuSign)
        : IConstrainedFitVar((nuSign==osc::ENuSign::kNu) ? "ss2th23_nu" : "ss2th23_nubar",
                             (nuSign==osc::ENuSign::kNu) ? "sin^{2}2#theta_{23}"
                                                          : "sin^{2}2#bar{#theta}_{23}"),
          fNuSign(nuSign)
      {}

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

  extern const FitSinSq2Theta23CPT kFitSinSq2Theta23nu;
  extern const FitSinSq2Theta23CPT kFitSinSq2Theta23bar;

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

  /// FitSinSqTheta23CPT, but for one sign only
  class FitSinSqTheta23CPT: public FitSinSqTheta23
  {
    public:
      explicit FitSinSqTheta23CPT(osc::ENuSign nuSign)
        : StanFitSupport<IConstrainedFitVar>((nuSign==osc::ENuSign::kNu) ? "ssth23_nu" : "ssth23_nubar",
                                             (nuSign==osc::ENuSign::kNu) ? "sin^{2}#theta_{23}"
                                                                         : "sin^{2}#bar{#theta}_{23}"),
          fNuSign(nuSign)
      {}

      // make sure the inherited methods don't get shadowed
      using FitSinSqTheta23::GetValue;
      using FitSinSqTheta23::SetValue;

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

  extern const FitSinSqTheta23CPT kFitSinSqTheta23nu;
  extern const FitSinSqTheta23CPT kFitSinSqTheta23bar;

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

  // boundary between octants
  constexpr double kSinsqtheta23Limit = .5;

  /// FitSinSqTheta23CPT, but forcing octant
  class FitSinSqTheta23CPTOctant: public FitSinSqTheta23CPT
  {
    public:
      explicit FitSinSqTheta23CPTOctant(osc::ENuSign nuSign, bool second=false)
        :  StanFitSupport<IConstrainedFitVar>( ((nuSign==osc::ENuSign::kNu) ? "ssth23_nu" : "ssth23_nubar")
                                               + std::string(second ? "_UO" : "_LO"),
                                               ((nuSign==osc::ENuSign::kNu) ? "sin^{2}#theta_{23}"
                                                                            : "sin^{2}#bar{#theta}_{23}")
                                               + std::string(second ? " UO" : " LO")),

           FitSinSqTheta23CPT(nuSign), fSecond(second)
      {}
      double LowLimit() const override  { return !fSecond ? 0 : kSinsqtheta23Limit; }
      double HighLimit() const override { return !fSecond ? kSinsqtheta23Limit : 1; }
    protected:
      const bool fSecond;
  };

  extern const FitSinSqTheta23CPTOctant kFitSinSqTheta23nuFirst;
  extern const FitSinSqTheta23CPTOctant kFitSinSqTheta23barFirst;
  extern const FitSinSqTheta23CPTOctant kFitSinSqTheta23nuSecond;
  extern const FitSinSqTheta23CPTOctant kFitSinSqTheta23barSecond;

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

  /// FitSinSq2Theta13, but for one sign only
  class FitSinSq2Theta13CPT: public FitSinSq2Theta13
  {
    public:
      explicit FitSinSq2Theta13CPT(osc::ENuSign nuSign)
        : IConstrainedFitVar((nuSign==osc::ENuSign::kNu) ? "ss2th13_nu" : "ss2th13_nubar",
                             (nuSign==osc::ENuSign::kNu) ? "sin^{2}2#theta_{13}"
                                                          : "sin^{2}2#bar{#theta}_{13}"),
          fNuSign(nuSign)
      {}

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

  extern const FitSinSq2Theta13CPT kFitSinSq2Theta13nu;
  extern const FitSinSq2Theta13CPT kFitSinSq2Theta13bar;

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

  /// FitSinSq2Theta12, but for one sign only
  class FitSinSq2Theta12CPT: public FitSinSq2Theta12
  {
    public:
      explicit FitSinSq2Theta12CPT(osc::ENuSign nuSign)
        : IConstrainedFitVar((nuSign==osc::ENuSign::kNu) ? "ss2th12_nu" : "ss2th12_nubar",
                             (nuSign==osc::ENuSign::kNu) ? "sin^{2}2#theta_{12}"
                                                          : "sin^{2}2#bar{#theta}_{12}"),
          fNuSign(nuSign)
      {}

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

  extern const FitSinSq2Theta12CPT kFitSinSq2Theta12nu;
  extern const FitSinSq2Theta12CPT kFitSinSq2Theta12bar;

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

  /** Helper class, allows FitVar pairs like var1+var2, var1-var2
      Requires CPT calculator to cache data when parallelized */
  class SigmaDelta
  {
    friend class FitSigmaCPT;
    friend class FitDeltaCPT;
    public:
      SigmaDelta(osc::OscCalcCPT* osc,
                 const IConstrainedFitVar &x,
                 const IConstrainedFitVar &y);
    private:
      double GetSigma(const osc::IOscCalcAdjustable* osc) const;
      double GetDelta(const osc::IOscCalcAdjustable* osc) const;
      void SetSigma(osc::IOscCalcAdjustable* osc, double val);
      void SetDelta(osc::IOscCalcAdjustable* osc, double val);
      double SigmaPenalty(double val, osc::IOscCalcAdjustable*) const;
      double DeltaPenalty(double val) const;
      const IConstrainedFitVar &fXvar;
      const IConstrainedFitVar &fYvar;
      void SetFitVars(osc::OscCalcCPT*);
      const double fCenterDelta;
      const double fCenterSigma;
  };

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

  /** A FitVar that acts like fXvar+fYvar for members of its helper SigmaDelta.
      Changing a FitSigmaCPT maintains the associated FitDeltaCPT */
  class FitSigmaCPT: public IFitVar
  {
    public:
      FitSigmaCPT(SigmaDelta *sd)
        : IFitVar(sd->fXvar.ShortName() + "_plus_" + sd->fYvar.ShortName(),
                  sd->fXvar.LatexName() + "+" + sd->fYvar.LatexName()),
          fSigDel{sd}
      {}

      double GetValue(const osc::IOscCalcAdjustable* osc) const override
        { return fSigDel->GetSigma(osc); }

      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override
        {  fSigDel->SetSigma(osc, val); }

      double Penalty(double val, osc::IOscCalcAdjustable* osc) const override
        { return fSigDel->SigmaPenalty(val, osc); }
    private:
      SigmaDelta* fSigDel;
  };

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

  /** A FitVar that acts like fXvar-fYvar for members of its helper SigmaDelta.
      Changing a FitDeltaCPT tries to maintain the associated FitSigmaCPT,
      but if constraints prevent this, only FitDelta is maintained */
  class FitDeltaCPT: public IFitVar
  {
    public:
      FitDeltaCPT(SigmaDelta *sd)
        : IFitVar(sd->fXvar.ShortName() + "_minus_" + sd->fYvar.ShortName(),
                  sd->fXvar.LatexName() + "-" + sd->fYvar.LatexName()),
          fSigDel{sd}
      {}
      double GetValue(const osc::IOscCalcAdjustable* osc) const override
        { return fSigDel->GetDelta(osc); }
      void SetValue(osc::IOscCalcAdjustable* osc, double val) const override
        { fSigDel->SetDelta(osc, val); }
      double Penalty(double val, osc::IOscCalcAdjustable*) const override
        { return fSigDel->DeltaPenalty(val); }
    private:
      SigmaDelta* fSigDel;
  };

} //namespace