OscProbCalcerBase.h

Go to the documentation of this file.

#ifndef __OSCPROBCALCER_BASE_H__
#define __OSCPROBCALCER_BASE_H__
 
#include "Constants/OscillatorConstants.h"
 
#include <vector>
#include <string>
 
#include "yaml-cpp/yaml.h"
 
class OscProbCalcerBase {
 public:
  // ========================================================================================================================================================================
  // Public functions which are calculation implementation agnostic
  
  virtual ~OscProbCalcerBase();
  
  void SetEnergyArray(std::vector<FLOAT_T> EnergyArray);
 
  void SetCosineZArray(std::vector<FLOAT_T> CosineZArray);
 
  const FLOAT_T* ReturnPointerToWeight(int InitNuFlav, int FinalNuFlav, FLOAT_T Energy, FLOAT_T CosineZ=DUMMYVAL);
 
  void Reweight();
 
  void DefineParameter(const std::string& ParName, FLOAT_T* ParValue);
  
  void Reweight(const std::vector<FLOAT_T>& OscParams_);
 
  void Setup();
 
  bool SanityCheck();
 
  void PrintWeights();
 
  void PrintKnownOscillationChannels();
  
  bool HasOscillationChannel(int GeneratedFlavour, int DetectedFlavour);
 
  int ReturnNOscParams() {return fNOscParams;}
 
  std::vector<NuOscillator::OscillationChannel> ReturnOscChannels() {return fOscillationChannels;}
 
  std::vector<int> ReturnNeutrinoTypes() {return fNeutrinoTypes;}
 
  std::vector<FLOAT_T> ReturnOscParamsCurr() {return fOscParamsCurr;}
 
  int ReturnNEnergyPoints() {return fNEnergyPoints;}
 
  int ReturnNCosineZPoints() {return fNCosineZPoints;}
 
  std::vector<FLOAT_T> ReturnEnergyArray() {return fEnergyArray;}
 
  std::vector<FLOAT_T> ReturnCosineZArray() {return fCosineZArray;}
 
  std::string ReturnImplementationName() {return fImplementationName;}
 
  bool ReturnCosineZIgnored() {return fCosineZIgnored;}
 
  int ReturnNWeights() {return fNWeights;}
 
  std::vector<FLOAT_T> ReturnWeightArray() {return fWeightArray;}
 
  std::vector<NuOscillator::OscillationProbability> ReturnProbabilities();
 
  bool ReturnHasSetEnergyArray() {return fEnergyArraySet;}
 
  bool ReturnHasSetCosineZArray() {return fCosineZArraySet;}
 
  int ReturnNuTypeFromFlavour(int NuFlav);
  
  void PrintOscParamsCurr();
  
 
  // ========================================================================================================================================================================
  // Public virtual functions which need calculater specific implementations
 
 protected:
 
  OscProbCalcerBase(YAML::Node InputConfig_);
 
  OscProbCalcerBase(std::string ConfigName_) : OscProbCalcerBase(YAML::LoadFile(ConfigName_)) {}
  
  // ========================================================================================================================================================================
  // Protected functions which are calculation implementation agnostic  
 
  void IgnoreCosineZBinning(bool Ignore);
 
  bool AreOscParamsChanged();
 
  void SetCurrOscParams();
 
  void ResetCurrOscParams();
 
  void InitialiseNeutrinoTypesArray(int Size);
  
  void InitialiseOscillationChannelMapping();
 
  void CheckNuFlavourMapping();
 
  void IntialiseWeightArray();
 
  void SanitiseProbabilities();
 
  int ReturnCosineZIndexFromValue(FLOAT_T CosineZVal);
 
  int ReturnEnergyIndexFromValue(FLOAT_T EnergyVal);
 
  int ReturnOscChannelIndexFromFlavours(int InitNuFlav, int FinalNuFlav);
 
  void SetExpectedParameterNames(const std::vector<std::string>& ExpectedOscParNames_) {
    fExpectedOscillationParameterNames = ExpectedOscParNames_;
    fNOscParams = fExpectedOscillationParameterNames.size();
    fOscParams = std::vector<FLOAT_T*>(fNOscParams,new FLOAT_T(0));
    fOscillationParametersSetCheck = std::vector<bool>(fNOscParams,false);
  }
 
  void PrintExpectedParameterNames() {
    if (fNOscParams == 0) {
      std::cerr << "No oscillation parameter names to print" << std::endl;
      return;
    }
 
    std::cout << "Expected Parameters:" << std::endl;
    for (size_t iPar=0;iPar<fNOscParams;iPar++) {
      std::cout << "\t" << iPar << " : " << fExpectedOscillationParameterNames[iPar] << std::endl;
    }
  }
 
  FLOAT_T GetOscillationParameter(int Index);
 
  void CheckOscillationParametersDefined();
 
  // ========================================================================================================================================================================
  // Protected virtual functions which are calculation implementation agnostic
 
  virtual void CalculateProbabilities() = 0;
 
  virtual void SetupPropagator() = 0;
 
  virtual int ReturnWeightArrayIndex(int NuTypeIndex, int OscChanIndex, int EnergyIndex, int CosineZIndex=-1) = 0;
 
  virtual long DefineWeightArraySize() = 0;
 
  // ========================================================================================================================================================================
  // Basic variables required for oscillation probability calculation
 
  // Enums to define the mappings below. Each implementation is expected to define a mapping of which initial and neutrino flavours are considered, along with whether
  // neutrinos and antineutrinos are considered
 
  int fNNeutrinoTypes;
 
  std::vector<int> fNeutrinoTypes;
 
  int fNOscillationChannels;
 
  std::vector<NuOscillator::OscillationChannel> fOscillationChannels;
 
  int fNEnergyPoints;
 
  int fNCosineZPoints;
 
  std::vector<FLOAT_T> fEnergyArray;
 
  std::vector<FLOAT_T> fCosineZArray;
 
  int fNWeights;
  
  std::vector<FLOAT_T> fWeightArray;
 
  int fVerbose;
 
  std::string fImplementationName;
 
  bool fCosineZIgnored;
 
  YAML::Node Config;
  
 private:
  // ========================================================================================================================================================================
  // Sanity check variables
  bool fEnergyArraySet;
 
  bool fCosineZArraySet;
  
  bool fPropagatorSet;
 
  bool fWeightArrayInit;
 
  bool fNuMappingSet;
 
  FLOAT_T PrecisionLimit;
 
  int fNOscParams;
 
  std::vector<FLOAT_T> fOscParamsCurr;
 
  std::vector<FLOAT_T*> fOscParams;
 
  std::vector<std::string> fExpectedOscillationParameterNames;
 
  std::vector<bool> fOscillationParametersSetCheck;
 
  bool fUseLegacyMode;
 
  bool fUseLegacyMode_OscParsSet;
 
  bool fNoSanity;
};
 
#endif