ParameterStructs.h File Reference

#include <set>
#include <list>
#include <unordered_map>
#include "Manager/MaCh3Exception.h"
#include "Manager/MaCh3Logger.h"
#include "Manager/Core.h"
#include "TSpline.h"
#include "TObjString.h"
#include "TFile.h"
#include "TF1.h"
#include "TH2Poly.h"
#include "TH1.h"

Include dependency graph for ParameterStructs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	TypeParameterBase
	Base class storing info for parameters types, helping unify codebase. More...
struct	NormParameter
	ETA - Normalisations for cross-section parameters Carrier for whether you want to apply a systematic to an event or not. More...
struct	FunctionalParameter
	HH - Functional parameters Carrier for whether you want to apply a systematic to an event or not. More...
struct	SplineParameter
	KS: Struct holding info about Spline Systematics. More...
struct	OscillationParameter
	KS: Struct holding info about oscillation Systematics. More...

Typedefs
using	FuncParFuncType = std::function< void(const double *, std::size_t)>

Enumerations
enum	RespFuncType { kTSpline3_red , kTF1_red , kRespFuncTypes }
	Make an enum of the spline interpolation type. More...
enum	SplineInterpolation {   kTSpline3 , kLinear , kMonotonic , kAkima ,   kLinearFunc , kSplineInterpolations }
	Make an enum of the spline interpolation type. More...
enum	SystType {   kNorm , kSpline , kFunc , kOsc ,   kSystTypes }

Functions
template<typename T , size_t N>
std::vector< T >	MakeVector (const T(&data)[N])
	Template to make vector out of an array of any length.
template<typename T >
void	CleanVector (std::vector< T > &vec)
	Generic cleanup function.
template<typename T >
void	CleanVector (std::vector< std::vector< T > > &vec)
	Generic cleanup function.
template<typename T >
void	CleanVector (std::vector< std::vector< std::vector< T > > > &vec)
	Generic cleanup function.
template<typename T >
void	CleanVector (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &vec)
	Generic cleanup function.
template<typename T >
void	CleanContainer (std::vector< T * > &container)
	Generic cleanup function.
template<typename T >
void	CleanContainer (std::vector< std::vector< std::vector< T * > > > &container)
	Generic cleanup function.
std::string	GetTF1 (const SplineInterpolation i)
	Get function for TF1_red.
RespFuncType	SplineInterpolation_ToRespFuncType (const SplineInterpolation i)
	Convert a RespFuncType type to a SplineInterpolation.
std::string	SplineInterpolation_ToString (const SplineInterpolation i)
	Convert a LLH type to a string.
std::string	SystType_ToString (const SystType i)
	Convert a Syst type type to a string.

Detailed Description

Author

Asher Kaboth

Clarence Wret

Patrick Dunne

Dan Barrow

Ed Atkin

Kamil Skwarczynski

Definition in file ParameterStructs.h.

Typedef Documentation

FuncParFuncType

using FuncParFuncType = std::function<void (const double*, std::size_t)>

Definition at line 184 of file ParameterStructs.h.

Enumeration Type Documentation

RespFuncType

enum RespFuncType

Make an enum of the spline interpolation type.

Enumerator
kTSpline3_red	Uses TSpline3_red for interpolation.
kTF1_red	Uses TF1_red for interpolation.
kRespFuncTypes	This only enumerates.

Definition at line 220 of file ParameterStructs.h.

                  {
  kTSpline3_red,  
  kTF1_red,       
  kRespFuncTypes  
};

SplineInterpolation

enum SplineInterpolation

Make an enum of the spline interpolation type.

Enumerator
kTSpline3	Default TSpline3 interpolation.
kLinear	Linear interpolation between knots.
kMonotonic	EM: DOES NOT make the entire spline monotonic, only the segments.
kAkima	EM: Akima spline iis allowed to be discontinuous in 2nd derivative and coefficients in any segment.
kLinearFunc	Liner interpolation using TF1 not spline.
kSplineInterpolations	This only enumerates.

Definition at line 227 of file ParameterStructs.h.

                         {
  kTSpline3,             
  kLinear,               
  kMonotonic,            
  kAkima,                
  kLinearFunc,           
  kSplineInterpolations  
};

SystType

enum SystType

Make an enum of systematic type recognised by covariance class

Todo:

KS: Consider using enum class, it is generally recommended as safer. It will require many static_cast

Enumerator
kNorm	For normalisation parameters.
kSpline	For splined parameters (1D)
kFunc	For functional parameters.
kOsc	For oscillation parameters.
kSystTypes	This only enumerates.

Definition at line 324 of file ParameterStructs.h.

              {
  kNorm,      
  kSpline,    
  kFunc,      
  kOsc,       
  kSystTypes  
};

Function Documentation

CleanContainer() [1/2]

template<typename T >

void CleanContainer

(

std::vector< std::vector< std::vector< T * > > > &

container

)

Generic cleanup function.

Definition at line 128 of file ParameterStructs.h.

                                                                        {
// *******************
  for (auto& container2D : container) {
    for (auto& container1D : container2D) {
      for (T* ptr : container1D) {
        if(ptr) delete ptr;
      }
      container1D.clear();
      container1D.shrink_to_fit();
    }
    container2D.clear();
    container2D.shrink_to_fit();
  }
  container.clear();
  container.shrink_to_fit();
}

CleanContainer() [2/2]

template<typename T >

void CleanContainer

(

std::vector< T * > &

container

)

Generic cleanup function.

Definition at line 115 of file ParameterStructs.h.

                                              {
// *******************
  for (T* ptr : container) {
    if(ptr) delete ptr;
    ptr = nullptr;
  }
  container.clear();
  container.shrink_to_fit();
}

CleanVector() [1/4]

template<typename T >

void CleanVector

(

std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &

vec

)

Generic cleanup function.

Todo:

Use recursive to make it more scalable in future

Definition at line 82 of file ParameterStructs.h.

                                                                                                      {
// *******************
  for (auto& v6 : vec) {
    for (auto& v5 : v6) {
      for (auto& v4 : v5) {
        for (auto& v3 : v4) {
          for (auto& v2 : v3) {
            for (auto& v1 : v2) {
              v1.clear();
              v1.shrink_to_fit();
            }
            v2.clear();
            v2.shrink_to_fit();
          }
          v3.clear();
          v3.shrink_to_fit();
        }
        v4.clear();
        v4.shrink_to_fit();
      }
      v5.clear();
      v5.shrink_to_fit();
    }
    v6.clear();
    v6.shrink_to_fit();
  }
  vec.clear();
  vec.shrink_to_fit();
}

CleanVector() [2/4]

template<typename T >

void CleanVector

(

std::vector< std::vector< std::vector< T > > > &

vec

)

Generic cleanup function.

Definition at line 64 of file ParameterStructs.h.

                                                          {
// *******************
  for (auto& inner2DVec : vec) {
    for (auto& innerVec : inner2DVec) {
      innerVec.clear();
      innerVec.shrink_to_fit();
    }
    inner2DVec.clear();
    inner2DVec.shrink_to_fit();
  }
  vec.clear();
  vec.shrink_to_fit();
}

CleanVector() [3/4]

template<typename T >

void CleanVector

(

std::vector< std::vector< T > > &

vec

)

Generic cleanup function.

Definition at line 51 of file ParameterStructs.h.

                                               {
// *******************
  for (auto& innerVec : vec) {
    innerVec.clear();
    innerVec.shrink_to_fit();
  }
  vec.clear();
  vec.shrink_to_fit();
}

CleanVector() [4/4]

template<typename T >

void CleanVector

(

std::vector< T > &

vec

)

Generic cleanup function.

Definition at line 42 of file ParameterStructs.h.

                                    {
// *******************
  vec.clear();
  vec.shrink_to_fit();
}

GetTF1()

std::string GetTF1 ( const SplineInterpolation  i )

inline

Get function for TF1_red.

Parameters

i	Interpolation type

Definition at line 239 of file ParameterStructs.h.

                                                     {
  // **************************************************
  std::string Func = "";
  switch(i) {
    case SplineInterpolation::kLinearFunc:
      Func = "([1]+[0]*x)";
      break;
    case SplineInterpolation::kTSpline3:
    case SplineInterpolation::kLinear:
    case SplineInterpolation::kMonotonic:
    case SplineInterpolation::kAkima:
    case SplineInterpolation::kSplineInterpolations:
      MACH3LOG_ERROR("Interpolation type {} not supported for TF1!", static_cast<int>(i));
      throw MaCh3Exception(__FILE__, __LINE__);
    default:
      MACH3LOG_ERROR("UNKNOWN SPLINE INTERPOLATION SPECIFIED!");
      MACH3LOG_ERROR("You gave {}", static_cast<int>(i));
      throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return Func;
}

MakeVector()

template<typename T , size_t N>

std::vector< T > MakeVector

(

const T(&)

data[N]

)

Template to make vector out of an array of any length.

Definition at line 34 of file ParameterStructs.h.

                                              {
// *******************
  return std::vector<T>(data, data+N);
}

SplineInterpolation_ToRespFuncType()

RespFuncType SplineInterpolation_ToRespFuncType ( const SplineInterpolation  i )

inline

Convert a RespFuncType type to a SplineInterpolation.

Parameters

i	Interpolation type

Definition at line 264 of file ParameterStructs.h.

                                                                                    {
// **************************************************
  RespFuncType Type = kRespFuncTypes;
  switch(i) {
    case SplineInterpolation::kTSpline3:
    case SplineInterpolation::kLinear:
    case SplineInterpolation::kMonotonic:
    case SplineInterpolation::kAkima:
      Type = RespFuncType::kTSpline3_red;
      break;
    case SplineInterpolation::kLinearFunc:
      Type = RespFuncType::kTF1_red;
      break;
    case SplineInterpolation::kSplineInterpolations:
      MACH3LOG_ERROR("kSplineInterpolations is not a valid interpolation type!");
      throw MaCh3Exception(__FILE__, __LINE__);
    default:
      MACH3LOG_ERROR("UNKNOWN SPLINE INTERPOLATION SPECIFIED!");
      MACH3LOG_ERROR("You gave {}", static_cast<int>(i));
      throw MaCh3Exception(__FILE__, __LINE__);
  }
  return Type;
}

SplineInterpolation_ToString()

std::string SplineInterpolation_ToString ( const SplineInterpolation  i )

inline

Convert a LLH type to a string.

Definition at line 290 of file ParameterStructs.h.

                                                                           {
// **************************************************
  std::string name = "";
  switch(i) {
    //  TSpline3 (third order spline in ROOT)
    case SplineInterpolation::kTSpline3:
      name = "TSpline3";
      break;
    case SplineInterpolation::kLinear:
      name = "Linear";
      break;
    case SplineInterpolation::kMonotonic:
      name = "Monotonic";
      break;
    //  (Experimental) Akima_Spline (crd order spline which is allowed to be discontinuous in 2nd deriv)
    case SplineInterpolation::kAkima:
      name = "Akima";
      break;
    case SplineInterpolation::kLinearFunc:
      name = "LinearFunc";
      break;
    case SplineInterpolation::kSplineInterpolations:
      MACH3LOG_ERROR("kSplineInterpolations is not a valid interpolation type!");
      throw MaCh3Exception(__FILE__, __LINE__);
    default:
      MACH3LOG_ERROR("UNKNOWN SPLINE INTERPOLATION SPECIFIED!");
      MACH3LOG_ERROR("You gave {}", static_cast<int>(i));
      throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return name;
}

SystType_ToString()

std::string SystType_ToString ( const SystType  i )

inline

Convert a Syst type type to a string.

Definition at line 350 of file ParameterStructs.h.

                                                     {
// **************************************************
  std::string name = "";
  switch(i) {
    case SystType::kNorm:
      name = "Norm";
      break;
    case SystType::kSpline:
      name = "Spline";
      break;
    case SystType::kFunc:
      name = "Functional";
      break;
    case SystType::kOsc:
      name = "Oscillation";
      break;
    case SystType::kSystTypes:
      MACH3LOG_ERROR("kSystTypes is not a valid SystType!");
      throw MaCh3Exception(__FILE__, __LINE__);
    default:
      MACH3LOG_ERROR("UNKNOWN SYST TYPE SPECIFIED!");
      MACH3LOG_ERROR("You gave {}", static_cast<int>(i));
      throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return name;
}