Interface between NuOscillator and MaCh3, meant to compute oscillation weights for events/bin. More...

#include <Samples/OscillationHandler.h>

Collaboration diagram for OscillationHandler:

Public Member Functions
	OscillationHandler (const std::string &ConfigFile, bool EqualBinningPerChannel, std::vector< const double * > OscParams_, const int SubChannels)
	Constructor. More...

virtual	~OscillationHandler ()
	Destructor. More...

void	AddSample (const std::string &NuOscillatorConfigFile, const int SubChannels)
	Add different oscillator for sample. More...

bool	isEqualBinningPerOscChannel ()
	check if same binning is used for multiple oscillation channels More...

void	Evaluate ()
	DB Evaluate oscillation weights for each defined event/bin. More...

const M3::float_t *	GetNuOscillatorPointers (const int Sample, const int Channel, const int InitFlav, const int FinalFlav, const FLOAT_T TrueEnu, const FLOAT_T TrueCosZenith=-999)
	Get pointer to oscillation weight. More...

void	SetOscillatorBinning (const int Sample, const int Channel, const std::vector< M3::float_t > &EnergyArray, const std::vector< M3::float_t > &CosineZArray)
	Setup binning, arrays correspond to events and their energy bins. More...

unsigned int	GetOscParamsSize () const
	return size of oscillation parameter pointer vector More...

Private Attributes
bool	EqualBinningPerOscChannel
	flag used to define whether all oscillation channels have a probability calculated using the same binning More...

std::vector< std::vector< std::unique_ptr< OscillatorBase > > >	NuOscProbCalcers
	DB Variables required for oscillation. More...

std::vector< const double * >	OscParams
	pointer to osc params, since not all params affect every sample, we perform some operations before hand for speed More...

Detailed Description

Interface between NuOscillator and MaCh3, meant to compute oscillation weights for events/bin.

Author: Dan Barrow

Definition at line 11 of file OscillationHandler.h.

Constructor & Destructor Documentation

◆ OscillationHandler()

_MaCh3_Safe_Include_Start_ _MaCh3_Safe_Include_End_ OscillationHandler::OscillationHandler	(	const std::string &	ConfigFile,
		bool	EqualBinningPerChannel,
		std::vector< const double * >	OscParams_,
		const int	SubChannels
	)

Constructor.

Parameters

ConfigFile	name/path to NuOscillator Config
EqualBinningPerChannel	whether to use same binning per each oscillation channel
OscParams_	Pointers to values of oscillation parameters
SubChannels	Number of oscillation channels

Warning: If EqualBinningPerChannel is true then argument SubChannels makes no difference

Definition at line 9 of file OscillationHandler.cpp.

                                                                                                    {
 // ************************************************
   EqualBinningPerOscChannel = BinningPerOscChannel_;
   OscParams = OscParams_;
   // Add first sample
   NuOscProbCalcers.resize(1);
  
   auto OscillFactory = std::make_unique<OscillatorFactory>();
   //DB's explanation of EqualBinningPerOscChannel:
   //In the situation where we are applying binning oscillation probabilities to a SampleHandler object, it maybe the case that there is identical binning per oscillation channel
   //In which case, and remembering that each NuOscillator::Oscillator object calculate the oscillation probabilities for all channels, we just have to create one Oscillator object and use the results from that
   //This means that we can get up to a factor of 12 reduction in the calculation time of the oscillation probabilities, because we don't need to repeat the operation per oscillation channel
  
   if (EqualBinningPerOscChannel) {
     NuOscProbCalcers[0].resize(1);
     LoggerPrint("NuOscillator",
                 [](const std::string& message) { MACH3LOG_INFO("{}", message); },
                 [this, &OscillFactory, &NuOscillatorConfigFile]() {
                   this->NuOscProbCalcers[0][0] = std::unique_ptr<OscillatorBase>(OscillFactory->CreateOscillator(NuOscillatorConfigFile));
                 });
  
     if (!NuOscProbCalcers[0][0]->EvalPointsSetInConstructor()) {
       MACH3LOG_ERROR("Attempted to use equal binning per oscillation channel, but not binning has been set in the NuOscillator::Oscillator object");
       throw MaCh3Exception(__FILE__, __LINE__);
     }
     NuOscProbCalcers[0][0]->Setup();
   } else {
     NuOscProbCalcers[0].resize(SubChannels);
     for (int iChannel = 0; iChannel < SubChannels; iChannel++) {
       MACH3LOG_INFO("Setting up NuOscillator::Oscillator object in OscillationChannel: {}/{}", iChannel, SubChannels);
  
       LoggerPrint("NuOscillator",
                   [](const std::string& message) { MACH3LOG_INFO("{}", message); },
                   [this, iChannel, &OscillFactory, &NuOscillatorConfigFile]() {
                     this->NuOscProbCalcers[0][iChannel] = std::unique_ptr<OscillatorBase>(
                       OscillFactory->CreateOscillator(NuOscillatorConfigFile));
                   });
     }
   }
 }

◆ ~OscillationHandler()

OscillationHandler::~OscillationHandler ( )

virtual

Destructor.

Definition at line 52 of file OscillationHandler.cpp.

                                         {
 // ************************************************
 }

Member Function Documentation

◆ AddSample()

void OscillationHandler::AddSample	(	const std::string &	NuOscillatorConfigFile,
		const int	SubChannels
	)

Add different oscillator for sample.

Definition at line 57 of file OscillationHandler.cpp.

                                                                                                  {
 // ************************************************
   if(EqualBinningPerOscChannel){
     MACH3LOG_ERROR("Trying to add sample while EqualBinningPerOscChannel is enabled. This will not work...");
     throw MaCh3Exception(__FILE__, __LINE__);
   }
   auto OscillFactory = std::make_unique<OscillatorFactory>();
  
   std::vector<std::unique_ptr<OscillatorBase>> OscProbCalcersTemp(SubChannels);
  
   for (int iChannel = 0; iChannel < SubChannels; iChannel++) {
     MACH3LOG_INFO("Setting up NuOscillator::Oscillator object in OscillationChannel: {}/{}", iChannel, SubChannels);
  
     LoggerPrint("NuOscillator",
                 [](const std::string& message) { MACH3LOG_INFO("{}", message); },
                 [&OscProbCalcersTemp, iChannel, &OscillFactory, &NuOscillatorConfigFile]() {
                   OscProbCalcersTemp[iChannel] = std::unique_ptr<OscillatorBase>(
                     OscillFactory->CreateOscillator(NuOscillatorConfigFile));
                 });
   }
   NuOscProbCalcers.push_back(std::move(OscProbCalcersTemp));
 }

◆ Evaluate()

void OscillationHandler::Evaluate ( )

DB Evaluate oscillation weights for each defined event/bin.

Definition at line 81 of file OscillationHandler.cpp.

                                   {
 // ************************************************
   std::vector<M3::float_t> OscVec(OscParams.size());
   for (size_t iPar = 0; iPar < OscParams.size(); ++iPar) {
     #pragma GCC diagnostic push
     #pragma GCC diagnostic ignored "-Wuseless-cast"
     OscVec[iPar] = static_cast<M3::float_t>(*OscParams[iPar]);
     #pragma GCC diagnostic pop
   }
  
   if (EqualBinningPerOscChannel) {
     NuOscProbCalcers[0][0]->CalculateProbabilities(OscVec);
   } else {
     for (size_t iSample = 0; iSample < NuOscProbCalcers.size(); iSample++) {
       for (size_t iChannel = 0; iChannel < NuOscProbCalcers[iSample].size(); iChannel++) {
         NuOscProbCalcers[iSample][iChannel]->CalculateProbabilities(OscVec);
       }
     }
   }
 }

◆ GetNuOscillatorPointers()

const M3::float_t * OscillationHandler::GetNuOscillatorPointers	(	const int	Sample,
		const int	Channel,
		const int	InitFlav,
		const int	FinalFlav,
		const FLOAT_T	TrueEnu,
		const FLOAT_T	TrueCosZenith = `-999`
	)

Get pointer to oscillation weight.

Definition at line 104 of file OscillationHandler.cpp.

                                                                                                                                         {
 // ************************************************
   int IndexSample = 0;
   int IndexChannel = 0;
   if (!EqualBinningPerOscChannel) {
     IndexSample = Sample;
     IndexChannel = Channel;
   }
  
   if(TrueCosZenith != -999) {
     return NuOscProbCalcers[IndexSample][IndexChannel]->ReturnWeightPointer(InitFlav ,FinalFlav, TrueEnu, TrueCosZenith);
   } else {
     return NuOscProbCalcers[IndexSample][IndexChannel]->ReturnWeightPointer(InitFlav ,FinalFlav, TrueEnu);
   }
 }

◆ GetOscParamsSize()

unsigned int OscillationHandler::GetOscParamsSize ( ) const

inline

return size of oscillation parameter pointer vector

Definition at line 41 of file OscillationHandler.h.

41 {return static_cast<unsigned int>(OscParams.size());};

◆ isEqualBinningPerOscChannel()

bool OscillationHandler::isEqualBinningPerOscChannel ( )

inline

check if same binning is used for multiple oscillation channels

Definition at line 29 of file OscillationHandler.h.

29 {return EqualBinningPerOscChannel;}

◆ SetOscillatorBinning()

void OscillationHandler::SetOscillatorBinning	(	const int	Sample,
		const int	Channel,
		const std::vector< M3::float_t > &	EnergyArray,
		const std::vector< M3::float_t > &	CosineZArray
	)

Setup binning, arrays correspond to events and their energy bins.

Definition at line 123 of file OscillationHandler.cpp.

                                                                                         {
 // ************************************************
   if (!NuOscProbCalcers[Sample][Channel]->EvalPointsSetInConstructor()) {
     NuOscProbCalcers[Sample][Channel]->SetEnergyArrayInCalcer(EnergyArray);
     if(CosineZArray.size() != 0) NuOscProbCalcers[Sample][Channel]->SetCosineZArrayInCalcer(CosineZArray);
   }
   NuOscProbCalcers[Sample][Channel]->Setup();
 }

Member Data Documentation

◆ EqualBinningPerOscChannel

bool OscillationHandler::EqualBinningPerOscChannel

private

flag used to define whether all oscillation channels have a probability calculated using the same binning

Definition at line 44 of file OscillationHandler.h.

◆ NuOscProbCalcers

std::vector<std::vector<std::unique_ptr<OscillatorBase> > > OscillationHandler::NuOscProbCalcers

private

DB Variables required for oscillation.

Definition at line 47 of file OscillationHandler.h.

◆ OscParams

std::vector<const double*> OscillationHandler::OscParams

private

pointer to osc params, since not all params affect every sample, we perform some operations before hand for speed

Definition at line 50 of file OscillationHandler.h.

The documentation for this class was generated from the following files:

Samples/OscillationHandler.h
Samples/OscillationHandler.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ OscillationHandler()

◆ ~OscillationHandler()

Member Function Documentation

◆ AddSample()

◆ Evaluate()

◆ GetNuOscillatorPointers()

◆ GetOscParamsSize()

◆ isEqualBinningPerOscChannel()

◆ SetOscillatorBinning()

Member Data Documentation

◆ EqualBinningPerOscChannel

◆ NuOscProbCalcers

◆ OscParams