Parameter.cxx

Go to the documentation of this file.

//
// Created by Brian Rebel on 8/17/20.
//

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

namespace cmf{

  //------------------------------------------------------------
  std::ostream& operator<<(std::ostream& o, cmf::OscPar const& op) {
    o << cmf::cOscParams_Strings[op.Param()]
      << " " 
      << op.Value();
      
    return o;
  }

  //----------------------------------------------------------------------------
  Parameter::Parameter()
  : fDetector     (cmf::kFARDET       )
  , fVal          (cmf::kGarbageDouble)
  , fCentralVal   (cmf::kGarbageFloat )
  , fSigmaSize    (1.e-5              )
  , fVariance     (1.e-5              )
  , fIsFixed      (false              )
  , fIsNuisance   (false              )
  , fIsConstrained(false              )
  , fLowerBound   (cmf::kGarbageFloat )
  , fUpperBound   (cmf::kGarbageFloat )
  , fParType      (cmf::kUnknownPar   )
  {
  }

  //----------------------------------------------------------------------------
  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)
  : fDetector     (det             )
  , fVal          (val             )
  , fCentralVal   (cv              )
  , fSigmaSize    (sigmaSize       )
  , fVariance     (variance        )
  , fIsFixed      (fixed           )
  , fIsNuisance   (nuisance        )
  , fIsConstrained(constrained     )
  , fLowerBound   (lowerBound      )
  , fUpperBound   (upperBound      )
  , fParType      (cmf::kUnknownPar)
  {
    if(fVariance < 1.e-5) fVariance = 1.e-5;

    if(cmf::IsOscillationParameter(name)){
      fParType = cmf::kOscPar;
      fKey     = cmf::StringToOscParmType(name);
    }
    else{
      fKey = cmf::VarNameToKey(name);
      if(fKey >= cmf::kFirstSigmaVar && fKey <= cmf::kLastSigmaVar) 
        fParType = cmf::kCMFSystPar;
      else if (fKey >= kFirstNormalizationVar && fKey <= cmf::kLastNormalizationVar)
        fParType = cmf::kCMFNormSystPar;
      else if (fKey >= kFirstCalibrationVar && fKey <= cmf::kLastCalibrationVar) 
        fParType = cmf::kCalibSystPar;
      else if (fKey >= kFirstEShiftVar && fKey <= cmf::kLastEShiftVar)
        fParType = cmf::kEShiftSystPar;
      else
        fParType = cmf::kOtherSystPar;
    }
      

    // sanity check warning - if the parameter is fixed and labeled as nuisance,
    // tell the user that the fixed part wins
    if(fIsFixed && fIsNuisance){
      LOG_WARNING("Parameter")
          << name
          << " is set to be fixed but is also set to be a nuisance parameter, "
          << "assume that leaving it fixed is correct and set IsNuisance to "
          << " false";

      fIsNuisance = false;
    }

  }

  //----------------------------------------------------------------------------
  bool Parameter::operator<(cmf::Parameter const& other) const {
    return fKey < other.Key();
  }

  //----------------------------------------------------------------------------
  bool Parameter::operator==(cmf::Parameter const& other) const {
    return fKey == other.Key();
  }

  //------------------------------------------------------------
  std::ostream& operator<<(std::ostream& o, cmf::Parameter const& par) {

    o  << "-- parameter: "
       << std::setw(30)     << par.Name()  << std::setw(10)
       << " val: "          << par.Value()
       << " fixed: "        << par.IsFixed()
       << " oscillation "   << par.IsOscPar()
       << " nuisance "      << par.IsNuisance()
       << " constrained "   << par.IsConstrained()
       << " lower: "        << par.LowerBound()
       << " upper: "        << par.UpperBound()
       << std::endl;

    return o;
  }

  //------------------------------------------------------------
  std::ostream& operator<<(std::ostream& o, cmf::Location const& loc) {
    o << std::endl;
    for(auto const& itr : loc.NDLocation()){
      o << " -- parameter: "  
        << std::setw(30)
        << itr.first
        << std::setw(15)
        << " val ND: "
        << itr.second.Value()
        << " fixed: "
        << std::setw(5)
        << itr.second.IsFixed();
      if(loc.FDLocation().count(itr.first) > 0)
        o << " val FD: "
          << std::setw(15)
          << " "
          << loc.FDLocation().find(itr.first)->second.Value()
          << " fixed: "
          << std::setw(5)
          << itr.second.IsFixed();

      o << std::endl;
    }
    for(auto const& itr : loc.FDLocation()){
      if(loc.NDLocation().count(itr.first) < 1)
       o  << " -- parameter: "
          << std::setw(30)
          << itr.first
          << std::setw(15)
          << " val FD: "
          << itr.second.Value()
          << " fixed: "
          << std::setw(5)
          << itr.second.IsFixed()
          << std::endl;
    }

    return o;
  }

  //----------------------------------------------------------------------------
  Location::Location(const cmf::OscillationParameterMap &oscPars)
  {
    for(auto const& itr : oscPars){
      fNDLoc.emplace(cmf::cOscParams_Strings[itr.first],
                     cmf::Parameter(cmf::cOscParams_Strings[itr.first],
                                    cmf::kNEARDET,
                                    itr.second,
                                    true,
                                    0,
                                    itr.second,
                                    0,
                                    false,
                                    false,
                                    0.,
                                    1.));
      fFDLoc.emplace(cmf::cOscParams_Strings[itr.first],
                     cmf::Parameter(cmf::cOscParams_Strings[itr.first],
                                    cmf::kFARDET,
                                    itr.second,
                                    true,
                                    0,
                                    itr.second,
                                    0,
                                    false,
                                    false,
                                    0.,
                                    1.));
    }

    // add in the baselines
    fNDLoc.emplace(cmf::cOscParams_Strings[cmf::kL],
                   cmf::Parameter(cmf::cOscParams_Strings[kL],
                                  cmf::kNEARDET,
                                  1,
                                  true,
                                  0,
                                  1,
                                  0,
                                  false,
                                  false,
                                  0.,
                                  1.));

    fFDLoc.emplace(cmf::cOscParams_Strings[cmf::kL],
                   cmf::Parameter(cmf::cOscParams_Strings[kL],
                                  cmf::kFARDET,
                                  810,
                                  true,
                                  0,
                                  810,
                                  0,
                                  false,
                                  false,
                                  0.,
                                  1.));

  }

  //----------------------------------------------------------------------------
  void Location::InsertParameter(cmf::Parameter const& par)
  {
    if(par.Detector() == cmf::kNEARDET){
      if(fNDLoc.count(par.Name()) < 1) fNDLoc.emplace(par.Name(), par);
      else fNDLoc.find(par.Name())->second.SetValue(par.Value());
    }
    if(par.Detector() == cmf::kFARDET){
      if(fFDLoc.count(par.Name()) < 1) fFDLoc.emplace(par.Name(), par);
      else fFDLoc.find(par.Name())->second.SetValue(par.Value());
    }
  }

  //----------------------------------------------------------------------------
  void Location::SetParameterValue(std::string    const& parName,
                                   double         const& value,
                                   cmf::DetType_t const& det)
  {
    if(det == cmf::kNEARDET){
      if(fNDLoc.count(parName) > 0) fNDLoc.find(parName)->second.SetValue(value);
      else
        LOG_WARNING("Location")
        << parName
        << " is not a recognized parameter for the NearDet";
    }
    else if(det == cmf::kFARDET ){
      if(fFDLoc.count(parName) > 0) fFDLoc.find(parName)->second.SetValue(value);
      else
        LOG_WARNING("Location")
            << parName
            << " is not a recognized parameter for the FarDet";
    }
  }

  //----------------------------------------------------------------------------
  cmf::OscillationParameterMap Location::AsOscillationParameterMap()
  {
    cmf::OscillationParameterMap oscMap;

    for(auto const& itr : fFDLoc){
      oscMap.emplace((cmf::OscParm_t)itr.second.Key(),
                     itr.second.Value());
    }

    return std::move(oscMap);
  }

}// namespace