OscillationHandler Class Reference

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.
virtual	~OscillationHandler ()
	Destructor.
bool	isEqualBinningPerOscChannel ()
	check if same binning is used for multiple oscillation channels
void	Evaluate ()
	DB Evaluate oscillation weights for each defined event/bin.
const M3::float_t *	GetNuOscillatorPointers (int Channel, int InitFlav, int FinalFlav, FLOAT_T TrueEnu, FLOAT_T TrueCosZenith=-999)
	Get pointer to oscillation weight.
void	SetOscillatorBinning (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.
unsigned int	GetOscParamsSize () const
	return size of oscillation parameter pointer vector

Private Attributes
bool	EqualBinningPerOscChannel
	flag used to define whether all oscillation channels have a probability calculated using the same binning
std::vector< std::unique_ptr< OscillatorBase > >	NuOscProbCalcers
	DB Variables required for oscillation.
std::vector< const double * >	OscParams
	pointer to osc params, since not all params affect every sample, we perform some operations before hand for speed

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 make no difference

Definition at line 9 of file OscillationHandler.cpp.

                                                                                                   {
// ************************************************
  EqualBinningPerOscChannel = BinningPerOscChannel_;
  OscParams = OscParams_;
  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.resize(1);
    LoggerPrint("NuOscillator",
                [](const std::string& message) { MACH3LOG_INFO("{}", message); },
                [this, &OscillFactory, &NuOscillatorConfigFile]() {
                  this->NuOscProbCalcers[0] = std::unique_ptr<OscillatorBase>(OscillFactory->CreateOscillator(NuOscillatorConfigFile));
                });
 
    if (!NuOscProbCalcers[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]->Setup();
  } else {
    NuOscProbCalcers.resize(SubChannels);
    for (int iSample = 0; iSample < SubChannels; iSample++) {
      MACH3LOG_INFO("Setting up NuOscillator::Oscillator object in OscillationChannel: {}/{}", iSample, SubChannels);
 
      LoggerPrint("NuOscillator",
                  [](const std::string& message) { MACH3LOG_INFO("{}", message); },
                  [this, iSample, &OscillFactory, &NuOscillatorConfigFile]() {
                    this->NuOscProbCalcers[iSample] = std::unique_ptr<OscillatorBase>(
                      OscillFactory->CreateOscillator(NuOscillatorConfigFile));
                  });
    }
  }
}

~OscillationHandler()

OscillationHandler::~OscillationHandler ( )

virtual

Destructor.

Definition at line 50 of file OscillationHandler.cpp.

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

Member Function Documentation

Evaluate()

void OscillationHandler::Evaluate

(

)

DB Evaluate oscillation weights for each defined event/bin.

Definition at line 56 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]->CalculateProbabilities(OscVec);
  } else {
    for (size_t iChannel = 0; iChannel < NuOscProbCalcers.size(); iChannel++) {
      NuOscProbCalcers[iChannel]->CalculateProbabilities(OscVec);
    }
  }
}

GetNuOscillatorPointers()

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

Get pointer to oscillation weight.

Definition at line 77 of file OscillationHandler.cpp.

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

GetOscParamsSize()

unsigned int OscillationHandler::GetOscParamsSize ( ) const

inline

return size of oscillation parameter pointer vector

Definition at line 35 of file OscillationHandler.h.

{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 25 of file OscillationHandler.h.

{return EqualBinningPerOscChannel;}

SetOscillatorBinning()

void OscillationHandler::SetOscillatorBinning	(	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 93 of file OscillationHandler.cpp.

                                                                                                                                                  {
// ************************************************
  if (!NuOscProbCalcers[Channel]->EvalPointsSetInConstructor()) {
    NuOscProbCalcers[Channel]->SetEnergyArrayInCalcer(EnergyArray);
    if(CosineZArray.size() != 0) NuOscProbCalcers[Channel]->SetCosineZArrayInCalcer(CosineZArray);
  }
  NuOscProbCalcers[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 38 of file OscillationHandler.h.

NuOscProbCalcers

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

private

DB Variables required for oscillation.

Definition at line 41 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 44 of file OscillationHandler.h.

---

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

• Samples/OscillationHandler.h
• Samples/OscillationHandler.cpp