Base class for calculating weight from spline. More...

#include <Splines/SplineBase.h>

Inheritance diagram for SplineBase:

Collaboration diagram for SplineBase:

Public Member Functions
	SplineBase (const bool Use_GPU=true)
	Constructor. More...

virtual	~SplineBase ()
	Destructor. More...

virtual void	Evaluate ()=0
	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...

virtual std::string	GetName () const
	Get class name. More...

short int	GetNParams () const
	Get number of spline parameters. More...

virtual void	PrepareSplineFile (std::string FileName)=0
	KS: Prepare spline file that can be used for fast loading. More...

virtual void	LoadSplineFile (std::string FileName)=0
	KS: Load preprocessed spline file. More...

void	SynchroniseMemTransfer () const
	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...

Protected Member Functions
void	FindSplineSegment ()
	CW:Code used in step by step reweighting, Find Spline Segment for each param. More...

virtual void	CalcSplineWeights ()=0
	CPU based code which eval weight for each spline. 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...

void	SetupSegments ()
	Since we find segment before actual reweight and sometimes we want to copy it to GPU we have different functionality depending if GPU or CPU. More...

Protected Attributes
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...

short int	_max_knots
	Max knots for production. More...

unsigned int	NSplines_valid
	Number of valid splines. More...

SplineMonolithGPU *	gpu_monolith
	KS: Store info about Spline monolith, this allow to obtain better step time. As all necessary information for spline weight calculation are here meaning better cache hits. More...

bool	useGPU
	Whether to use GPU or not. More...

Private Member Functions
void	CheckSegmentValidity (const M3::int_t i, const M3::int_t segment, const M3::float_t xvar, const std::vector< M3::float_t > &xPts) const
	Validates that the spline segment is correct for the given variation. More...

Detailed Description

Base class for calculating weight from spline.

Author: Dan Barrow; Kamil Skwarczynski

Definition at line 30 of file SplineBase.h.

Constructor & Destructor Documentation

◆ SplineBase()

SplineBase::SplineBase ( const bool Use_GPU = true )

Constructor.

Definition at line 11 of file SplineBase.cpp.

                                                     {
 // *****************************************
   #ifdef MaCh3_CUDA
   useGPU = Use_GPU;
   if(useGPU) MACH3LOG_INFO("Using GPU version of {}", GetName());
   gpu_monolith = nullptr;
   #else
   // if we don't have GPU simply
   useGPU = false;
   #endif
  
   NSplines_valid = 0;
   nParams = 0;
   _max_knots = 0;
   SplineSegments = nullptr;
   ParamValues = nullptr;
 }

◆ ~SplineBase()

SplineBase::~SplineBase ( )

virtual

Destructor.

Definition at line 30 of file SplineBase.cpp.

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

Member Function Documentation

◆ CalcSplineWeights()

virtual void SplineBase::CalcSplineWeights ( )

protectedpure virtual

CPU based code which eval weight for each spline.

Splines are stored using a flat monolithic structure. The monolith is organised as follows:

Spline 0
  Segment 0: [ Y | B | C | D ]
  Segment 1: [ Y | B | C | D ]
  Segment 2: [ Y | B | C | D ]
 
Spline 1
  Segment 0: [ Y | B | C | D ]
  Segment 1: [ Y | B | C | D ]
  Segment 2: [ Y | B | C | D ]
 
Spline 2
  Segment 0: [ Y | B | C | D ]
  Segment 1: [ Y | B | C | D ]
  Segment 2: [ Y | B | C | D ]
  ...

Once coefficient are grabbed we calculate weight using:

weight = Y + B*dx + C*dx^2 + D*dx^3;

Implemented in PySplineBase, UnbinnedSplineHandler, and BinnedSplineHandler.

◆ CheckSegmentValidity()

void SplineBase::CheckSegmentValidity	(	const M3::int_t	i,
		const M3::int_t	segment,
		const M3::float_t	xvar,
		const std::vector< M3::float_t > &	xPts
	)		const

private

Validates that the spline segment is correct for the given variation.

Parameters

i	Index of the spline in SplineInfoArray.
segment	The segment index to validate.
xvar	The variation value being checked.
xPts	The array of x-values for the spline.

Definition at line 35 of file SplineBase.cpp.

                                                                               {
 // *************************
   if (xPts[segment] > xvar && segment != 0) {
     MACH3LOG_ERROR("Found a segment which is _ABOVE_ the variation!");
     MACH3LOG_ERROR("IT SHOULD ALWAYS BE BELOW! (except when segment 0)");
     MACH3LOG_ERROR("Spline: {}", i);
     MACH3LOG_ERROR("Found segment = {}", segment);
     MACH3LOG_ERROR("Doing variation = {}", xvar);
     MACH3LOG_ERROR("x in spline = {}", xPts[segment]);
     for (size_t j = 0; j < xPts.size(); ++j) {
       MACH3LOG_ERROR("    {} = {}", j, xPts[j]);
     }
     throw MaCh3Exception(__FILE__, __LINE__);
   }
 }

◆ Evaluate()

virtual void SplineBase::Evaluate ( )

pure virtual

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.

Implemented in PySplineBase, UnbinnedSplineHandler, and BinnedSplineHandler.

◆ FindSplineSegment()

void SplineBase::FindSplineSegment ( )

protected

CW:Code used in step by step reweighting, Find Spline Segment for each param.

Definition at line 58 of file SplineBase.cpp.

                                    {
 // *************************
   // Loop over the splines
   //KS: Tried multithreading here with 48 splines and it is faster with one thread, maybe in future multithreading will be worth revisiting
   for (M3::int_t i = 0; i < nParams; ++i)
   {
     const M3::int_t nPoints = SplineInfoArray[i].nPts;
     const std::vector<M3::float_t>& xArray = SplineInfoArray[i].xPts;
  
     // Get the variation for this reconfigure for the ith parameter
     const float xvar = float(*SplineInfoArray[i].splineParsPointer);
     ParamValues[i] = xvar;
  
     // EM: if we have a parameter that has no response for any event (i.e. all splines have just one knot), then skip it and avoid a seg fault here
     //     In principle, such parameters shouldn't really be included in the first place, but with new det syst splines this
     //     could happen if say you were just running on one FHC run, then all RHC parameters would be flat and the code below would break.
     if(xArray.size() == 0) continue;
  
     // The segment we're interested in (klow in ROOT code)
     M3::int_t segment = 0;
     M3::int_t kHigh = nPoints-1;
     //KS: We expect new segment is very close to previous
     const M3::int_t PreviousSegment = SplineInfoArray[i].CurrSegment;
  
     // If the variation is below the lowest saved spline point
     if (xvar <= xArray[0]) {
       segment = 0;
       // If the variation is above the highest saved spline point
     } else if (xvar >= xArray[nPoints-1]) {
       //CW: Yes, the -2 is indeed correct, see TSpline.cxx:814 and //see: https://savannah.cern.ch/bugs/?71651
       segment = kHigh;
       //KS: It is quite probable the new segment is same as in previous step so try to avoid binary search, first we have to check if it is in bounds to avoid seg fault
     } else if( xArray[PreviousSegment+1] > xvar && xvar >= xArray[PreviousSegment] ) {
       segment = PreviousSegment;
       // If the variation is between the maximum and minimum, perform a binary search
     } else {
       // The top point we've got
       M3::int_t kHalf = 0;
       // While there is still a difference in the points (we haven't yet found the segment)
       // This is a binary search, incrementing segment and decrementing kHalf until we've found the segment
       while (kHigh - segment > 1) {
         // Increment the half-step
         kHalf = M3::int_t((segment + kHigh)/2);
         // If our variation is above the kHalf, set the segment to kHalf
         if (xvar > xArray[kHalf]) {
           segment = kHalf;
           // Else move kHigh down
         } else {
           kHigh = kHalf;
         }
       } // End the while: we've now done our binary search
     } // End the else: we've now found our point
  
     if (segment >= nPoints-1 && nPoints > 1) segment = nPoints-2;
  
     // CW: This way we avoid doing 1.2M+ binary searches on the GPU
     // and literally just multiply lots of numbers together on the GPU without any algorithm
     // Update the values and which segment it belongs to
     SplineInfoArray[i].CurrSegment = segment;
     SplineSegments[i] = short(SplineInfoArray[i].CurrSegment);
  
     #ifdef MACH3_DEBUG
     CheckSegmentValidity(i, segment, xvar, SplineInfoArray[i].xPts);
     #endif
   } //end loop over params
 }

◆ GetName()

virtual std::string SplineBase::GetName ( ) const

inlinevirtual

Get class name.

Reimplemented in UnbinnedSplineHandler, and PySplineBase.

Definition at line 41 of file SplineBase.h.

41 {return "SplineBase";};

◆ GetNParams()

short int SplineBase::GetNParams ( ) const

inline

Get number of spline parameters.

Definition at line 44 of file SplineBase.h.

44 {return nParams;};

◆ GetTF1Coeff()

void SplineBase::GetTF1Coeff	(	TF1_red *&	spl,
		int &	nPoints,
		float *&	coeffs
	)		const

protected

CW: Gets the polynomial coefficients for TF1.

Parameters

spl	pointer to TF1_red that will be checked
nPoints	number of knots
coeffs	Array holding coefficients for each knot

Definition at line 129 of file SplineBase.cpp.

                                                                                {
 // *****************************************
   // Initialise all arrays to 1.0
   for (int i = 0; i < _nTF1Coeff_; ++i) {
     coeffs[i] = 0.0;
   }
  
   // Get number of points in spline
   nPoints = spl->GetSize();
  
   if(nPoints > _nTF1Coeff_)
   {
     MACH3LOG_ERROR("Too big number of points for TF1");
     throw MaCh3Exception(__FILE__ , __LINE__ );
   }
   // TSpline3 can only take doubles, not floats
   // But our GPU is slow with doubles, so need to cast to float
   for (int i = 0; i < nPoints; i++) {
     coeffs[i] = float(spl->GetParameter(M3::int_t(i)));
   }
   // The structure is now coeffs  = {a,b,c,d,e}
 }

◆ LoadFastSplineInfoDir()

void SplineBase::LoadFastSplineInfoDir ( std::unique_ptr< TFile > & SplineFile )

protected

KS: Load preprocessed FastSplineInfo.

Parameters

File	File from which we load new tree

Definition at line 181 of file SplineBase.cpp.

                                                                        {
 // *****************************************
   TTree *FastSplineInfoTree = SplineFile->Get<TTree>("FastSplineInfoTree");
   M3::int_t nPoints = 0;
   float xtemp[20];
   FastSplineInfoTree->SetBranchAddress("nPts", &nPoints);
   FastSplineInfoTree->SetBranchAddress("xPts", &xtemp);
  
   if(nParams == 0){
     MACH3LOG_WARN("Calling {} with {} number of params", __func__, nParams);
   }
   SplineInfoArray.resize(nParams);
   for (M3::int_t i = 0; i < nParams; ++i) {
     FastSplineInfoTree->GetEntry(i);
  
     // Fill the number of points
     SplineInfoArray[i].nPts = nPoints;
     if(nPoints == -999) continue;
     SplineInfoArray[i].xPts.resize(SplineInfoArray[i].nPts);
     for (M3::int_t k = 0; k < SplineInfoArray[i].nPts; ++k)
     {
       SplineInfoArray[i].xPts[k] = xtemp[k];
     }
   }
 }

◆ LoadSplineFile()

virtual void SplineBase::LoadSplineFile ( std::string FileName )

pure virtual

KS: Load preprocessed spline file.

Parameters

FileName Path to ROOT file with predefined reduced Spline Monolith

Implemented in UnbinnedSplineHandler, and BinnedSplineHandler.

◆ PrepareFastSplineInfoDir()

void SplineBase::PrepareFastSplineInfoDir ( std::unique_ptr< TFile > & SplineFile ) const

protected

KS: Prepare Fast Spline Info within SplineFile.

Parameters

File	File to which we add new tree

Definition at line 153 of file SplineBase.cpp.

                                                                                 {
 // *****************************************
   TTree *FastSplineInfoTree = new TTree("FastSplineInfoTree", "FastSplineInfoTree");
  
   M3::int_t nPoints = 0;
   float xtemp[20];
   FastSplineInfoTree->Branch("nPts", &nPoints, "nPts/I");
   FastSplineInfoTree->Branch("xPts", xtemp, "xPts[nPts]/F");
  
   for (M3::int_t i = 0; i < nParams; ++i)
   {
     nPoints = SplineInfoArray[i].nPts;
  
     for (M3::int_t k = 0; k < SplineInfoArray[i].nPts; ++k)
     {
       xtemp[k] = float(SplineInfoArray[i].xPts[k]);
     }
     FastSplineInfoTree->Fill();
   }
  
   SplineFile->cd();
   FastSplineInfoTree->Write();
  
   delete FastSplineInfoTree;
 }

◆ PrepareSplineFile()

virtual void SplineBase::PrepareSplineFile ( std::string FileName )

pure virtual

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

Implemented in UnbinnedSplineHandler, and BinnedSplineHandler.

◆ SetupSegments()

void SplineBase::SetupSegments ( )

protected

Since we find segment before actual reweight and sometimes we want to copy it to GPU we have different functionality depending if GPU or CPU.

Definition at line 208 of file SplineBase.cpp.

                                {
 // *****************************************
   //KS: Since we are going to copy it each step use fancy CUDA memory allocation
   #ifdef MaCh3_CUDA
   if (useGPU) {
     gpu_monolith->InitGPU_Segments(&SplineSegments);
     gpu_monolith->InitGPU_Vals(&ParamValues);
   } else
   #endif
   {
     SplineSegments = new short int[nParams]();
     ParamValues = new float[nParams]();
   }
   //ETA - let this just be set as the first segment by default
   for (M3::int_t j = 0; j < nParams; j++)
   {
     SplineSegments[j] = 0;
     ParamValues[j] = -999;
   }
 }

◆ SynchroniseMemTransfer()

void SplineBase::SynchroniseMemTransfer ( ) const

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.

Definition at line 231 of file SplineBase.cpp.

                                               {
 //*********************************************************
   #ifdef MaCh3_CUDA
   if(useGPU) {
     SynchroniseSplines();
     CudaCheckError();
   }
   #endif
 }

Member Data Documentation

◆ _max_knots

short int SplineBase::_max_knots

protected

Max knots for production.

Definition at line 115 of file SplineBase.h.

◆ gpu_monolith

SplineMonolithGPU* SplineBase::gpu_monolith

protected

KS: Store info about Spline monolith, this allow to obtain better step time. As all necessary information for spline weight calculation are here meaning better cache hits.

Definition at line 120 of file SplineBase.h.

◆ nParams

short int SplineBase::nParams

protected

Number of parameters that have splines.

Definition at line 113 of file SplineBase.h.

◆ NSplines_valid

unsigned int SplineBase::NSplines_valid

protected

Number of valid splines.

Definition at line 117 of file SplineBase.h.

◆ ParamValues

float* SplineBase::ParamValues

protected

Store parameter values they are not in FastSplineInfo as in case of GPU we need to copy paste it to GPU.

Definition at line 111 of file SplineBase.h.

◆ SplineInfoArray

std::vector<FastSplineInfo> SplineBase::SplineInfoArray

protected

Array of FastSplineInfo structs: keeps information on each spline for fast evaluation Method identical to TSpline3::Eval(double) but faster because less operations

Definition at line 106 of file SplineBase.h.

◆ SplineSegments

short int* SplineBase::SplineSegments

protected

Store currently found segment they are not in FastSplineInfo as in case of GPU we need to copy paste it to GPU

Warning: this is being used sometimes by GPU, therefore must be raw pointer!

Definition at line 109 of file SplineBase.h.

◆ useGPU

bool SplineBase::useGPU

protected

Whether to use GPU or not.

Definition at line 123 of file SplineBase.h.

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

Splines/SplineBase.h
Splines/SplineBase.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SplineBase()

◆ ~SplineBase()

Member Function Documentation

◆ CalcSplineWeights()

◆ CheckSegmentValidity()

◆ Evaluate()

◆ FindSplineSegment()

◆ GetName()

◆ GetNParams()

◆ GetTF1Coeff()

◆ LoadFastSplineInfoDir()

◆ LoadSplineFile()

◆ PrepareFastSplineInfoDir()

◆ PrepareSplineFile()

◆ SetupSegments()

◆ SynchroniseMemTransfer()

Member Data Documentation

◆ _max_knots

◆ gpu_monolith

◆ nParams

◆ NSplines_valid

◆ ParamValues

◆ SplineInfoArray

◆ SplineSegments

◆ useGPU