Parameter.h

Go to the documentation of this file.

// Object to keep track of parameter information
//
// Created by Brian Rebel on 8/17/20.
//

#ifndef COVARIANCEMATRIXFIT_DATAPRODUCTS_PARAMETER_H
#define COVARIANCEMATRIXFIT_DATAPRODUCTS_PARAMETER_H

#include "NovaDAQConventions/DAQConventions.h"

#include "CovarianceMatrixFit/dataProducts/StaticFuncs.h"
#include "CovarianceMatrixFit/dataProducts/Constants.h"

#include <iomanip>

namespace cmf{
  class Parameter;
  class OscPar;
  class SystPar;

  typedef std::map<std::string, Parameter> ParameterSpaceLoc;

}


//----------------------------------------------------------------------------
class cmf::OscPar{

public:

  OscPar()
  : fParm(cmf::kNumOscParams)
  , fVal(cmf::kGarbageFloat)
  {}

  OscPar(cmf::OscParm_t const& par,
         float          const& val)
  : fParm(par)
  , fVal(val)
  {}

  cmf::OscParm_t const& Param() const { return fParm; }
  float          const& Value() const { return fVal;  }

  bool operator==(cmf::OscPar const& other) const { return fParm == other.Param(); }
  bool operator< (cmf::OscPar const& other) const { return fParm <  other.Param(); }

  friend std::ostream& operator << (std::ostream & o, cmf::OscPar const& op);

private:

  cmf::OscParm_t fParm;  ///< the parameter
  float          fVal;   ///< the value of the parameter
};

//----------------------------------------------------------------------------
class cmf::SystPar{

public:

  SystPar()
  : fParm(cmf::kNumSigmaSysts)
  , fVal(cmf::kGarbageFloat)
  {}

  SystPar(uint8_t const& par,
         float    const& val)
  : fParm(par)
  , fVal(val)
  {}

  uint8_t const& Param() const { return fParm; }
  float   const& Value() const { return fVal;  }

  bool operator==(cmf::SystPar const& other) const { return fParm == other.Param(); }
  bool operator< (cmf::SystPar const& other) const { return fParm <  other.Param(); }

private:

  uint8_t fParm;  ///< the parameter
  float   fVal;   ///< the value of the parameter
};

// cmf::Parameter is used in the definition of cmf::ParameterSpaceLoc
//.............................................................................
class cmf::Parameter{

public:
  Parameter();

  Parameter(std::string    const& name,
            cmf::DetType_t const& det,
            double         const& val,
            bool           const& fixed,
            float          const& sigmaSize,
            float          const& cv,
            float          const& variance,
            bool           const& nuisance,
            bool           const& constrained,
            float          const& lowerBound,
            float          const& upperBound);

  std::string         const  Name()           const { return (fParType == cmf::kOscPar) ? cmf::cOscParams_Strings[fKey] : cmf::KeyToVarName(fKey);  }
  cmf::ParType_t      const& ParType()        const { return fParType;                   }
  double              const& Value()          const { return fVal;                       }
  uint8_t             const& Key()            const { return fKey;                       }
  cmf::DetType_t      const  Detector()       const { return (cmf::DetType_t)fDetector;  }
  float               const& CentralValue()   const { return fCentralVal;                }
  float               const& Sigma()          const { return fSigmaSize;                 }
  float               const& Variance()       const { return fVariance;                  }
  bool                const& IsFixed()        const { return fIsFixed;                   }
  bool                       IsOscPar()       const { return (fParType == cmf::kOscPar); }
  bool                const& IsConstrained()  const { return fIsConstrained;             }
  bool                const& IsNuisance()     const { return fIsNuisance;                }
  float               const& LowerBound()     const { return fLowerBound;                }
  float               const& UpperBound()     const { return fUpperBound;                }

  void SetValue(double const& val) { fVal = val; }

  bool operator<(cmf::Parameter const& other) const;
  bool operator==(cmf::Parameter const& other) const;

  friend std::ostream& operator << (std::ostream & o, cmf::Parameter const& par);

private:
  uint8_t        fKey;           ///< key for this parameter
  uint8_t        fDetector;      ///< which detector is this parameter for?
  double         fVal;           ///< current value for the parameter in the fit
  float          fCentralVal;    ///< central value for the parameter
  float          fSigmaSize;     ///< size of 1 sigma
  float          fVariance;      ///< amount parameter can vary when making random universes
  bool           fIsFixed;       ///< is this parameter fixed during fits?
  bool           fIsNuisance;    ///< is this parameter treated as a nuisance parameter?
  bool           fIsConstrained; ///< is this parameter constrained in allowed values?
  float          fLowerBound;    ///< lower bound for the constrained parameter
  float          fUpperBound;    ///< upper bound for the constrained parameter
  cmf::ParType_t fParType;       ///< type of paramter this is

};

namespace cmf{

  class Location {

  public:

    Location()
    {}

    Location(ParameterSpaceLoc const& nd,
             ParameterSpaceLoc const& fd)
    : fNDLoc(nd)
    , fFDLoc(fd)
    {}

    Location(cmf::OscillationParameterMap const& oscPars);

    cmf::OscillationParameterMap AsOscillationParameterMap();

    cmf::ParameterSpaceLoc const& NDLocation() const { return fNDLoc; }
    cmf::ParameterSpaceLoc const& FDLocation() const { return fFDLoc; }

    void  InsertParameter(cmf::Parameter const& par);
    void  SetParameterValue(std::string    const& parName,
                            double         const& value,
                            cmf::DetType_t const& det);


  private:

    ParameterSpaceLoc fNDLoc;
    ParameterSpaceLoc fFDLoc;

    friend std::ostream& operator<<(std::ostream& o, cmf::Location const& loc);
  };
}

#endif //COVARIANCEMATRIXFIT_DATAPRODUCTS_PARAMETER_H