BinnedSplineHandler Class Reference

Bin-by-bin class calculating response for spline parameters. More...

#include <Splines/BinnedSplineHandler.h>

Inheritance diagram for BinnedSplineHandler:

Collaboration diagram for BinnedSplineHandler:

Public Member Functions
	BinnedSplineHandler (ParameterHandlerGeneric *ParamHandler, MaCh3Modes *Modes_)
	Constructor. More...
virtual	~BinnedSplineHandler ()
	Destructor. More...
void	Evaluate () final
	CW: This Eval should be used when using two separate x,{y,a,b,c,d} arrays to store the weights; probably the best one here! Same thing but pass parameter spline segments instead of variations. More...
void	AddSample (const std::string &SampleName, const std::string &SampleTitle, const std::vector< std::string > &OscChanFileNames, const std::vector< std::string > &SplineVarNames)
	add oscillation channel to spline monolith More...
void	TransferToMonolith ()
	flatten multidimensional spline array into proper monolith More...
void	CleanUpMemory ()
	Remove setup variables not needed for spline evaluations. More...
virtual void	FillSampleArray (const std::string &SampleTitle, const std::vector< std::string > &OscChanFileNames)
	Loads and processes splines from ROOT files for a given sample. More...
std::vector< SplineIndex >	GetEventSplines (const std::string &SampleTitle, int iOscChan, int EventMode, double Var1Val, double Var2Val, double Var3Val)
	Return the splines which affect a given event. More...
void	SynchroniseMemTransfer () const final
	KS: After calculations are done on GPU we copy memory to CPU. This operation is asynchronous meaning while memory is being copied some operations are being carried. Memory must be copied before actual reweight. This function make sure all has been copied. More...
int	CountNumberOfLoadedSplines (bool NonFlat=false, int Verbosity=0) const
	Count how many splines we have. More...
const M3::float_t *	RetPointer (const SplineIndex &Variables) const
	get pointer to spline weight based on bin variables More...
void	PrepareSplineFile (std::string FileName) final
	KS: Prepare spline file that can be used for fast loading. More...
void	LoadSplineFile (std::string FileName) final
	KS: Load preprocessed spline file. More...
Public Member Functions inherited from SplineBase
	SplineBase ()
	Constructor. More...
virtual	~SplineBase ()
	Destructor. More...
virtual std::string	GetName () const
	Get class name. More...
short int	GetNParams () const
	Get number of spline parameters. More...

Protected Types
enum	TokenOrdering {   kSystToken , kModeToken , kVar1BinToken , kVar2BinToken ,   kVar3BinToken , kNTokens }

Protected Member Functions
void	CalcSplineWeights () final
	CPU based code which eval weight for each spline. More...
void	PrepForReweight ()
	Initialise flat structure. More...
void	BuildSampleIndexingArray (const std::string &SampleTitle)
	Only need 1 indexing array everything else interfaces with this to get binning properties. More...
std::vector< TAxis * >	FindSplineBinning (const std::string &FileName, const std::string &SampleTitle)
	Grab histograms with spline binning. More...
void	PrintBinning (TAxis *Axis) const
	Print spline binning. More...
void	PrintSampleDetails (const std::string &SampleTitle) const
	Print info like Sample ID of spline params etc. More...
void	PrintArrayDetails (const std::string &SampleTitle) const
	Print info like Sample ID of spline params etc. More...
int	GetSampleIndex (const std::string &SampleTitle) const
	Get index of sample based on name. More...
bool	isValidSplineIndex (const std::string &SampleTitle, int iSyst, int iOscChan, int iMode, const std::vector< int > &iVar) const
	Ensure we have spline for a given bin. More...
std::vector< std::vector< int > >	StripDuplicatedModes (const std::vector< std::vector< int > > &InputVector) const
	Creates an array to be filled with monolith indexes for each sample (allows for indexing between 7D binning and 1D Vector). More...
void	GetSplineCoeff_SepMany (int splineindex, M3::float_t *&xArray, M3::float_t *&manyArray)
	Rather work with spline coefficients in the splines, let's copy ND and use coefficient arrays. More...
virtual std::vector< std::string >	GetTokensFromSplineName (const std::string &FullSplineName)=0
	Extract metadata tokens encoded in a spline name. allows experiment to have different formats of splines. More...
Protected Member Functions inherited from SplineBase
void	FindSplineSegment ()
	CW:Code used in step by step reweighting, Find Spline Segment for each param. More...
void	PrepareFastSplineInfoDir (std::unique_ptr< TFile > &SplineFile) const
	KS: Prepare Fast Spline Info within SplineFile. More...
void	LoadFastSplineInfoDir (std::unique_ptr< TFile > &SplineFile)
	KS: Load preprocessed FastSplineInfo. More...
void	GetTF1Coeff (TF1_red *&spl, int &nPoints, float *&coeffs) const
	CW: Gets the polynomial coefficients for TF1. More...

Protected Attributes
ParameterHandlerGeneric *	ParHandler
	Pointer to covariance from which we get information about spline params. More...
std::vector< std::string >	SampleNames
std::vector< std::string >	SampleTitles
std::vector< int >	Dimensions
std::vector< std::vector< std::string > >	DimensionLabels
std::vector< int >	nSplineParams
std::vector< int >	nOscChans
std::vector< std::vector< std::vector< TAxis * > > >	SplineBinning
	Holds TAxis for [sample][channel][dimension]. More...
std::vector< std::vector< std::string > >	SplineFileParPrefixNames
	[Sample][Syst] More...
std::vector< std::vector< std::vector< int > > >	SplineModeVecs
std::vector< std::vector< int > >	GlobalSystIndex
	This holds the global spline index and is used to grab the current parameter value to evaluate splines at. Each internal vector will be of size of the number of spline systematics which affect that sample. More...
std::vector< std::vector< SplineInterpolation > >	SplineInterpolationTypes
	spline interpolation types for each sample. These vectors are from a call to GetSplineInterpolationFromSampleID() More...
std::vector< std::string >	UniqueSystNames
	name of each spline parameter More...
std::vector< int >	UniqueSystIndices
	Global index of each spline param, it allows us to match spline ordering with global. More...
std::vector< SplineIndex >	IndexVect
	Variables related to determined which modes have splines and which piggy-back of other modes. More...
std::map< std::tuple< int, int, int, int, int, int, int >, int >	IndexVectMap
	Map between spline origin/properties (iSample, iOscChan, iSyst, iMode, iVar1, iVar2, iVar3) and the index of the spline in IndexVect. More...
std::vector< int >	coeffindexvec
	Number of coefficients for a single flat (after flattening) More...
std::vector< int >	uniquecoeffindices
	Unique coefficient indices. More...
std::vector< TSpline3_red * >	splinevec_Monolith
	holds each spline object before stripping into coefficient monolith More...
int	MonolithSize
int	MonolithIndex
int	CoeffIndex
bool *	isflatarray
	Need to keep track of which splines are flat and which aren't. More...
M3::float_t *	xcoeff_arr
	x coefficients for each spline More...
M3::float_t *	manycoeff_arr
	ybcd coefficients for each spline More...
std::vector< M3::float_t >	weightvec_Monolith
	Stores weight from spline evaluation for each single spline. More...
std::vector< int >	uniquesplinevec_Monolith
	Maps single spline object with single parameter. More...
MaCh3Modes *	Modes
	pointer to MaCh3 Mode from which we get spline suffix More...
Protected Attributes inherited from SplineBase
std::vector< FastSplineInfo >	SplineInfoArray
short int *	SplineSegments
float *	ParamValues
	Store parameter values they are not in FastSplineInfo as in case of GPU we need to copy paste it to GPU. More...
short int	nParams
	Number of parameters that have splines. More...

Private Member Functions
void	InvestigateMissingSplines () const
	This function will find missing splines in file. More...
void	LoadSettingsDir (std::unique_ptr< TFile > &SplineFile)
	KS: Load preprocessed Settings. More...
void	LoadMonolithDir (std::unique_ptr< TFile > &SplineFile)
	KS: Load preprocessed Monolith. More...
void	LoadIndexDir (std::unique_ptr< TFile > &SplineFile)
	KS: Load preprocessed Index. More...
void	PrepareSettingsDir (std::unique_ptr< TFile > &SplineFile) const
	KS: Prepare Settings Info within SplineFile. More...
void	PrepareMonolithDir (std::unique_ptr< TFile > &SplineFile) const
	KS: Prepare Monolith Info within SplineFile. More...
void	PrepareIndexDir (std::unique_ptr< TFile > &SplineFile) const
	KS: Prepare Index Info within SplineFile. More...
void	PrepareOtherInfoDir (std::unique_ptr< TFile > &SplineFile) const
	KS: Prepare Other Info within SplineFile. More...

Detailed Description

Bin-by-bin class calculating response for spline parameters.

Author

Dan Barrow

Ed Atkin

Henry Wallace

Definition at line 11 of file BinnedSplineHandler.h.

Member Enumeration Documentation

TokenOrdering

enum BinnedSplineHandler::TokenOrdering

protected

Enumerator
kSystToken
kModeToken
kVar1BinToken
kVar2BinToken
kVar3BinToken
kNTokens

Definition at line 141 of file BinnedSplineHandler.h.

{kSystToken,kModeToken,kVar1BinToken,kVar2BinToken,kVar3BinToken,kNTokens};

Constructor & Destructor Documentation

BinnedSplineHandler()

_MaCh3_Safe_Include_Start_ _MaCh3_Safe_Include_End_ BinnedSplineHandler::BinnedSplineHandler	(	ParameterHandlerGeneric *	ParamHandler,
		MaCh3Modes *	Modes_
	)

Constructor.

Definition at line 14 of file BinnedSplineHandler.cpp.

                                                                                                 : SplineBase() {
//****************************************
  if (!ParHandler_) {
    MACH3LOG_ERROR("Trying to create BinnedSplineHandler with uninitialized covariance object");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  ParHandler = ParHandler_;
 
  if (!Modes_) {
    MACH3LOG_ERROR("Trying to create BinnedSplineHandler with uninitialized MaCh3Modes object");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  Modes = Modes_;
 
  // Keep these in class scope, important for using 1 monolith/sample!
  MonolithIndex = 0; //Keeps track of the monolith index we're on when filling arrays (declared here so we can have multiple FillSampleArray calls)
  CoeffIndex = 0; //Keeps track of our indexing the coefficient arrays [x, ybcd]
  isflatarray = nullptr;
}

~BinnedSplineHandler()

BinnedSplineHandler::~BinnedSplineHandler ( )

virtual

Destructor.

Definition at line 35 of file BinnedSplineHandler.cpp.

                                         {
//****************************************
  if(manycoeff_arr != nullptr) delete[] manycoeff_arr;
  if(xcoeff_arr != nullptr) delete[] xcoeff_arr;
  if(SplineSegments != nullptr) delete[] SplineSegments;
  if(ParamValues != nullptr) delete[] ParamValues;
}

Member Function Documentation

AddSample()

void BinnedSplineHandler::AddSample	(	const std::string &	SampleName,
		const std::string &	SampleTitle,
		const std::vector< std::string > &	OscChanFileNames,
		const std::vector< std::string > &	SplineVarNames
	)

add oscillation channel to spline monolith

Definition at line 70 of file BinnedSplineHandler.cpp.

                                                                                {
//****************************************
  SampleNames.push_back(SampleName);
  SampleTitles.push_back(SampleTitle);
  Dimensions.push_back(static_cast<int>(SplineVarNames.size()));
  DimensionLabels.push_back(SplineVarNames);
 
  int nSplineParam = ParHandler->GetNumParamsFromSampleName(SampleName, SystType::kSpline);
  nSplineParams.push_back(nSplineParam);
 
  //This holds the global index of the spline i.e. 0 -> _fNumPar
  std::vector<int> GlobalSystIndex_Sample = ParHandler->GetGlobalSystIndexFromSampleName(SampleName, SystType::kSpline);
  //Keep track of this for all the samples
  GlobalSystIndex.push_back(GlobalSystIndex_Sample);
 
  std::vector<SplineInterpolation> SplineInterpolation_Sample = ParHandler->GetSplineInterpolationFromSampleName(SampleName);
  // Keep track of this for all samples
  SplineInterpolationTypes.push_back(SplineInterpolation_Sample);
 
  std::vector<std::string> SplineFileParPrefixNames_Sample = ParHandler->GetSplineParsNamesFromSampleName(SampleName);
  SplineFileParPrefixNames.push_back(SplineFileParPrefixNames_Sample);
 
  MACH3LOG_INFO("Create SplineModeVecs_Sample");
  std::vector<std::vector<int>> SplineModeVecs_Sample = StripDuplicatedModes(ParHandler->GetSplineModeVecFromSampleName(SampleName));
  MACH3LOG_INFO("SplineModeVecs_Sample is of size {}", SplineModeVecs_Sample.size());
  SplineModeVecs.push_back(SplineModeVecs_Sample);
 
  MACH3LOG_INFO("SplineModeVecs is of size {}", SplineModeVecs.size());
 
  int nOscChan = int(OscChanFileNames.size());
  nOscChans.push_back(nOscChan);
 
  PrintSampleDetails(SampleTitle);
 
  std::vector<std::vector<TAxis *>> SampleBinning(nOscChan);
  for (int iOscChan = 0; iOscChan < nOscChan; iOscChan++)
  {
    SampleBinning[iOscChan] = FindSplineBinning(OscChanFileNames[iOscChan], SampleTitle);
  }
  MACH3LOG_INFO("#----------------------------------------------------------------------------------------------------------------------------------#");
  SplineBinning.push_back(SampleBinning);
 
  BuildSampleIndexingArray(SampleTitle);
  PrintArrayDetails(SampleTitle);
  MACH3LOG_INFO("#----------------------------------------------------------------------------------------------------------------------------------#");
 
  FillSampleArray(SampleTitle, OscChanFileNames);
  MACH3LOG_INFO("#----------------------------------------------------------------------------------------------------------------------------------#");
}

BuildSampleIndexingArray()

void BinnedSplineHandler::BuildSampleIndexingArray ( const std::string &  SampleTitle )

protected

Only need 1 indexing array everything else interfaces with this to get binning properties.

Definition at line 310 of file BinnedSplineHandler.cpp.

                                                                               {
//****************************************
  int iSample = GetSampleIndex(SampleTitle);
  for (int iOscChan = 0; iOscChan < nOscChans[iSample]; ++iOscChan)
  {
    for (int iSyst = 0; iSyst < nSplineParams[iSample]; ++iSyst)
    {
      int nModesInSyst = static_cast<int>(SplineModeVecs[iSample][iSyst].size());
      for (int iMode = 0; iMode < nModesInSyst; ++iMode)
      {
        const int nBins1 = SplineBinning[iSample][iOscChan][0]->GetNbins();
        const int nBins2 = SplineBinning[iSample][iOscChan][1]->GetNbins();
        const int nBins3 = SplineBinning[iSample][iOscChan][2]->GetNbins();
        for (int iVar1 = 0; iVar1 < nBins1; ++iVar1) {
          for (int iVar2 = 0; iVar2 < nBins2; ++iVar2) {
            for (int iVar3 = 0; iVar3 < nBins3; ++iVar3) {
              SplineIndex entry;
              entry.value    = -1;
              entry.iSample  = iSample;
              entry.iOscChan = iOscChan;
              entry.iSyst    = iSyst;
              entry.iMode    = iMode;
              entry.iVar = {iVar1, iVar2, iVar3};
              IndexVect.push_back(entry);
              IndexVectMap[std::make_tuple(iSample, iOscChan, iSyst, iMode, iVar1, iVar2, iVar3)] = static_cast<int>(IndexVect.size() - 1);
            }
          }
        }
      }
    }
  }
}

CalcSplineWeights()

void BinnedSplineHandler::CalcSplineWeights ( )

finalprotectedvirtual

CPU based code which eval weight for each spline.

Todo:

KS: Once could use "ParamValues" but this will result in tiny bit different results due to floating point precision

Implements SplineBase.

Definition at line 270 of file BinnedSplineHandler.cpp.

                                            {
//****************************************
  #ifdef MULTITHREAD
  #pragma omp parallel for simd
  #endif
  for (size_t iCoeff = 0; iCoeff < uniquecoeffindices.size(); ++iCoeff)
  {
    const int iSpline = uniquecoeffindices[iCoeff];
    const short int uniqueIndex = short(uniquesplinevec_Monolith[iSpline]);
    const short int currentsegment = short(SplineSegments[uniqueIndex]);
 
    const int segCoeff = coeffindexvec[iSpline]+currentsegment;
    const int coeffOffset = segCoeff * _nCoeff_;
    // These are what we can extract from the TSpline3
    const M3::float_t y = manycoeff_arr[coeffOffset+kCoeffY];
    const M3::float_t b = manycoeff_arr[coeffOffset+kCoeffB];
    const M3::float_t c = manycoeff_arr[coeffOffset+kCoeffC];
    const M3::float_t d = manycoeff_arr[coeffOffset+kCoeffD];
 
    // Get the variation for this reconfigure for the i-th parameter
    const M3::float_t xvar = (*SplineInfoArray[uniqueIndex].splineParsPointer);
    // The Delta(x) = xvar - x
    const M3::float_t dx = xvar - xcoeff_arr[segCoeff];
 
    //Speedy 1% time boost https://en.cppreference.com/w/c/numeric/math/fma (see ND code!)
    M3::float_t weight = M3::fmaf_t(dx, M3::fmaf_t(dx, M3::fmaf_t(dx, d, c), b), y);
    //This is the speedy version of writing dx^3+b*dx^2+c*dx+d
 
    //ETA - do we need this? We check later for negative weights and I wonder if this is even
    //possible with the fmaf line above?
    if(weight < 0){weight = 0.;}  //Stops is getting negative weights
 
    weightvec_Monolith[iSpline] = weight;
  }
}

CleanUpMemory()

void BinnedSplineHandler::CleanUpMemory

(

)

Remove setup variables not needed for spline evaluations.

Definition at line 44 of file BinnedSplineHandler.cpp.

                                        {
//****************************************
  //Call once everything's been allocated in SampleHandlerBase, cleans up junk from memory!
  //Not a huge saving but it's better than leaving everything up to the compiler
  MACH3LOG_INFO("Cleaning up spline memory");
  CleanVector(IndexVect);
  IndexVectMap.clear();
  CleanVector(SplineFileParPrefixNames);
  CleanVector(GlobalSystIndex);
  CleanVector(SplineModeVecs);
  CleanVector(UniqueSystNames);
  CleanVector(SplineInterpolationTypes);
  CleanVector(nOscChans);
  CleanVector(nSplineParams);
  CleanVector(DimensionLabels);
  CleanVector(SampleNames);
  CleanVector(SampleTitles);
  CleanVector(Dimensions);
  CleanContainer(splinevec_Monolith);
  CleanContainer(SplineBinning);
  CleanVector(UniqueSystIndices);
  if(isflatarray) delete [] isflatarray;
}

CountNumberOfLoadedSplines()

int BinnedSplineHandler::CountNumberOfLoadedSplines	(	bool	NonFlat = false,
		int	Verbosity = 0
	)		const

Count how many splines we have.

Definition at line 452 of file BinnedSplineHandler.cpp.

                                                                                     {
//****************************************
  std::vector<int> SampleAll(SampleTitles.size(), 0);
  std::vector<int> SampleNonFlat(SampleTitles.size(), 0);
 
  int FullCounter_All = 0;
  int FullCounter_NonFlat = 0;
 
  for (unsigned int index = 0; index < IndexVect.size(); index++)
  {
    const auto& entry = IndexVect[index];
 
    int iSample = entry.iSample;
 
    std::string SampleTitle = SampleTitles[iSample];
 
    if (!isValidSplineIndex(SampleTitle, entry.iOscChan, entry.iSyst,
         entry.iMode, entry.iVar)) {
      continue;
    }
    SampleAll[iSample]++;
 
    if (splinevec_Monolith[entry.value]) {
      SampleNonFlat[iSample]++;
    }
  }
 
  // Print per-sample summary
  for (size_t iSample = 0; iSample < SampleTitles.size(); iSample++)
  {
    MACH3LOG_DEBUG("{:<10} has {:<10} splines, of which {:<10} are not flat",
                   SampleTitles[iSample],
                   SampleAll[iSample],
                   SampleNonFlat[iSample]);
 
    FullCounter_All += SampleAll[iSample];
    FullCounter_NonFlat += SampleNonFlat[iSample];
  }
 
  if (Verbosity > 0) {
    MACH3LOG_INFO("Total number of splines loaded: {}", FullCounter_All);
    MACH3LOG_INFO("Total number of non-flat splines loaded: {}", FullCounter_NonFlat);
  }
 
  if (NonFlat) {
    return FullCounter_NonFlat;
  } else {
    return FullCounter_All;
  }
}

Evaluate()

void BinnedSplineHandler::Evaluate ( )

finalvirtual

CW: This Eval should be used when using two separate x,{y,a,b,c,d} arrays to store the weights; probably the best one here! Same thing but pass parameter spline segments instead of variations.

Implements SplineBase.

Definition at line 259 of file BinnedSplineHandler.cpp.

                                   {
// *****************************************
  // There's a parameter mapping that goes from spline parameter to a global parameter index
  // Find the spline segments
  FindSplineSegment();
 
  //KS: Huge MP loop over all valid splines
  CalcSplineWeights();
}

FillSampleArray()

void BinnedSplineHandler::FillSampleArray ( const std::string &  SampleTitle, const std::vector< std::string > &  OscChanFileNames  )

virtual

Loads and processes splines from ROOT files for a given sample.

Note

DB Add virtual so it can be overridden in experiment specific (if needed)

Definition at line 802 of file BinnedSplineHandler.cpp.

{
  int iSample = GetSampleIndex(SampleTitle);
  int nOscChannels = nOscChans[iSample];
  
  for (int iOscChan = 0; iOscChan < nOscChannels; iOscChan++) {
    MACH3LOG_INFO("Processing: {}", OscChanFileNames[iOscChan]);
    TSpline3* mySpline = nullptr;
    TSpline3_red* Spline = nullptr;
 
    std::set<std::string> SplineFileNames;
    auto File = std::unique_ptr<TFile>(TFile::Open(OscChanFileNames[iOscChan].c_str()));
 
    if (!File || File->IsZombie()) {
      MACH3LOG_ERROR("File {} not found", OscChanFileNames[iOscChan]);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    //This is the MC specific part of the code
    //i.e. we always assume that the splines are just store in  single TDirectory and they're all in there as single objects   
    for (auto k : *File->GetListOfKeys()) {
      auto Key = static_cast<TKey*>(k);
      TClass *Class = gROOT->GetClass(Key->GetClassName(), false);
      if(!Class->InheritsFrom("TSpline3")) {
        continue;
      }
 
      std::string FullSplineName = std::string(Key->GetName());
 
      if (SplineFileNames.count(FullSplineName) > 0) {
        MACH3LOG_CRITICAL("Skipping spline - Found a spline whose name has already been encountered before: {}", FullSplineName);
        continue;
      }
      SplineFileNames.insert(FullSplineName);
 
      std::vector<std::string> Tokens = GetTokensFromSplineName(FullSplineName);
 
      if (Tokens.size() != kNTokens) {
        MACH3LOG_ERROR("Invalid tokens from spline name - Expected {} tokens. Check implementation in GetTokensFromSplineName()", static_cast<int>(kNTokens));
        throw MaCh3Exception(__FILE__, __LINE__);
      }
      
      TString Syst = Tokens[kSystToken];
      TString Mode = Tokens[kModeToken];
      int Var1Bin = std::stoi(Tokens[kVar1BinToken]);
      int Var2Bin = std::stoi(Tokens[kVar2BinToken]);
      int Var3Bin = std::stoi(Tokens[kVar3BinToken]);
 
      int SystNum = -1;
      for (unsigned iSyst = 0; iSyst < SplineFileParPrefixNames[iSample].size(); iSyst++) {
        if (Syst == SplineFileParPrefixNames[iSample][iSyst]) {
          SystNum = iSyst;
          break;
        }
      }
 
      // If the syst doesn't match any of the spline names then skip it
      if (SystNum == -1){
        MACH3LOG_DEBUG("Couldn't Match any systematic name in ParameterHandler with spline name: {}" , FullSplineName);
        continue;
      }
 
      int ModeNum = -1;
      for (unsigned int iMode = 0; iMode < SplineModeVecs[iSample][SystNum].size(); iMode++) {
        if (Mode == Modes->GetSplineSuffixFromMaCh3Mode(SplineModeVecs[iSample][SystNum][iMode])) {
          ModeNum = iMode;
          break;
        }
      }
 
      if (ModeNum == -1) {
      //DB - If you have splines in the root file that you don't want to use (e.g. removing a mode from a syst), this will cause a throw
      //     Therefore include as debug warning and continue instead
        MACH3LOG_DEBUG("Couldn't find mode for {} in {}. Problem Spline is : {} ", Mode, Syst, FullSplineName);
        continue;
      }
 
      mySpline = Key->ReadObject<TSpline3>();
      // loop over all the spline knots and check their value
      if (isValidSplineIndex(SampleTitle, iOscChan, SystNum, ModeNum, {Var1Bin, Var2Bin, Var3Bin})) {
        MACH3LOG_TRACE("Pushed back monolith for spline {}", FullSplineName);
        // if the value is 1 then set the flat bool to false
        int nKnots = mySpline->GetNp();
        bool isFlat = true;
        for (int iKnot = 0; iKnot < nKnots; iKnot++) {
          double x, y = M3::_BAD_DOUBLE_;
          mySpline->GetKnot(iKnot, x, y);
          if (y < 0.99999 || y > 1.00001)
          {
            isFlat = false;
            break;
          }
        }
 
        //Rather than keeping a mega vector of splines then converting, this should just keep everything nice in memory!
        int index = IndexVectMap.at(std::make_tuple(iSample, iOscChan, SystNum, ModeNum, Var1Bin, Var2Bin, Var3Bin));
        IndexVect[index].value = MonolithIndex;
        coeffindexvec.push_back(CoeffIndex);
        // Should save memory rather saving [x_i_0 ,... x_i_maxknots] for every spline!
        if (isFlat) {
          splinevec_Monolith.push_back(nullptr);
          delete mySpline;
        } else {
          ApplyKnotWeightCapTSpline3(mySpline, SystNum, ParHandler);
          Spline = new TSpline3_red(mySpline, SplineInterpolationTypes[iSample][SystNum]);
          if(mySpline) delete mySpline;
 
          splinevec_Monolith.push_back(Spline);
          uniquecoeffindices.push_back(MonolithIndex); //So we can get the unique coefficients and skip flat splines later on!
          CoeffIndex+=nKnots;
        }
        //Incrementing MonolithIndex to keep track of number of valid spline indices
        MonolithIndex+=1;
      } else {
        //Potentially you are not a valid spline index
        delete mySpline;
      }
    }//End of loop over all TKeys in file
 
    //A bit of clean up
    File->Delete("*");
    File->Close();
  } //End of oscillation channel loop
}

FindSplineBinning()

std::vector< TAxis * > BinnedSplineHandler::FindSplineBinning ( const std::string &  FileName, const std::string &  SampleTitle  )

protected

Grab histograms with spline binning.

Definition at line 344 of file BinnedSplineHandler.cpp.

                                                                                                                 {
//****************************************
  int iSample = GetSampleIndex(SampleTitle);
 
  //Try declaring these outside of TFile so they aren't owned by File
  constexpr int nDummyBins = 1;
  constexpr double DummyEdges[2] = {-1e15, 1e15};
  TAxis* DummyAxis = new TAxis(nDummyBins, DummyEdges);
  TH2F* Hist2D = nullptr;
  TH3F* Hist3D = nullptr;
 
  auto File = std::unique_ptr<TFile>(TFile::Open(FileName.c_str(), "READ"));
  if (!File || File->IsZombie())
  {
    MACH3LOG_ERROR("File {} not found", FileName);
    MACH3LOG_ERROR("This is caused by something here! {} : {}", __FILE__, __LINE__);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  MACH3LOG_INFO("Finding binning for:");
  MACH3LOG_INFO("{}", FileName);
 
  std::string TemplateName = "dev_tmp_0_0";
  TObject *Obj = File->Get(TemplateName.c_str());
  //If you can't find dev_tmp_0_0 then this will cause a problem
  if (!Obj)
  {
    TemplateName = "dev_tmp.0.0";
    Obj = File->Get(TemplateName.c_str());
    if (!Obj)
    {
      MACH3LOG_ERROR("Could not find dev_tmp_0_0 in spline file. Spline binning cannot be set!");
      MACH3LOG_ERROR("FileName: {}", FileName);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  }
 
  //Now check if dev_tmp_0_0 is a TH2 i.e. specifying the dimensions of the splines is 2D
  bool isHist2D = Obj->IsA() == TH2F::Class();
  //For T2K annoyingly all objects are TH3Fs
  bool isHist3D = Obj->IsA() == TH3F::Class();
  if (!isHist2D && !isHist3D)
  {
    MACH3LOG_ERROR("Object doesn't inherit from either TH2D and TH3D - Odd A");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  if (isHist2D)
  {
    if (Dimensions[iSample] != 2)
    {
      MACH3LOG_ERROR("Trying to load a 2D spline template when nDim={}", Dimensions[iSample]);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    Hist2D = File->Get<TH2F>(TemplateName.c_str());
  }
 
  if (isHist3D)
  {
    Hist3D = File->Get<TH3F>((TemplateName.c_str()));
    if (Dimensions[iSample] != 3 && Hist3D->GetZaxis()->GetNbins() != 1)
    {
      MACH3LOG_ERROR("Trying to load a 3D spline template when nDim={}", Dimensions[iSample]);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  }
 
  std::vector<TAxis*> ReturnVec;
  // KS: Resize to reduce impact of push back and memory fragmentation
  ReturnVec.resize(3);
  if (Dimensions[iSample] == 2) {
    if (isHist2D) {
      ReturnVec[0] = static_cast<TAxis*>(Hist2D->GetXaxis()->Clone());
      ReturnVec[1] = static_cast<TAxis*>(Hist2D->GetYaxis()->Clone());
      ReturnVec[2] = static_cast<TAxis*>(DummyAxis->Clone());
    } else if (isHist3D) {
      ReturnVec[0] = static_cast<TAxis*>(Hist3D->GetXaxis()->Clone());
      ReturnVec[1] = static_cast<TAxis*>(Hist3D->GetYaxis()->Clone());
      ReturnVec[2] = static_cast<TAxis*>(DummyAxis->Clone());
    }
  } else if (Dimensions[iSample] == 3) {
    ReturnVec[0] = static_cast<TAxis*>(Hist3D->GetXaxis()->Clone());
    ReturnVec[1] = static_cast<TAxis*>(Hist3D->GetYaxis()->Clone());
    ReturnVec[2] = static_cast<TAxis*>(Hist3D->GetZaxis()->Clone());
  } else {
    MACH3LOG_ERROR("Number of dimensions not valid! Given: {}", Dimensions[iSample]);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  for (unsigned int iAxis = 0; iAxis < ReturnVec.size(); ++iAxis) {
    PrintBinning(ReturnVec[iAxis]);
  }
 
  MACH3LOG_INFO("Left PrintBinning now tidying up");
  delete DummyAxis;
 
  return ReturnVec;
}

GetEventSplines()

std::vector< SplineIndex > BinnedSplineHandler::GetEventSplines	(	const std::string &	SampleTitle,
		int	iOscChan,
		int	EventMode,
		double	Var1Val,
		double	Var2Val,
		double	Var3Val
	)

Return the splines which affect a given event.

Definition at line 708 of file BinnedSplineHandler.cpp.

                                                                                              {
//****************************************
  std::vector<SplineIndex> ReturnVec;
  int SampleIndex = GetSampleIndex(SampleTitle);
 
  int Mode = -1;
  std::string SuffixForEventMode = Modes->GetSplineSuffixFromMaCh3Mode(EventMode);
  for (int iMode = 0; iMode< Modes->GetNModes(); iMode++) {
    if (SuffixForEventMode == Modes->GetSplineSuffixFromMaCh3Mode(iMode)) {
      Mode = iMode;
      break;
    }
  }
  if (Mode == -1) {
    return ReturnVec;
  }
 
  std::vector<int> var_bins;
  std::vector<double> vars = {Var1Val, Var2Val, Var3Val};
  for (size_t i = 0; i < vars.size(); ++i) {
    int bin = SplineBinning[SampleIndex][iOscChan][i]->FindBin(vars[i]) - 1;
    if (bin < 0 || bin >= SplineBinning[SampleIndex][iOscChan][i]->GetNbins()) {
      return ReturnVec;
    }
    var_bins.push_back(bin);
  }
 
  for(int iSyst=0; iSyst < nSplineParams[SampleIndex]; iSyst++){
    std::vector<int> spline_modes = SplineModeVecs[SampleIndex][iSyst];
    int nSampleModes = static_cast<int>(spline_modes.size());
 
    //ETA - look here at the length of spline_modes and what you're actually comparing against
    for(int iMode = 0; iMode<nSampleModes; iMode++) {
      //Only consider if the event mode (Mode) matches ones of the spline modes
      if (Mode == spline_modes[iMode]) {
        int index = IndexVectMap.at(std::make_tuple(SampleIndex, iOscChan, iSyst, iMode,
                                                    var_bins[0], var_bins[1], var_bins[2]));
        int splineID = IndexVect[index].value;
        //Also check that the spline isn't flat
        if(!isflatarray[splineID]) {
          SplineIndex idx;
          idx.iSample  = SampleIndex;
          idx.iOscChan = iOscChan;
          idx.iSyst    = iSyst;
          idx.iMode    = iMode;
          idx.iVar     = var_bins;
          ReturnVec.push_back(idx);
        }
      }
    }
  }
  return ReturnVec;
}

GetSampleIndex()

int BinnedSplineHandler::GetSampleIndex ( const std::string &  SampleTitle ) const

protected

Get index of sample based on name.

Parameters

SampleTitle

The title of the sample to search for.

Definition at line 630 of file BinnedSplineHandler.cpp.

                                                                         {
//****************************************
  for (size_t iSample = 0; iSample < SampleTitles.size(); ++iSample) {
    if (SampleTitle == SampleTitles[iSample]) {
      return static_cast<int>(iSample);
    }
  }
  MACH3LOG_ERROR("Sample name not found: {}", SampleTitle);
  throw MaCh3Exception(__FILE__, __LINE__);
}

GetSplineCoeff_SepMany()

void BinnedSplineHandler::GetSplineCoeff_SepMany ( int  splineindex, M3::float_t *&  xArray, M3::float_t *&  manyArray  )

protected

Rather work with spline coefficients in the splines, let's copy ND and use coefficient arrays.

Definition at line 593 of file BinnedSplineHandler.cpp.

                                                                                                           {
//****************************************
  //No point evaluating a flat spline
  int nPoints = splinevec_Monolith[splineindex]->GetNp();
 
  for (int i = 0; i < nPoints; i++) {
    xArray[i] = 1.0;
    for (int j = 0; j < _nCoeff_; j++) {
      manyArray[i*_nCoeff_+j] = 1.0;
    }
  }
 
  for(int i=0; i<nPoints; i++) {
    M3::float_t x = M3::float_t(-999.99);
    M3::float_t y = M3::float_t(-999.99);
    M3::float_t b = M3::float_t(-999.99);
    M3::float_t c = M3::float_t(-999.99);
    M3::float_t d = M3::float_t(-999.99);
    splinevec_Monolith[splineindex]->GetCoeff(i, x, y, b, c, d);
 
    // Store the coefficients for each knot contiguously in memory
    // 4 because manyArray stores y,b,c,d
    xArray[i] = x;
    manyArray[i * _nCoeff_ + kCoeffY] = y;
    manyArray[i * _nCoeff_ + kCoeffB] = b;
    manyArray[i * _nCoeff_ + kCoeffC] = c;
    manyArray[i * _nCoeff_ + kCoeffD] = d;
  }
 
  //We now clean up the splines!
  delete splinevec_Monolith[splineindex];
  splinevec_Monolith[splineindex] = nullptr;
}

GetTokensFromSplineName()

virtual std::vector<std::string> BinnedSplineHandler::GetTokensFromSplineName ( const std::string &  FullSplineName )

protectedpure virtual

Extract metadata tokens encoded in a spline name. allows experiment to have different formats of splines.

InvestigateMissingSplines()

void BinnedSplineHandler::InvestigateMissingSplines ( ) const

private

This function will find missing splines in file.

Definition at line 124 of file BinnedSplineHandler.cpp.

                                                          {
//****************************************
  // Map: iSample → iSyst → modeSuffix → {totalSplines, zeroCount}
  std::map<unsigned int, std::map<unsigned int, std::map<std::string, std::pair<unsigned int, unsigned int>>>> systZeroCounts;
  for (const auto& entry : IndexVect) {
    unsigned int iSample = entry.iSample;
    unsigned int iSyst   = entry.iSyst;
 
    std::string SampleName = SampleNames[iSample];
    // Get the mode suffix string
    std::string modeSuffix = Modes->GetSplineSuffixFromMaCh3Mode(SplineModeVecs[iSample][entry.iSyst][entry.iMode]);
    auto& counts = systZeroCounts[iSample][iSyst][modeSuffix];
 
    counts.first++; // totalSplines
    if (entry.value == -1)
    {
      counts.second++; // zeroCount
      if (counts.second > 1)
      {
        MACH3LOG_DEBUG(
          "Sample '{}' | OscChan {} | Syst '{}' | Mode '{}' | Var {} => Value: {}",
          SampleTitles[iSample],
          entry.iOscChan,
          SplineFileParPrefixNames[iSample][iSyst],
          modeSuffix,
          fmt::join(entry.iVar, " "),
          entry.value
        );
      }
    }
  }
 
  // KS: Let's print this atrocious mess...
  for (const auto& samplePair : systZeroCounts) {
    unsigned int iSample = samplePair.first;
    std::vector<std::string> SplineFileParPrefixNames_Sample = ParHandler->GetParsNamesFromSampleName(SampleNames[iSample], kSpline);
    for (const auto& systPair : samplePair.second) {
      unsigned int iSyst = systPair.first;
      const auto& systName = SplineFileParPrefixNames_Sample[iSyst];
      for (const auto& modePair : systPair.second) {
        const auto& modeSuffix = modePair.first;
        const auto& counts = modePair.second;
        MACH3LOG_CRITICAL(
          "Sample '{}': Systematic '{}' has missing splines in mode '{}'. Expected Splines: {}, Missing Splines: {}",
          SampleTitles[iSample],
          systName,
          modeSuffix,
          counts.first,
          counts.second
        );
      }
    }
  }
}

isValidSplineIndex()

bool BinnedSplineHandler::isValidSplineIndex ( const std::string &  SampleTitle, int  iSyst, int  iOscChan, int  iMode, const std::vector< int > &  iVar  ) const

protected

Ensure we have spline for a given bin.

Definition at line 673 of file BinnedSplineHandler.cpp.

                                                                                                     {
//****************************************
  int iSample = GetSampleIndex(SampleTitle);
 
  bool found = IndexVectMap.find(std::make_tuple(iSample, iOscChan, iSyst, iMode, iVar[0], iVar[1], iVar[2])) != IndexVectMap.end();
 
  if (!found)
  {
    MACH3LOG_ERROR("Given iSample: {}", iSample);
    MACH3LOG_ERROR("Given iOscChan: {}", iOscChan);
    MACH3LOG_ERROR("Given iSyst: {}", iSyst);
    MACH3LOG_ERROR("Given iMode: {}", iMode);
    for (size_t i = 0; i < iVar.size(); ++i) {
      MACH3LOG_ERROR("Given iVar{}: {}", i, iVar[i]);
    }
    MACH3LOG_ERROR("Come visit me at : {} : {}", __FILE__, __LINE__);
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  return true;
}

LoadIndexDir()

void BinnedSplineHandler::LoadIndexDir ( std::unique_ptr< TFile > &  SplineFile )

private

KS: Load preprocessed Index.

Parameters

SplineFile

File from which we load new tree

Definition at line 1054 of file BinnedSplineHandler.cpp.

                                                                       {
// *****************************************
  TTree *IndexTree = SplineFile->Get<TTree>("IndexVec");
 
  SplineIndex* IndexTemp = nullptr;
  IndexTree->SetBranchAddress("SplineIndex", &IndexTemp);
  IndexVect.resize(IndexTree->GetEntries());
  // Fill indexvec with data from IndexTree
  for (Long64_t iEntry = 0; iEntry < IndexTree->GetEntries(); ++iEntry) {
    IndexTree->GetEntry(iEntry);
    IndexVect[iEntry] = *IndexTemp;
 
    auto key = std::make_tuple(IndexTemp->iSample, IndexTemp->iOscChan, IndexTemp->iSyst,
                               IndexTemp->iMode, IndexTemp->iVar[0], IndexTemp->iVar[1],
                               IndexTemp->iVar[2]);
    IndexVectMap[key] = static_cast<int>(iEntry);
  }
 
  // Load SplineBinning data
  TTree *SplineBinningTree = SplineFile->Get<TTree>("SplineBinningTree");
  std::vector<int> indices(3);
  SplineBinningTree->SetBranchAddress("i", &indices[0]);
  SplineBinningTree->SetBranchAddress("j", &indices[1]);
  SplineBinningTree->SetBranchAddress("k", &indices[2]);
  TAxis* axis = nullptr;
  SplineBinningTree->SetBranchAddress("axis", &axis);
 
  // Reconstruct TAxis objects
  for (Long64_t entry = 0; entry < SplineBinningTree->GetEntries(); ++entry) {
    SplineBinningTree->GetEntry(entry);
    int i = indices[0];
    int j = indices[1];
    int k = indices[2];
    SplineBinning[i][j][k] = static_cast<TAxis*>(axis->Clone());
  }
 
  std::vector<int> indices_mode(3);
  int mode_value;
  TTree *SplineModeTree = SplineFile->Get<TTree>("SplineModeTree");
  SplineModeTree->SetBranchAddress("i", &indices_mode[0]);
  SplineModeTree->SetBranchAddress("j", &indices_mode[1]);
  SplineModeTree->SetBranchAddress("k", &indices_mode[2]);
  SplineModeTree->SetBranchAddress("value", &mode_value);
 
  // Fill SplineModeVecs with values from the tree
  for (Long64_t entry = 0; entry < SplineModeTree->GetEntries(); ++entry) {
    SplineModeTree->GetEntry(entry);
    int i = indices_mode[0];
    int j = indices_mode[1];
    int k = indices_mode[2];
    SplineModeVecs[i][j][k] = mode_value;
  }
}

LoadMonolithDir()

void BinnedSplineHandler::LoadMonolithDir ( std::unique_ptr< TFile > &  SplineFile )

private

KS: Load preprocessed Monolith.

Parameters

SplineFile

File from which we load new tree

Definition at line 1020 of file BinnedSplineHandler.cpp.

                                                                          {
// *****************************************
  TTree *MonolithTree = SplineFile->Get<TTree>("MonolithTree");
 
  manycoeff_arr = new M3::float_t[CoeffIndex * _nCoeff_];
  MonolithTree->SetBranchAddress("manycoeff", manycoeff_arr);
  isflatarray = new bool[MonolithSize];
  weightvec_Monolith.resize(MonolithSize);
  MonolithTree->SetBranchAddress("isflatarray", isflatarray);
 
  // Load vectors
  std::vector<int>* coeffindexvec_temp = nullptr;
  MonolithTree->SetBranchAddress("coeffindexvec", &coeffindexvec_temp);
  std::vector<int>* uniquecoeffindices_temp = nullptr;
  MonolithTree->SetBranchAddress("uniquecoeffindices", &uniquecoeffindices_temp);
  std::vector<int>* uniquesplinevec_Monolith_temp = nullptr;
  MonolithTree->SetBranchAddress("uniquesplinevec_Monolith", &uniquesplinevec_Monolith_temp);
  std::vector<int>* UniqueSystIndices_temp = nullptr;
  MonolithTree->SetBranchAddress("UniqueSystIndices", &UniqueSystIndices_temp);
 
  // Allocate and load xcoeff_arr
  xcoeff_arr = new M3::float_t[CoeffIndex];
  MonolithTree->SetBranchAddress("xcoeff", xcoeff_arr);
 
  MonolithTree->GetEntry(0);
 
  coeffindexvec       = *coeffindexvec_temp;
  uniquecoeffindices  = *uniquecoeffindices_temp;
  uniquesplinevec_Monolith = *uniquesplinevec_Monolith_temp;
  UniqueSystIndices = *UniqueSystIndices_temp;
}

LoadSettingsDir()

void BinnedSplineHandler::LoadSettingsDir ( std::unique_ptr< TFile > &  SplineFile )

private

KS: Load preprocessed Settings.

Parameters

SplineFile

File from which we load new tree

Definition at line 968 of file BinnedSplineHandler.cpp.

                                                                          {
// *****************************************
  TTree *Settings = SplineFile->Get<TTree>("Settings");
  int CoeffIndex_temp, MonolithSize_temp;
  short int nParams_temp;
  Settings->SetBranchAddress("CoeffIndex", &CoeffIndex_temp);
  Settings->SetBranchAddress("MonolithSize", &MonolithSize_temp);
  Settings->SetBranchAddress("nParams", &nParams_temp);
 
  int SplineBinning_size1, SplineBinning_size2, SplineBinning_size3;
  Settings->SetBranchAddress("SplineBinning_size1", &SplineBinning_size1);
  Settings->SetBranchAddress("SplineBinning_size2", &SplineBinning_size2);
  Settings->SetBranchAddress("SplineBinning_size3", &SplineBinning_size3);
  int SplineModeVecs_size1, SplineModeVecs_size2, SplineModeVecs_size3;
  Settings->SetBranchAddress("SplineModeVecs_size1", &SplineModeVecs_size1);
  Settings->SetBranchAddress("SplineModeVecs_size2", &SplineModeVecs_size2);
  Settings->SetBranchAddress("SplineModeVecs_size3", &SplineModeVecs_size3);
  std::vector<std::string>* SampleNames_temp = nullptr;
  Settings->SetBranchAddress("SampleNames", &SampleNames_temp);
  std::vector<std::string>* SampleTitles_temp = nullptr;
  Settings->SetBranchAddress("SampleTitles", &SampleTitles_temp);
  std::vector<int>* nSplineParams_temp = nullptr;
  Settings->SetBranchAddress("nSplineParams", &nSplineParams_temp);
  Settings->GetEntry(0);
 
  CoeffIndex = CoeffIndex_temp;
  MonolithSize = MonolithSize_temp;
  SampleNames = *SampleNames_temp;
  SampleTitles = *SampleTitles_temp;
  nSplineParams = *nSplineParams_temp;
 
  nParams = nParams_temp;
 
  SplineSegments = new short int[nParams]();
  ParamValues = new float[nParams]();
 
  auto Resize3D = [](auto& vec, int d1, int d2, int d3) {
    vec.resize(d1);
    for (int i = 0; i < d1; ++i) {
      vec[i].resize(d2);
      for (int j = 0; j < d2; ++j) {
        vec[i][j].resize(d3);
      }
    }
  };
 
  Resize3D(SplineBinning, SplineBinning_size1, SplineBinning_size2, SplineBinning_size3);
  Resize3D(SplineModeVecs, SplineModeVecs_size1, SplineModeVecs_size2, SplineModeVecs_size3);
}

LoadSplineFile()

void BinnedSplineHandler::LoadSplineFile ( std::string  FileName )

finalvirtual

KS: Load preprocessed spline file.

Parameters

FileName

Path to ROOT file with predefined reduced Spline Monolith

Implements SplineBase.

Definition at line 929 of file BinnedSplineHandler.cpp.

                                                           {
// *****************************************
  M3::AddPath(FileName);
 
  // Check for spaces in the filename
  size_t pos = FileName.find(' ');
  if (pos != std::string::npos) {
    MACH3LOG_WARN("Filename ({}) contains spaces. Replacing spaces with underscores.", FileName);
    while ((pos = FileName.find(' ')) != std::string::npos) {
      FileName[pos] = '_';
    }
  }
  auto SplineFile = std::make_unique<TFile>(FileName.c_str(), "OPEN");
 
  TMacro *ConfigCov = SplineFile->Get<TMacro>("ParameterHandler");
  // Config which was in MCMC from which we are starting
  YAML::Node CovSettings = TMacroToYAML(*ConfigCov);
  // Config from currently used cov object
  YAML::Node ConfigCurrent = ParHandler->GetConfig();
 
  if (!compareYAMLNodes(CovSettings, ConfigCurrent))
  {
    MACH3LOG_ERROR("Loading precomputed spline file, however encountered different YAML config, please regenerate input");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  LoadSettingsDir(SplineFile);
  LoadMonolithDir(SplineFile);
  LoadIndexDir(SplineFile);
  LoadFastSplineInfoDir(SplineFile);
 
  for (int iSpline = 0; iSpline < nParams; iSpline++) {
    SplineInfoArray[iSpline].splineParsPointer = ParHandler->RetPointer(UniqueSystIndices[iSpline]);
  }
  SplineFile->Close();
}

PrepareIndexDir()

void BinnedSplineHandler::PrepareIndexDir ( std::unique_ptr< TFile > &  SplineFile ) const

private

KS: Prepare Index Info within SplineFile.

Parameters

SplineFile

File from which we load new tree

Definition at line 1201 of file BinnedSplineHandler.cpp.

                                                                                {
// *****************************************
  // Create a TTree to store the data
  TTree *IndexTree = new TTree("IndexVec", "IndexVec");
  SplineIndex entry;
  IndexTree->Branch("SplineIndex", &entry);
  for (const auto& e : IndexVect) {
    entry = e;
    IndexTree->Fill();
  }
 
  SplineFile->cd();
  IndexTree->Write();
  delete IndexTree;
}

PrepareMonolithDir()

void BinnedSplineHandler::PrepareMonolithDir ( std::unique_ptr< TFile > &  SplineFile ) const

private

KS: Prepare Monolith Info within SplineFile.

Parameters

SplineFile

File from which we load new tree

Definition at line 1178 of file BinnedSplineHandler.cpp.

                                                                                   {
// *****************************************
  TTree *MonolithTree = new TTree("MonolithTree", "MonolithTree");
  MonolithTree->Branch("manycoeff", manycoeff_arr, Form("manycoeff[%d]/%s", CoeffIndex * _nCoeff_, M3::float_t_str_repr));
  MonolithTree->Branch("isflatarray", isflatarray, Form("isflatarray[%d]/O", MonolithSize));
 
  std::vector<int> coeffindexvec_temp = coeffindexvec;
  MonolithTree->Branch("coeffindexvec", &coeffindexvec_temp);
  std::vector<int> uniquecoeffindices_temp = uniquecoeffindices;
  MonolithTree->Branch("uniquecoeffindices", &uniquecoeffindices_temp);
  std::vector<int> uniquesplinevec_Monolith_temp = uniquesplinevec_Monolith;
  MonolithTree->Branch("uniquesplinevec_Monolith", &uniquesplinevec_Monolith_temp);
  std::vector<int> UniqueSystIndices_temp = UniqueSystIndices;
  MonolithTree->Branch("UniqueSystIndices", &UniqueSystIndices_temp);
  MonolithTree->Branch("xcoeff", xcoeff_arr, Form("xcoeff[%d]/%s", CoeffIndex, M3::float_t_str_repr));
 
  MonolithTree->Fill();
  SplineFile->cd();
  MonolithTree->Write();
  delete MonolithTree;
}

PrepareOtherInfoDir()

void BinnedSplineHandler::PrepareOtherInfoDir ( std::unique_ptr< TFile > &  SplineFile ) const

private

KS: Prepare Other Info within SplineFile.

Parameters

SplineFile

File from which we load new tree

Definition at line 1218 of file BinnedSplineHandler.cpp.

                                                                                    {
// *****************************************
  // Create a new tree for SplineBinning data
  TTree *SplineBinningTree = new TTree("SplineBinningTree", "SplineBinningTree");
  std::vector<int> indices(3); // To store the 3D indices
  TAxis* axis = nullptr;
  SplineBinningTree->Branch("i", &indices[0], "i/I");
  SplineBinningTree->Branch("j", &indices[1], "j/I");
  SplineBinningTree->Branch("k", &indices[2], "k/I");
  SplineBinningTree->Branch("axis", "TAxis", &axis);
 
  // Fill the SplineBinningTree
  for (size_t i = 0; i < SplineBinning.size(); ++i) {
    for (size_t j = 0; j < SplineBinning[i].size(); ++j) {
      for (size_t k = 0; k < SplineBinning[i][j].size(); ++k) {
        axis = SplineBinning[i][j][k];
        indices[0] = static_cast<int>(i);
        indices[1] = static_cast<int>(j);
        indices[2] = static_cast<int>(k);
        SplineBinningTree->Fill();
      }
    }
  }
  SplineFile->cd();
  SplineBinningTree->Write();
  delete SplineBinningTree;
 
  std::vector<int> indices_mode(3); // to store 3D indices
  int mode_value;
 
  TTree *SplineModeTree = new TTree("SplineModeTree", "SplineModeTree");
  // Create branches for indices and value
  SplineModeTree->Branch("i", &indices_mode[0], "i/I");
  SplineModeTree->Branch("j", &indices_mode[1], "j/I");
  SplineModeTree->Branch("k", &indices_mode[2], "k/I");
  SplineModeTree->Branch("value", &mode_value, "value/I");
 
  // Fill the tree
  for (size_t i = 0; i < SplineModeVecs.size(); ++i) {
    for (size_t j = 0; j < SplineModeVecs[i].size(); ++j) {
      for (size_t k = 0; k < SplineModeVecs[i][j].size(); ++k) {
        indices_mode[0] = static_cast<int>(i);
        indices_mode[1] = static_cast<int>(j);
        indices_mode[2] = static_cast<int>(k);
        mode_value = SplineModeVecs[i][j][k];
        SplineModeTree->Fill();
      }
    }
  }
  // Write the tree to the file
  SplineFile->cd();
  SplineModeTree->Write();
  delete SplineModeTree;
}

PrepareSettingsDir()

void BinnedSplineHandler::PrepareSettingsDir ( std::unique_ptr< TFile > &  SplineFile ) const

private

KS: Prepare Settings Info within SplineFile.

Parameters

SplineFile

File from which we load new tree

Definition at line 1137 of file BinnedSplineHandler.cpp.

                                                                                   {
// *****************************************
  TTree *Settings = new TTree("Settings", "Settings");
  int CoeffIndex_temp = CoeffIndex;
  int MonolithSize_temp = MonolithSize;
  short int nParams_temp = nParams;
 
  Settings->Branch("CoeffIndex", &CoeffIndex_temp, "CoeffIndex/I");
  Settings->Branch("MonolithSize", &MonolithSize_temp, "MonolithSize/I");
  Settings->Branch("nParams", &nParams_temp, "nParams/S");
 
  int SplineBinning_size1 = static_cast<int>(SplineBinning.size());
  int SplineBinning_size2 = (SplineBinning_size1 > 0) ? static_cast<int>(SplineBinning[0].size()) : 0;
  int SplineBinning_size3 = (SplineBinning_size2 > 0) ? static_cast<int>(SplineBinning[0][0].size()) : 0;
 
  Settings->Branch("SplineBinning_size1", &SplineBinning_size1, "SplineBinning_size1/I");
  Settings->Branch("SplineBinning_size2", &SplineBinning_size2, "SplineBinning_size2/I");
  Settings->Branch("SplineBinning_size3", &SplineBinning_size3, "SplineBinning_size3/I");
 
  int SplineModeVecs_size1 = static_cast<int>(SplineModeVecs.size());
  int SplineModeVecs_size2 = (SplineModeVecs_size1 > 0) ? static_cast<int>(SplineModeVecs[0].size()) : 0;
  int SplineModeVecs_size3 = (SplineModeVecs_size2 > 0) ? static_cast<int>(SplineModeVecs[0][0].size()) : 0;
 
  Settings->Branch("SplineModeVecs_size1", &SplineModeVecs_size1, "SplineModeVecs_size1/I");
  Settings->Branch("SplineModeVecs_size2", &SplineModeVecs_size2, "SplineModeVecs_size2/I");
  Settings->Branch("SplineModeVecs_size3", &SplineModeVecs_size3, "SplineModeVecs_size3/I");
 
  std::vector<std::string> SampleNames_temp = SampleNames;
  Settings->Branch("SampleNames", &SampleNames_temp);
  std::vector<std::string> SampleTitles_temp = SampleTitles;
  Settings->Branch("SampleTitles", &SampleTitles_temp);
  std::vector<int> nSplineParams_temp = nSplineParams;
  Settings->Branch("nSplineParams", &nSplineParams_temp);
 
  Settings->Fill();
  SplineFile->cd();
  Settings->Write();
  delete Settings;
}

PrepareSplineFile()

void BinnedSplineHandler::PrepareSplineFile ( std::string  FileName )

finalvirtual

KS: Prepare spline file that can be used for fast loading.

Implements SplineBase.

Definition at line 1110 of file BinnedSplineHandler.cpp.

                                                              {
// *****************************************
  M3::AddPath(FileName);
  // Check for spaces in the filename
  size_t pos = FileName.find(' ');
  if (pos != std::string::npos) {
    MACH3LOG_WARN("Filename ({}) contains spaces. Replacing spaces with underscores.", FileName);
    while ((pos = FileName.find(' ')) != std::string::npos) {
      FileName[pos] = '_';
    }
  }
  // Save ROOT File
  auto SplineFile = std::make_unique<TFile>(FileName.c_str(), "recreate");
  YAML::Node ConfigCurrent = ParHandler->GetConfig();
  TMacro ConfigSave = YAMLtoTMacro(ConfigCurrent, "ParameterHandler");
  ConfigSave.Write();
 
  PrepareSettingsDir(SplineFile);
  PrepareMonolithDir(SplineFile);
  PrepareIndexDir(SplineFile);
  PrepareOtherInfoDir(SplineFile);
  PrepareFastSplineInfoDir(SplineFile);
 
  SplineFile->Close();
}

PrepForReweight()

void BinnedSplineHandler::PrepForReweight ( )

protected

Initialise flat structure.

Definition at line 504 of file BinnedSplineHandler.cpp.

                                          {
//****************************************
  std::vector<TSpline3_red*> UniqueSystSplines;
  bool FoundNonFlatSpline = false;
  int SampleCounter = M3::_BAD_INT_;
  int SystCounter = M3::_BAD_INT_;
  // DB Find all the Unique systs across each sample and oscillation channel
  //    This assumes that each occurrence of the same systematic spline has the same knot spacing
  //    Which is a reasonable assumption for the current implementation of spline evaluations
  for (const auto& entry : IndexVect)
  {
    int splineindex = entry.value;
    // KS: reset if we moved to another sample or syst
    if(SampleCounter != entry.iSample || SystCounter != entry.iSyst) {
      SampleCounter = entry.iSample;
      SystCounter = entry.iSyst;
      FoundNonFlatSpline = false;
    }
    std::string SystName = SplineFileParPrefixNames[entry.iSample][entry.iSyst];
    bool FoundSyst = false;
    for (unsigned int iFoundSyst = 0; iFoundSyst < UniqueSystNames.size(); iFoundSyst++) {
      if (SystName == UniqueSystNames[iFoundSyst]) {
        FoundSyst = true;
      }
    }
    if (FoundSyst) continue;
 
    if (splinevec_Monolith[splineindex])
    {
      UniqueSystSplines.push_back(splinevec_Monolith[splineindex]);
      UniqueSystIndices.push_back(GlobalSystIndex[entry.iSample][entry.iSyst]);
 
      FoundNonFlatSpline = true;
    }
    if (FoundNonFlatSpline) {
      UniqueSystNames.push_back(SystName);
    } else {
      MACH3LOG_INFO("{} syst has no response in sample {}", SystName, entry.iSample);
      MACH3LOG_INFO("Whilst this isn't necessarily a problem, it seems odd");
    }
  }  // end loop over indices
  nParams = static_cast<short int>(UniqueSystSplines.size());
 
  // DB Find the number of splines knots which assumes each instance of the syst has the same number of knots
  SplineSegments = new short int[nParams]();
  ParamValues = new float[nParams]();
  SplineInfoArray.resize(nParams);
  for (int iSpline = 0; iSpline < nParams; iSpline++)
  {
    SplineInfoArray[iSpline].nPts = static_cast<M3::int_t>(UniqueSystSplines[iSpline]->GetNp());
    SplineInfoArray[iSpline].xPts.resize(SplineInfoArray[iSpline].nPts);
    SplineInfoArray[iSpline].splineParsPointer = ParHandler->RetPointer(UniqueSystIndices[iSpline]);
    for (int iKnot = 0; iKnot < SplineInfoArray[iSpline].nPts; iKnot++)
    {
      M3::float_t xPoint;
      M3::float_t yPoint;
      UniqueSystSplines[iSpline]->GetKnot(iKnot, xPoint, yPoint);
      SplineInfoArray[iSpline].xPts[iKnot] = xPoint;
    }
    //ETA - let this just be set as the first segment by default
    SplineSegments[iSpline] = 0;
    ParamValues[iSpline] = 0.;
  }
  
  MACH3LOG_INFO("nUniqueSysts: {}", nParams);
  MACH3LOG_INFO("{:<15} | {:<20} | {:<6}", "Spline Index", "Syst Name", "nKnots");
  for (int iUniqueSyst = 0; iUniqueSyst < nParams; iUniqueSyst++)
  {
    MACH3LOG_INFO("{:<15} | {:<20} | {:<6}", iUniqueSyst, UniqueSystNames[iUniqueSyst], SplineInfoArray[iUniqueSyst].nPts);
  }
 
  int nCombinations_FlatSplines = 0;
  int nCombinations_All = 0;
  // DB Now actually loop over splines to determine which are all null i.e. flat
  for (unsigned int index = 0; index < IndexVect.size(); index++)
  {
    int splineindex = IndexVect[index].value;;
    nCombinations_All++;
    if (!splinevec_Monolith[splineindex]) {
      nCombinations_FlatSplines++;
    }
  }
 
  // We need to grab the maximum number of knots
  MACH3LOG_INFO("Number of combinations of Sample, OscChan, Syst and Mode which have entirely flat response: {} / {}", nCombinations_FlatSplines, nCombinations_All);
}

PrintArrayDetails()

void BinnedSplineHandler::PrintArrayDetails ( const std::string &  SampleTitle ) const

protected

Print info like Sample ID of spline params etc.

Definition at line 653 of file BinnedSplineHandler.cpp.

                                                                              {
//****************************************
  int iSample = GetSampleIndex(SampleTitle);
  // count oscillation channels
  std::map<int, std::set<int>> OscToSysts;
 
  for (const auto& entry : IndexVect) {
    if (entry.iSample != iSample) continue;
    OscToSysts[entry.iOscChan].insert(entry.iSyst);
  }
  MACH3LOG_INFO("Sample {} has {} oscillation channels", SampleTitle, OscToSysts.size());
 
  for (const auto& OscPair : OscToSysts) {
    int osc = OscPair.first;
    const std::set<int>& SystSet = OscPair.second;
    MACH3LOG_INFO("Oscillation channel {} has {} systematics", osc, SystSet.size());
  }
}

PrintBinning()

void BinnedSplineHandler::PrintBinning ( TAxis *  Axis ) const

protected

Print spline binning.

Definition at line 697 of file BinnedSplineHandler.cpp.

                                                        {
//****************************************
  const int NBins = Axis->GetNbins();
  std::string text = "";
  for (int iBin = 0; iBin <= NBins; iBin++) {
    text += fmt::format("{} ", Axis->GetXbins()->GetAt(iBin));
  }
  MACH3LOG_INFO("{}", text);
}

PrintSampleDetails()

void BinnedSplineHandler::PrintSampleDetails ( const std::string &  SampleTitle ) const

protected

Print info like Sample ID of spline params etc.

Definition at line 642 of file BinnedSplineHandler.cpp.

                                                                               {
//****************************************
  const int iSample = GetSampleIndex(SampleTitle);
 
  MACH3LOG_INFO("Details about sample: {:<20}", SampleTitles[iSample]);
  MACH3LOG_INFO("\t Dimension: {:<35}", Dimensions[iSample]);
  MACH3LOG_INFO("\t nSplineParam: {:<35}", nSplineParams[iSample]);
  MACH3LOG_INFO("\t nOscChan: {:<35}", nOscChans[iSample]);
}

RetPointer()

const M3::float_t * BinnedSplineHandler::RetPointer

(

const SplineIndex &

Variables

)

const

get pointer to spline weight based on bin variables

Definition at line 444 of file BinnedSplineHandler.cpp.

                                                                                   {
//****************************************
  int Index = IndexVectMap.at(std::make_tuple(Variables.iSample, Variables.iOscChan, Variables.iSyst,
                                              Variables.iMode, Variables.iVar[0], Variables.iVar[1], Variables.iVar[2]));
  return &weightvec_Monolith[IndexVect[Index].value];
}

StripDuplicatedModes()

std::vector< std::vector< int > > BinnedSplineHandler::StripDuplicatedModes ( const std::vector< std::vector< int > > &  InputVector ) const

protected

Creates an array to be filled with monolith indexes for each sample (allows for indexing between 7D binning and 1D Vector).

Check if there are any repeated modes. This is used to reduce the number of modes in case many interaction modes get averaged into one spline

Definition at line 767 of file BinnedSplineHandler.cpp.

                                                                                                                          {
//****************************************
  //ETA - this is of size nPars from the syst model
  size_t InputVectorSize = InputVector.size();
  std::vector< std::vector<int> > ReturnVec(InputVectorSize);
 
  //ETA - loop over all systematics
  for (size_t iSyst=0;iSyst<InputVectorSize;iSyst++) {
    std::vector<int> TmpVec;
    std::vector<std::string> TestVec;
 
    //Loop over the modes that we've listed in ParHandler
    for (unsigned int iMode = 0 ; iMode < InputVector[iSyst].size() ; iMode++) {
      int Mode = InputVector[iSyst][iMode];
      std::string ModeName = Modes->GetSplineSuffixFromMaCh3Mode(Mode);
 
      bool IncludeMode = true;
      for (auto TestString : TestVec) {
        if (ModeName == TestString) {
          IncludeMode = false;
          break;
        }
      }
 
      if (IncludeMode) {
        TmpVec.push_back(Mode);
        TestVec.push_back(ModeName);
      }
    }
 
    ReturnVec[iSyst] = TmpVec;
  }
  return ReturnVec;
}

SynchroniseMemTransfer()

void BinnedSplineHandler::SynchroniseMemTransfer ( ) const

inlinefinalvirtual

KS: After calculations are done on GPU we copy memory to CPU. This operation is asynchronous meaning while memory is being copied some operations are being carried. Memory must be copied before actual reweight. This function make sure all has been copied.

Note

now is empty but once we add GPU support it will actually do something

Implements SplineBase.

Definition at line 40 of file BinnedSplineHandler.h.

{return;}

TransferToMonolith()

void BinnedSplineHandler::TransferToMonolith

(

)

flatten multidimensional spline array into proper monolith

Definition at line 180 of file BinnedSplineHandler.cpp.

                                             {
//****************************************
  PrepForReweight(); 
  MonolithSize = CountNumberOfLoadedSplines(false, 1);
 
  if(MonolithSize != MonolithIndex){
    InvestigateMissingSplines();
    MACH3LOG_ERROR("Something's gone wrong when we tried to get the size of your monolith");
    MACH3LOG_ERROR("MonolithSize is {}", MonolithSize);
    MACH3LOG_ERROR("MonolithIndex is {}", MonolithIndex);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  MACH3LOG_INFO("Now transferring splines to a monolith if size {}", MonolithSize);
  // Maps single spline object with single parameter
  uniquesplinevec_Monolith.resize(MonolithSize);
  weightvec_Monolith.resize(MonolithSize);
  isflatarray = new bool[MonolithSize];
  
  xcoeff_arr = new M3::float_t[CoeffIndex];
  manycoeff_arr = new M3::float_t[CoeffIndex*_nCoeff_];
 
  for (const auto& entry : IndexVect) {
    int splineindex = entry.value;
    weightvec_Monolith[splineindex] = 1.0;
 
    bool foundUniqueSpline = false;
    // We are trying to match Spline Object with single parameter (like MAQE)
    for (int iUniqueSyst = 0; iUniqueSyst < nParams; iUniqueSyst++)
    {
      if (SplineFileParPrefixNames[entry.iSample][entry.iSyst] == UniqueSystNames[iUniqueSyst])
      {
        uniquesplinevec_Monolith[splineindex] = iUniqueSyst;
        foundUniqueSpline = true;
        break;
      }
    } //unique syst loop end
 
    // If current spline object hasn't been matched with actual parameter this means misconfiguration
    if (!foundUniqueSpline)
    {
      MACH3LOG_ERROR("Unique spline index not found");
      MACH3LOG_ERROR("For Spline {}", SplineFileParPrefixNames[entry.iSample][entry.iSyst]);
      MACH3LOG_ERROR("Couldn't match {} with any of the following {} systs:", SplineFileParPrefixNames[entry.iSample][entry.iSyst], nParams);
      for (int iUniqueSyst = 0; iUniqueSyst < nParams; iUniqueSyst++)
      {
        MACH3LOG_ERROR("{},", UniqueSystNames.at(iUniqueSyst));
      }//unique syst loop end
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
 
    int splineKnots;
    if(splinevec_Monolith[splineindex]){
      isflatarray[splineindex] = false;
      splineKnots=splinevec_Monolith[splineindex]->GetNp();
 
      //Now to fill up our coefficient arrayss
      M3::float_t* tmpXCoeffArr = new M3::float_t[splineKnots];
      M3::float_t* tmpManyCoeffArr = new M3::float_t[splineKnots*_nCoeff_];
 
      int iCoeff=coeffindexvec[splineindex];
      GetSplineCoeff_SepMany(splineindex, tmpXCoeffArr, tmpManyCoeffArr);
 
      for(int i = 0; i < splineKnots; i++){
        xcoeff_arr[iCoeff+i] = tmpXCoeffArr[i];
 
        for(int j = 0; j < _nCoeff_; j++){
          manycoeff_arr[(iCoeff+i)*_nCoeff_+j]=tmpManyCoeffArr[i*_nCoeff_+j];
        }
      }
      delete[] tmpXCoeffArr;
      delete[] tmpManyCoeffArr;
    } else {
      isflatarray[splineindex]=true;
    }
  }
}

Member Data Documentation

CoeffIndex

int BinnedSplineHandler::CoeffIndex

protected

Definition at line 125 of file BinnedSplineHandler.h.

coeffindexvec

std::vector<int > BinnedSplineHandler::coeffindexvec

protected

Number of coefficients for a single flat (after flattening)

Definition at line 116 of file BinnedSplineHandler.h.

DimensionLabels

std::vector<std::vector<std::string> > BinnedSplineHandler::DimensionLabels

protected

Definition at line 87 of file BinnedSplineHandler.h.

Dimensions

std::vector<int> BinnedSplineHandler::Dimensions

protected

Definition at line 86 of file BinnedSplineHandler.h.

GlobalSystIndex

std::vector< std::vector<int> > BinnedSplineHandler::GlobalSystIndex

protected

This holds the global spline index and is used to grab the current parameter value to evaluate splines at. Each internal vector will be of size of the number of spline systematics which affect that sample.

Definition at line 101 of file BinnedSplineHandler.h.

IndexVect

std::vector<SplineIndex> BinnedSplineHandler::IndexVect

protected

Variables related to determined which modes have splines and which piggy-back of other modes.

Definition at line 112 of file BinnedSplineHandler.h.

IndexVectMap

std::map<std::tuple<int, int, int, int, int, int, int>, int> BinnedSplineHandler::IndexVectMap

protected

Map between spline origin/properties (iSample, iOscChan, iSyst, iMode, iVar1, iVar2, iVar3) and the index of the spline in IndexVect.

Definition at line 114 of file BinnedSplineHandler.h.

isflatarray

bool* BinnedSplineHandler::isflatarray

protected

Need to keep track of which splines are flat and which aren't.

Definition at line 128 of file BinnedSplineHandler.h.

manycoeff_arr

M3::float_t* BinnedSplineHandler::manycoeff_arr

protected

ybcd coefficients for each spline

Definition at line 132 of file BinnedSplineHandler.h.

Modes

MaCh3Modes* BinnedSplineHandler::Modes

protected

pointer to MaCh3 Mode from which we get spline suffix

Definition at line 140 of file BinnedSplineHandler.h.

MonolithIndex

int BinnedSplineHandler::MonolithIndex

protected

Definition at line 124 of file BinnedSplineHandler.h.

MonolithSize

int BinnedSplineHandler::MonolithSize

protected

Definition at line 123 of file BinnedSplineHandler.h.

nOscChans

std::vector<int> BinnedSplineHandler::nOscChans

protected

Definition at line 89 of file BinnedSplineHandler.h.

nSplineParams

std::vector<int> BinnedSplineHandler::nSplineParams

protected

Definition at line 88 of file BinnedSplineHandler.h.

ParHandler

ParameterHandlerGeneric* BinnedSplineHandler::ParHandler

protected

Pointer to covariance from which we get information about spline params.

Definition at line 81 of file BinnedSplineHandler.h.

SampleNames

std::vector<std::string> BinnedSplineHandler::SampleNames

protected

Definition at line 84 of file BinnedSplineHandler.h.

SampleTitles

std::vector<std::string> BinnedSplineHandler::SampleTitles

protected

Definition at line 85 of file BinnedSplineHandler.h.

SplineBinning

std::vector< std::vector< std::vector<TAxis*> > > BinnedSplineHandler::SplineBinning

protected

Holds TAxis for [sample][channel][dimension].

Definition at line 91 of file BinnedSplineHandler.h.

SplineFileParPrefixNames

std::vector< std::vector<std::string> > BinnedSplineHandler::SplineFileParPrefixNames

protected

[Sample][Syst]

Definition at line 93 of file BinnedSplineHandler.h.

SplineInterpolationTypes

std::vector< std::vector<SplineInterpolation> > BinnedSplineHandler::SplineInterpolationTypes

protected

spline interpolation types for each sample. These vectors are from a call to GetSplineInterpolationFromSampleID()

Definition at line 104 of file BinnedSplineHandler.h.

SplineModeVecs

std::vector< std::vector< std::vector<int> > > BinnedSplineHandler::SplineModeVecs

protected

A vector of vectors of the spline modes that a systematic applies to This gets compared against the event mode to figure out if a syst should apply to an event or not

Definition at line 97 of file BinnedSplineHandler.h.

splinevec_Monolith

std::vector< TSpline3_red* > BinnedSplineHandler::splinevec_Monolith

protected

holds each spline object before stripping into coefficient monolith

Definition at line 121 of file BinnedSplineHandler.h.

uniquecoeffindices

std::vector<int> BinnedSplineHandler::uniquecoeffindices

protected

Unique coefficient indices.

Definition at line 118 of file BinnedSplineHandler.h.

uniquesplinevec_Monolith

std::vector<int> BinnedSplineHandler::uniquesplinevec_Monolith

protected

Maps single spline object with single parameter.

Definition at line 137 of file BinnedSplineHandler.h.

UniqueSystIndices

std::vector<int> BinnedSplineHandler::UniqueSystIndices

protected

Global index of each spline param, it allows us to match spline ordering with global.

Definition at line 109 of file BinnedSplineHandler.h.

UniqueSystNames

std::vector<std::string> BinnedSplineHandler::UniqueSystNames

protected

name of each spline parameter

Definition at line 107 of file BinnedSplineHandler.h.

weightvec_Monolith

std::vector<M3::float_t> BinnedSplineHandler::weightvec_Monolith

protected

Stores weight from spline evaluation for each single spline.

Definition at line 135 of file BinnedSplineHandler.h.

xcoeff_arr

M3::float_t* BinnedSplineHandler::xcoeff_arr

protected

x coefficients for each spline

Definition at line 130 of file BinnedSplineHandler.h.

---

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

• Splines/BinnedSplineHandler.h
• Splines/BinnedSplineHandler.cpp