4#pragma GCC diagnostic ignored "-Wuseless-cast"
5#pragma GCC diagnostic ignored "-Wfloat-conversion"
16 MACH3LOG_ERROR(
"Trying to create BinnedSplineHandler with uninitialized covariance object");
22 MACH3LOG_ERROR(
"Trying to create BinnedSplineHandler with uninitialized MaCh3Modes object");
64 const std::vector<std::string>& OscChanFileNames,
65 const std::vector<std::string>& SplineVarNames)
70 Dimensions.push_back(
int(SplineVarNames.size()));
90 MACH3LOG_INFO(
"SplineModeVecs_Sample is of size {}", SplineModeVecs_Sample.size());
95 int nOscChan = int(OscChanFileNames.size());
100 std::vector<std::vector<TAxis *>> SampleBinning(nOscChan);
101 for (
int iOscChan = 0; iOscChan < nOscChan; iOscChan++)
103 SampleBinning[iOscChan] =
FindSplineBinning(OscChanFileNames[iOscChan], SampleName);
105 MACH3LOG_INFO(
"#----------------------------------------------------------------------------------------------------------------------------------#");
110 MACH3LOG_INFO(
"#----------------------------------------------------------------------------------------------------------------------------------#");
113 MACH3LOG_INFO(
"#----------------------------------------------------------------------------------------------------------------------------------#");
124 MACH3LOG_ERROR(
"Something's gone wrong when we tried to get the size of your monolith");
139 for (
unsigned int iSample = 0; iSample <
indexvec.size(); iSample++)
141 for (
unsigned int iOscChan = 0; iOscChan <
indexvec[iSample].size(); iOscChan++)
143 for (
unsigned int iSyst = 0; iSyst <
indexvec[iSample][iOscChan].size(); iSyst++)
145 for (
unsigned int iMode = 0; iMode <
indexvec[iSample][iOscChan][iSyst].size(); iMode++)
147 for (
unsigned int iVar1 = 0; iVar1 <
indexvec[iSample][iOscChan][iSyst][iMode].size(); iVar1++)
149 for (
unsigned int iVar2 = 0; iVar2 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1].size(); iVar2++)
151 for (
unsigned int iVar3 = 0; iVar3 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2].size(); iVar3++)
153 int splineindex=
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2][iVar3];
156 bool foundUniqueSpline =
false;
157 for (
int iUniqueSyst = 0; iUniqueSyst <
nParams; iUniqueSyst++)
162 foundUniqueSpline =
true;
166 if (!foundUniqueSpline)
171 for (
int iUniqueSyst = 0; iUniqueSyst <
nParams; iUniqueSyst++)
190 for(
int i = 0; i < splineKnots; i++){
193 for(
int j=0; j<4; j++){
197 delete[] tmpXCoeffArr;
198 delete[] tmpManyCoeffArr;
231 #pragma omp parallel for simd
237 const short int currentsegment = short(
SplineSegments[uniqueIndex]);
240 const int coeffOffset = segCoeff * 4;
259 if(weight < 0){weight = 0.;}
276 indexvec.emplace_back(nOscChannels);
278 for (
int iOscChan = 0; iOscChan < nOscChannels; ++iOscChan)
280 indexvec.back()[iOscChan].resize(nSplineSysts);
281 for (
int iSyst = 0; iSyst < nSplineSysts; ++iSyst)
283 int nModesInSyst =
static_cast<int>(
SplineModeVecs[iSample][iSyst].size());
284 indexvec.back()[iOscChan][iSyst].resize(nModesInSyst);
286 for (
int iMode = 0; iMode < nModesInSyst; ++iMode)
288 const int nBins1 =
SplineBinning[iSample][iOscChan][0]->GetNbins();
289 const int nBins2 =
SplineBinning[iSample][iOscChan][1]->GetNbins();
290 const int nBins3 =
SplineBinning[iSample][iOscChan][2]->GetNbins();
292 indexvec.back()[iOscChan][iSyst][iMode]
293 .resize(nBins1,std::vector<std::vector<int>>(nBins2, std::vector<int>(nBins3, 0)));
303 std::vector<TAxis *> ReturnVec;
308 const double DummyEdges[2] = {-1e15, 1e15};
309 TAxis* DummyAxis =
new TAxis(nDummyBins, DummyEdges);
310 TH2F* Hist2D =
nullptr;
311 TH3F* Hist3D =
nullptr;
313 auto File = std::unique_ptr<TFile>(TFile::Open(FileName.c_str(),
"READ"));
314 if (!File || File->IsZombie())
317 MACH3LOG_ERROR(
"This is caused by something here! {} : {}", __FILE__, __LINE__);
324 std::string TemplateName =
"dev_tmp_0_0";
325 TObject *Obj = File->Get(TemplateName.c_str());
329 TemplateName =
"dev_tmp.0.0";
330 Obj = File->Get(TemplateName.c_str());
333 MACH3LOG_ERROR(
"Could not find dev_tmp_0_0 in spline file. Spline binning cannot be set!");
340 bool isHist2D = Obj->IsA() == TH2F::Class();
342 bool isHist3D = Obj->IsA() == TH3F::Class();
343 if (!isHist2D && !isHist3D)
345 MACH3LOG_ERROR(
"Object doesn't inherit from either TH2D and TH3D - Odd A");
356 Hist2D = File->Get<TH2F>(TemplateName.c_str());
361 Hist3D = File->Get<TH3F>((TemplateName.c_str()));
363 if (
Dimensions[iSample] != 3 && Hist3D->GetZaxis()->GetNbins() != 1)
368 Hist3D = File->Get<TH3F>(TemplateName.c_str());
373 ReturnVec.push_back(
static_cast<TAxis*
>(Hist2D->GetXaxis()->Clone()));
374 ReturnVec.push_back(
static_cast<TAxis*
>(Hist2D->GetYaxis()->Clone()));
375 ReturnVec.push_back(
static_cast<TAxis*
>(DummyAxis->Clone()));
376 }
else if (isHist3D) {
377 ReturnVec.push_back(
static_cast<TAxis*
>(Hist3D->GetXaxis()->Clone()));
378 ReturnVec.push_back(
static_cast<TAxis*
>(Hist3D->GetYaxis()->Clone()));
379 ReturnVec.push_back(
static_cast<TAxis*
>(DummyAxis->Clone()));
382 ReturnVec.push_back(
static_cast<TAxis*
>(Hist3D->GetXaxis()->Clone()));
383 ReturnVec.push_back(
static_cast<TAxis*
>(Hist3D->GetYaxis()->Clone()));
384 ReturnVec.push_back(
static_cast<TAxis*
>(Hist3D->GetZaxis()->Clone()));
390 for (
unsigned int iAxis = 0; iAxis < ReturnVec.size(); ++iAxis) {
404 int SampleCounter_NonFlat = 0;
405 int SampleCounter_All = 0;
406 int FullCounter_NonFlat = 0;
407 int FullCounter_All = 0;
409 for (
unsigned int iSample = 0; iSample <
indexvec.size(); iSample++)
411 SampleCounter_NonFlat = 0;
412 SampleCounter_All = 0;
414 for (
unsigned int iOscChan = 0; iOscChan <
indexvec[iSample].size(); iOscChan++)
416 for (
unsigned int iSyst = 0; iSyst <
indexvec[iSample][iOscChan].size(); iSyst++)
418 for (
unsigned int iMode = 0; iMode <
indexvec[iSample][iOscChan][iSyst].size(); iMode++)
420 for (
unsigned int iVar1 = 0; iVar1 <
indexvec[iSample][iOscChan][iSyst][iMode].size(); iVar1++)
422 for (
unsigned int iVar2 = 0; iVar2 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1].size(); iVar2++)
424 for (
unsigned int iVar3 = 0; iVar3 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2].size(); iVar3++)
428 int splineindex =
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2][iVar3];
431 SampleCounter_NonFlat += 1;
433 SampleCounter_All += 1;
441 MACH3LOG_DEBUG(
"{:<10} has {:<10} splines, of which {:<10} are not flat",
SampleNames[iSample], SampleCounter_All, SampleCounter_NonFlat);
443 FullCounter_NonFlat += SampleCounter_NonFlat;
444 FullCounter_All += SampleCounter_All;
449 MACH3LOG_INFO(
"Total number of splines loaded: {}", FullCounter_All);
450 MACH3LOG_INFO(
"Total number of non-flat splines loaded: {}", FullCounter_NonFlat);
454 return FullCounter_NonFlat;
456 return FullCounter_All;
463 std::vector<TSpline3_red*> UniqueSystSplines;
468 for (
unsigned int iSample = 0; iSample <
indexvec.size(); iSample++)
470 for (
unsigned int iSyst = 0; iSyst <
indexvec[iSample][0].size(); iSyst++)
473 bool FoundSyst =
false;
477 for (
unsigned int iFoundSyst = 0; iFoundSyst <
UniqueSystNames.size(); iFoundSyst++)
486 bool FoundNonFlatSpline =
false;
489 for (
unsigned int iOscChan = 0; iOscChan <
indexvec[iSample].size(); iOscChan++)
491 for (
unsigned int iMode = 0; iMode <
indexvec[iSample][iOscChan][iSyst].size(); iMode++)
493 for (
unsigned int iVar1 = 0; iVar1 <
indexvec[iSample][iOscChan][iSyst][iMode].size(); iVar1++)
495 for (
unsigned int iVar2 = 0; iVar2 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1].size(); iVar2++)
497 for (
unsigned int iVar3 = 0; iVar3 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2].size(); iVar3++)
499 int splineindex=
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2][iVar3];
504 FoundNonFlatSpline =
true;
506 if (FoundNonFlatSpline) {
break;}
508 if (FoundNonFlatSpline) {
break;}
510 if (FoundNonFlatSpline){
break; }
512 if (FoundNonFlatSpline){
break; }
514 if (FoundNonFlatSpline) {
break; }
517 if(FoundNonFlatSpline){
521 if (!FoundNonFlatSpline)
523 MACH3LOG_INFO(
"{} syst has no response in sample {}", SystName, iSample);
524 MACH3LOG_INFO(
"Whilst this isn't necessarily a problem, it seems odd");
531 nParams =
static_cast<short int>(UniqueSystSplines.size());
537 for (
int iSpline = 0; iSpline <
nParams; iSpline++)
546 UniqueSystSplines[iSpline]->GetKnot(iKnot, xPoint, yPoint);
555 MACH3LOG_INFO(
"{:<15} | {:<20} | {:<6}",
"Spline Index",
"Syst Name",
"nKnots");
556 for (
int iUniqueSyst = 0; iUniqueSyst <
nParams; iUniqueSyst++)
563 int nCombinations_FlatSplines = 0;
564 int nCombinations_All = 0;
566 for (
unsigned int iSample = 0; iSample <
indexvec.size(); iSample++)
568 for (
unsigned int iOscChan = 0; iOscChan <
indexvec[iSample].size(); iOscChan++)
570 for (
unsigned int iSyst = 0; iSyst <
indexvec[iSample][iOscChan].size(); iSyst++)
572 for (
unsigned int iMode = 0; iMode <
indexvec[iSample][iOscChan][iSyst].size(); iMode++)
575 for (
unsigned int iVar1 = 0; iVar1 <
indexvec[iSample][iOscChan][iSyst][iMode].size(); iVar1++)
577 for (
unsigned int iVar2 = 0; iVar2 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1].size(); iVar2++)
579 for (
unsigned int iVar3 = 0; iVar3 <
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2].size(); iVar3++)
581 int splineindex=
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2][iVar3];
584 nCombinations_All += 1;
586 nCombinations_FlatSplines += 1;
587 nCombinations_All += 1;
597 MACH3LOG_INFO(
"Number of combinations of Sample, OscChan, Syst and Mode which have entirely flat response: {} / {}", nCombinations_FlatSplines, nCombinations_All);
607 for (
int i = 0; i < nPoints; i++) {
609 for (
int j = 0; j < 4; j++) {
610 manyArray[i*4+j] = 1.0;
614 for(
int i=0; i<nPoints; i++) {
626 manyArray[i*4+1] = b;
627 manyArray[i*4+2] = c;
628 manyArray[i*4+3] = d;
641 if(Axis > DimensionLabels[iSample].
size()){
642 MACH3LOG_ERROR(
"The spline Axis you are trying to get the label of is larger than the number of dimensions");
643 MACH3LOG_ERROR(
"You are trying to get axis {} but have only got {}", Axis, Dimensions[iSample]);
646 return DimensionLabels.at(iSample).at(Axis);
653 for (
size_t iSample = 0; iSample <
SampleNames.size(); ++iSample) {
655 return static_cast<int>(iSample);
666 const int iSample = getSampleIndex(SampleName);
668 MACH3LOG_INFO(
"Details about sample: {:<20}", SampleNames[iSample]);
670 MACH3LOG_INFO(
"\t nSplineParam: {:<35}", nSplineParams[iSample]);
678 int iSample = getSampleIndex(SampleName);
679 int nOscChannels = int(indexvec[iSample].
size());
680 MACH3LOG_INFO(
"Sample {} has {} oscillation channels", SampleName, nOscChannels);
682 for (
int iOscChan = 0; iOscChan < nOscChannels; iOscChan++)
684 int nSysts = int(indexvec[iSample][iOscChan].
size());
685 MACH3LOG_INFO(
"Oscillation channel {} has {} systematics", iOscChan, nSysts);
688 MACH3LOG_INFO(
"#----------------------------------------------------------------------------------------------------------------------------------#");
689 MACH3LOG_INFO(
"Printing no. of modes affected by each systematic for each oscillation channel");
690 for (
unsigned int iOscChan = 0; iOscChan < indexvec[iSample].size(); iOscChan++) {
691 std::string modes = fmt::format(
"OscChan: {}\t", iOscChan);
692 for (
unsigned int iSyst = 0; iSyst < indexvec[iSample][iOscChan].size(); iSyst++) {
693 modes += fmt::format(
"{} ", indexvec[iSample][iOscChan][iSyst].
size());
697 MACH3LOG_INFO(
"#----------------------------------------------------------------------------------------------------------------------------------#");
708 auto checkIndex = [&isValid](
int index,
size_t size,
const std::string& name) {
709 if (index < 0 || index >=
int(
size)) {
715 checkIndex(iSample,
indexvec.size(),
"Sample");
716 if (isValid) checkIndex(iOscChan,
indexvec[iSample].
size(),
"OscChan");
717 if (isValid) checkIndex(iSyst,
indexvec[iSample][iOscChan].
size(),
"Syst");
718 if (isValid) checkIndex(iMode,
indexvec[iSample][iOscChan][iSyst].
size(),
"Mode");
719 if (isValid) checkIndex(iVar1,
indexvec[iSample][iOscChan][iSyst][iMode].
size(),
"Var1");
720 if (isValid) checkIndex(iVar2,
indexvec[iSample][iOscChan][iSyst][iMode][iVar1].
size(),
"Var2");
721 if (isValid) checkIndex(iVar3,
indexvec[iSample][iOscChan][iSyst][iMode][iVar1][iVar2].
size(),
"Var3");
743 const int NBins = Axis->GetNbins();
744 std::string text =
"";
745 for (
int iBin = 0; iBin <= NBins; iBin++) {
746 text += fmt::format(
"{} ", Axis->GetXbins()->GetAt(iBin));
755 std::vector<std::vector<int>> ReturnVec;
756 int SampleIndex = -1;
757 for (
unsigned int iSample = 0; iSample <
SampleNames.size(); iSample++) {
759 SampleIndex = iSample;
763 if (SampleIndex == -1) {
768 int nSplineSysts =
static_cast<int>(
indexvec[SampleIndex][iOscChan].size());
783 int Var1Bin =
SplineBinning[SampleIndex][iOscChan][0]->FindBin(Var1Val)-1;
784 if (Var1Bin < 0 || Var1Bin >=
SplineBinning[SampleIndex][iOscChan][0]->GetNbins()) {
788 int Var2Bin =
SplineBinning[SampleIndex][iOscChan][1]->FindBin(Var2Val)-1;
789 if (Var2Bin < 0 || Var2Bin >=
SplineBinning[SampleIndex][iOscChan][1]->GetNbins()) {
793 int Var3Bin =
SplineBinning[SampleIndex][iOscChan][2]->FindBin(Var3Val)-1;
794 if (Var3Bin < 0 || Var3Bin >=
SplineBinning[SampleIndex][iOscChan][2]->GetNbins()){
798 for(
int iSyst=0; iSyst<nSplineSysts; iSyst++){
799 std::vector<int> spline_modes =
SplineModeVecs[SampleIndex][iSyst];
800 int nSampleModes =
static_cast<int>(spline_modes.size());
803 for(
int iMode = 0; iMode<nSampleModes ; iMode++){
805 if (Mode == spline_modes[iMode]) {
806 int splineID=
indexvec[SampleIndex][iOscChan][iSyst][iMode][Var1Bin][Var2Bin][Var3Bin];
809 ReturnVec.push_back({SampleIndex, iOscChan, iSyst, iMode, Var1Bin, Var2Bin, Var3Bin});
823 size_t InputVectorSize = InputVector.size();
824 std::vector< std::vector<int> > ReturnVec(InputVectorSize);
827 for (
size_t iSyst=0;iSyst<InputVectorSize;iSyst++) {
828 std::vector<int> TmpVec;
829 std::vector<std::string> TestVec;
832 for (
unsigned int iMode = 0 ; iMode < InputVector[iSyst].size() ; iMode++) {
833 int Mode = InputVector[iSyst][iMode];
836 bool IncludeMode =
true;
837 for (
auto TestString : TestVec) {
838 if (ModeName == TestString) {
845 TmpVec.push_back(Mode);
846 TestVec.push_back(ModeName);
850 ReturnVec[iSyst] = TmpVec;
860 for (
int iOscChan = 0; iOscChan < nOscChannels; iOscChan++) {
862 TSpline3* mySpline =
nullptr;
865 int nKnots, SystNum, ModeNum, Var1Bin, Var2Bin, Var3Bin =
M3::_BAD_INT_;
869 std::set<std::string> SplineFileNames;
871 auto File = std::unique_ptr<TFile>(TFile::Open(OscChanFileNames[iOscChan].c_str()));
873 if (!File || File->IsZombie()) {
880 for (
auto k : *File->GetListOfKeys()) {
881 auto Key =
static_cast<TKey*
>(k);
882 TClass *Class = gROOT->GetClass(Key->GetClassName(),
false);
883 if(!Class->InheritsFrom(
"TSpline3")) {
887 std::string FullSplineName = std::string(Key->GetName());
889 if (SplineFileNames.count(FullSplineName) > 0) {
890 MACH3LOG_CRITICAL(
"Skipping spline - Found a spline whose name has already been encountered before: {}", FullSplineName);
893 SplineFileNames.insert(FullSplineName);
898 MACH3LOG_ERROR(
"Invalid tokens from spline name - Expected {} tokens. Check implementation in GetTokensFromSplineName()",
static_cast<int>(
kNTokens));
919 MACH3LOG_DEBUG(
"Couldn't Match any systematic name in ParameterHandler with spline name: {}" , FullSplineName);
924 for (
unsigned int iMode = 0; iMode <
SplineModeVecs[iSample][SystNum].size(); iMode++) {
934 MACH3LOG_DEBUG(
"Couldn't find mode for {} in {}. Problem Spline is : {} ", Mode, Syst, FullSplineName);
938 mySpline = Key->ReadObject<TSpline3>();
940 if (
isValidSplineIndex(SampleName, iOscChan, SystNum, ModeNum, Var1Bin, Var2Bin, Var3Bin)) {
941 MACH3LOG_DEBUG(
"Pushed back monolith for spline {}", FullSplineName);
943 nKnots = mySpline->GetNp();
945 for (
int iKnot = 0; iKnot < nKnots; iKnot++) {
946 mySpline->GetKnot(iKnot, x, y);
947 if (y < 0.99999 || y > 1.00001)
964 if(mySpline)
delete mySpline;
#define _MaCh3_Safe_Include_Start_
KS: Avoiding warning checking for headers.
#define _MaCh3_Safe_Include_End_
KS: Restore warning checking after including external headers.
std::vector< bool > isFlat
#define MACH3LOG_CRITICAL
void CleanVector(std::vector< T > &vec)
Generic cleanup function.
void CleanContainer(std::vector< T * > &container)
Generic cleanup function.
void ApplyKnotWeightCapTSpline3(TSpline3 *&Spline, const int splineParsIndex, ParameterHandlerGeneric *XsecCov)
EM: Apply capping to knot weight for specified spline parameter. param graph needs to have been set i...
void getSplineCoeff_SepMany(int splineindex, M3::float_t *&xArray, M3::float_t *&manyArray)
std::string getDimLabel(const int BinningOpt, const unsigned int Axis) const
void Evaluate()
CW: This Eval should be used when using two separate x,{y,a,b,c,d} arrays to store the weights; proba...
bool * isflatarray
Need to keep track of which splines are flat and which aren't.
int CountNumberOfLoadedSplines(bool NonFlat=false, int Verbosity=0)
std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< int > > > > > > > indexvec
Variables related to determined which modes have splines and which piggy-back of other modes.
std::vector< std::vector< std::string > > SplineFileParPrefixNames
void CalcSplineWeights() override
CPU based code which eval weight for each spline.
std::vector< std::vector< int > > GetEventSplines(const std::string &SampleName, int iOscChan, int EventMode, double Var1Val, double Var2Val, double Var3Val)
Return the splines which affect a given event.
std::vector< int > coeffindexvec
void cleanUpMemory()
Remove setup variables not needed for spline evaluations.
void PrintBinning(TAxis *Axis) const
ParameterHandlerGeneric * xsec
Pointer to covariance from which we get information about spline params.
virtual std::vector< std::string > GetTokensFromSplineName(std::string FullSplineName)=0
std::vector< TAxis * > FindSplineBinning(const std::string &FileName, const std::string &SampleName)
Grab histograms with spline binning.
std::vector< int > nSplineParams
void ModifyWeights() override
Calc total event weight, not used by Bin-by-bin splines.
std::vector< std::vector< std::vector< int > > > SplineModeVecs
std::vector< int > nOscChans
M3::float_t * xcoeff_arr
x coefficients for each spline
std::vector< std::string > UniqueSystNames
name of each spline parameter
int getSampleIndex(const std::string &SampleName) const
Get index of sample based on name.
void AddSample(const std::string &SampleName, const std::vector< std::string > &OscChanFileNames, const std::vector< std::string > &SplineVarNames)
add oscillation channel to spline monolith
std::vector< std::vector< SplineInterpolation > > SplineInterpolationTypes
spline interpolation types for each sample. These vectors are from a call to GetSplineInterpolationFr...
std::vector< int > Dimensions
std::vector< int > uniquesplinevec_Monolith
Maps single spline object with single parameter.
void PrintArrayDetails(const std::string &SampleName) const
std::vector< std::vector< int > > StripDuplicatedModes(const std::vector< std::vector< int > > &InputVector)
Check if there are any repeated modes. This is used to reduce the number of modes in case many intera...
std::vector< M3::float_t > weightvec_Monolith
Stores weight from spline evaluation for each single spline.
void BuildSampleIndexingArray(const std::string &SampleName)
std::vector< std::vector< std::string > > DimensionLabels
BinnedSplineHandler(ParameterHandlerGeneric *xsec_, MaCh3Modes *Modes_)
Constructor.
std::vector< std::vector< std::vector< TAxis * > > > SplineBinning
virtual void FillSampleArray(std::string SampleName, std::vector< std::string > OscChanFileNames)
Loads and processes splines from ROOT files for a given sample.
std::vector< TSpline3_red * > splinevec_Monolith
holds each spline object before stripping into coefficient monolith
std::vector< int > uniquecoeffindices
Unique coefficient indices.
MaCh3Modes * Modes
pointer to MaCh3 Mode from which we get spline suffix
std::vector< std::vector< int > > GlobalSystIndex
This holds the global spline index and is used to grab the current parameter value to evaluate spline...
void PrintSampleDetails(const std::string &SampleName) const
Print info like Sample ID of spline params etc.
virtual ~BinnedSplineHandler()
Destructor.
std::vector< std::string > SampleNames
void TransferToMonolith()
flatten multidimensional spline array into proper monolith
std::vector< int > UniqueSystIndices
Global index of each spline param, it allows us to match spline ordering with global.
bool isValidSplineIndex(const std::string &SampleName, int iSyst, int iOscChan, int iMode, int iVar1, int iVar2, int iVar3)
Ensure we have spline for a given bin.
M3::float_t * manycoeff_arr
ybcd coefficients for each spline
Custom exception class for MaCh3 errors.
KS: Class describing MaCh3 modes used in the analysis, it is being initialised from config.
int GetNModes() const
KS: Get number of modes, keep in mind actual number is +1 greater due to unknown category.
std::string GetSplineSuffixFromMaCh3Mode(const int Index)
DB: Get binned spline mode suffic from MaCh3 Mode.
const double * RetPointer(const int iParam)
DB Pointer return to param position.
Class responsible for handling of systematic error parameters with different types defined in the con...
Base class for calculating weight from spline.
short int nParams
Number of parameters that have splines.
void FindSplineSegment()
CW:Code used in step by step reweighting, Find Spline Segment for each param.
short int * SplineSegments
std::vector< FastSplineInfo > SplineInfoArray
float * ParamValues
Store parameter values they are not in FastSplineInfo as in case of GPU we need to copy paste it to G...
CW: Reduced TSpline3 class.
const std::vector< int > GetGlobalSystIndexFromSampleName(const std::string &SampleName, const SystType Type)
DB Get spline parameters depending on given SampleName.
int GetNumParamsFromSampleName(const std::string &SampleName, const SystType Type)
DB Grab the number of parameters for the relevant SampleName.
const std::vector< std::string > GetSplineParsNamesFromSampleName(const std::string &SampleName)
DB Get spline parameters depending on given SampleName.
const std::vector< SplineInterpolation > GetSplineInterpolationFromSampleName(const std::string &SampleName)
Get the interpolation types for splines affecting a particular SampleName.
const std::vector< std::vector< int > > GetSplineModeVecFromSampleName(const std::string &SampleName)
DB Grab the Spline Modes for the relevant SampleName.
static constexpr const double _BAD_DOUBLE_
Default value used for double initialisation.
constexpr T fmaf_t(T x, T y, T z)
Function template for fused multiply-add.
static constexpr const int _BAD_INT_
Default value used for int initialisation.