#include <MELALinearInterpFunc.h>

Inheritance diagram for MELALinearInterpFunc:

Collaboration diagram for MELALinearInterpFunc:

Public Types
enum	VerbosityLevel { kSilent, kError, kVerbose }

typedef Float_t	T

Public Member Functions
	MELALinearInterpFunc ()

	MELALinearInterpFunc (const char name, const char title)

	MELALinearInterpFunc (const char name, const char title, RooAbsReal &inXVar, const std::vector< T > &inXList, const RooArgList &inFcnList, Bool_t inUseFloor=true, T inFloorEval=1e-15, T inFloorInt=1e-10)

	MELALinearInterpFunc (const MELALinearInterpFunc &other, const char *name=0)

virtual TObject *	clone (const char *newname) const

virtual	~MELALinearInterpFunc ()

void	setVerbosity (VerbosityLevel flag)

void	setEvalFloor (T val)

void	setIntFloor (T val)

void	doFloor (Bool_t flag)

void	setRangeValidity (const T valmin, const T valmax)

Int_t	getAnalyticalIntegral (RooArgSet &allVars, RooArgSet &analVars, const char *rangeName=0) const

Double_t	analyticalIntegral (Int_t code, const char *rangeName=0) const

Protected Member Functions
unsigned int	npoints () const

Int_t	getWhichBin (const T &val) const

T	getKappa (const Int_t &bin) const

T	getTVar (const T &val) const

Bool_t	testRangeValidity (const T &val) const

void	cropValueForRange (T &val) const

T	interpolateFcn (Int_t code, const char *rangeName=0) const

Double_t	evaluate () const

Protected Attributes
VerbosityLevel	verbosity

Bool_t	useFloor

T	floorEval

T	floorInt

T	rangeXmin

T	rangeXmax

std::vector< T >	XList

RooRealProxy	theXVar

RooListProxy	FcnList

RooListProxy	leafDepsList

Detailed Description

Definition at line 13 of file MELALinearInterpFunc.h.

Member Typedef Documentation

◆ T

typedef Float_t MELALinearInterpFunc::T

Definition at line 15 of file MELALinearInterpFunc.h.

Member Enumeration Documentation

◆ VerbosityLevel

enum MELALinearInterpFunc::VerbosityLevel

Enumerator
kSilent
kError
kVerbose

Definition at line 17 of file MELALinearInterpFunc.h.

                      {
     kSilent,
     kError,
     kVerbose
   };

Constructor & Destructor Documentation

◆ MELALinearInterpFunc() [1/4]

MELALinearInterpFunc::MELALinearInterpFunc ( )

◆ MELALinearInterpFunc() [2/4]

MELALinearInterpFunc::MELALinearInterpFunc	(	const char *	name,
		const char *	title
	)

Definition at line 24 of file MELALinearInterpFunc.cc.

     :
   RooAbsReal(name, title),
   verbosity(MELALinearInterpFunc::kSilent),
   useFloor(true), floorEval(0), floorInt(0),
   rangeXmin(1), rangeXmax(-1),
   theXVar("theXVar", "theXVar", this),
   FcnList("FcnList", "FcnList", this),
   leafDepsList("leafDepsList", "leafDepsList", this)
 {}

◆ MELALinearInterpFunc() [3/4]

MELALinearInterpFunc::MELALinearInterpFunc	(	const char *	name,
		const char *	title,
		RooAbsReal &	inXVar,
		const std::vector< T > &	inXList,
		const RooArgList &	inFcnList,
		Bool_t	inUseFloor = `true`,
		T	inFloorEval = `1e-15`,
		T	inFloorInt = `1e-10`
	)

◆ MELALinearInterpFunc() [4/4]

MELALinearInterpFunc::MELALinearInterpFunc	(	const MELALinearInterpFunc &	other,
		const char *	name = `0`
	)

Definition at line 90 of file MELALinearInterpFunc.cc.

     :
   RooAbsReal(other, name),
   verbosity(other.verbosity),
   useFloor(other.useFloor), floorEval(other.floorEval), floorInt(other.floorInt),
   rangeXmin(other.rangeXmin), rangeXmax(other.rangeXmax),
   XList(other.XList),
   theXVar("theXVar", this, other.theXVar),
   FcnList("FcnList", this, other.FcnList),
   leafDepsList("leafDepsList", this, other.leafDepsList)
 {}

◆ ~MELALinearInterpFunc()

virtual MELALinearInterpFunc::~MELALinearInterpFunc ( )

inlinevirtual

Definition at line 41 of file MELALinearInterpFunc.h.

41 {}

Member Function Documentation

◆ analyticalIntegral()

Double_t MELALinearInterpFunc::analyticalIntegral	(	Int_t	code,
		const char *	rangeName = `0`
	)		const

Definition at line 290 of file MELALinearInterpFunc.cc.

                                                                                        {
   Double_t value = interpolateFcn(code, rangeName);
   if (useFloor && value<floorInt){
     if (verbosity>=MELALinearInterpFunc::kError) coutE(Integration) << "MELALinearInterpFunc ERROR::MELALinearInterpFunc(" << GetName() << ") integration returned " << value << " for code = " << code << endl;
     value = floorInt;
   }
   if (verbosity==MELALinearInterpFunc::kVerbose){ cout << "MELALinearInterpFunc(" << GetName() << ")::analyticalIntegral = " << value << " for code = " << code << endl; }
   return value;
 }

◆ clone()

virtual TObject* MELALinearInterpFunc::clone ( const char * newname ) const

inlinevirtual

Definition at line 40 of file MELALinearInterpFunc.h.

40 { return new MELALinearInterpFunc(*this, newname); }

◆ cropValueForRange()

void MELALinearInterpFunc::cropValueForRange ( T & val ) const

protected

Definition at line 313 of file MELALinearInterpFunc.cc.

                                                        {
   if (testRangeValidity(val)) return;
   const T* range[2];
   range[0] = &rangeXmin;
   range[1] = &rangeXmax;
   if (val<*(range[0])) val = *(range[0]);
   if (val>*(range[1])) val = *(range[1]);
 }

◆ doFloor()

void MELALinearInterpFunc::doFloor ( Bool_t flag )

Definition at line 107 of file MELALinearInterpFunc.cc.

107 { useFloor = flag; }

◆ evaluate()

Double_t MELALinearInterpFunc::evaluate ( ) const

protected

Definition at line 222 of file MELALinearInterpFunc.cc.

                                             {
   Double_t value = interpolateFcn(0);
   if (useFloor && value<floorEval){
     if (verbosity>=MELALinearInterpFunc::kError) coutE(Eval) << "MELALinearInterpFunc ERROR::MELALinearInterpFunc(" << GetName() << ") evaluation returned " << value << " at x = " << theXVar << endl;
     value = floorEval;
   }
   if (verbosity==MELALinearInterpFunc::kVerbose){ cout << "MELALinearInterpFunc(" << GetName() << ")::evaluate = " << value << " at x = " << theXVar << endl; }
   return value;
 }

◆ getAnalyticalIntegral()

Int_t MELALinearInterpFunc::getAnalyticalIntegral	(	RooArgSet &	allVars,
		RooArgSet &	analVars,
		const char *	rangeName = `0`
	)		const

Definition at line 231 of file MELALinearInterpFunc.cc.

                                                                                                                     {
   if (_forceNumInt) return 0;
  
   const Int_t xprime = 101;
   Int_t code=1;
  
   RooArgSet Xdeps, Fcndeps;
   RooRealVar* rrv_x = dynamic_cast<RooRealVar*>(theXVar.absArg());
   if (rrv_x==0) theXVar.absArg()->leafNodeServerList(&Xdeps, 0, true);
  
   for (int ix=0; ix<FcnList.getSize(); ix++){
     RooArgSet tmpdeps;
     RooAbsReal const* fcn = dynamic_cast<const RooAbsReal*>(FcnList.at(ix));
     fcn->leafNodeServerList(&tmpdeps, 0, true);
     Fcndeps.add(tmpdeps);
     if (ix==0){
       RooArgSet mirrorvars;
       TIterator* iter = allVars.createIterator();
       RooAbsArg* var;
       while ((var = (RooAbsArg*)iter->Next())){
         RooRealVar* rrv_tmp = dynamic_cast<RooRealVar*>(var);
         if (rrv_tmp==0) continue;
         bool isFound=false;
         if (rrv_x!=0){
           isFound = (rrv_tmp==rrv_x);
         }
         else{
           TIterator* iter_deps = Xdeps.createIterator();
           RooAbsArg* var_deps;
           while ((var_deps = (RooAbsArg*)iter_deps->Next())){
             RooRealVar* depvar = dynamic_cast<RooRealVar*>(var_deps);
             if (depvar==0) continue;
             if (depvar==rrv_tmp){ isFound=true; break; }
           }
           delete iter_deps;
         }
         if (!isFound) mirrorvars.add(*var);
       }
       delete iter;
  
       Int_t codetmp = fcn->getAnalyticalIntegral(mirrorvars, analVars, rangeName);
       if (codetmp!=0) code *= codetmp;
     }
   }
  
   if (rrv_x!=0){
     if (Fcndeps.find(*rrv_x)==0){
       if (matchArgs(allVars, analVars, theXVar)) code *= xprime;
     }
   }
  
   if (code==1) code=0;
   if (verbosity==MELALinearInterpFunc::kVerbose){
     cout << "MELALinearInterpFunc(" << GetName() << ")::getAnalyticalIntegral code = " << code << endl;
     allVars.Print("v");
     analVars.Print("v");
   }
   return code;
 }

◆ getKappa()

MELALinearInterpFunc::T MELALinearInterpFunc::getKappa ( const Int_t & bin ) const

protected

Definition at line 130 of file MELALinearInterpFunc.cc.

                                                                          {
   if (bin>=0){
     vector<MELALinearInterpFunc::T> const* coord=&XList;
     MELALinearInterpFunc::T diff = 1;
     if (Int_t(coord->size())>(bin+1)) diff = coord->at(bin+1)-coord->at(bin);
     if (fabs(diff)>MELALinearInterpFunc::T(0)) return MELALinearInterpFunc::T(1)/diff;
     else return 0;
   }
   else return 1;
 }

◆ getTVar()

MELALinearInterpFunc::T MELALinearInterpFunc::getTVar ( const T & val ) const

protected

Definition at line 140 of file MELALinearInterpFunc.cc.

                                                                                         {
   const Int_t bin = getWhichBin(val);
   vector<MELALinearInterpFunc::T> const* coord=&XList;
   const MELALinearInterpFunc::T kappa = getKappa(bin);
   return (val - coord->at(bin))*kappa;
 }

◆ getWhichBin()

Int_t MELALinearInterpFunc::getWhichBin ( const T & val ) const

protected

Definition at line 109 of file MELALinearInterpFunc.cc.

                                                                             {
   Int_t bin=-1;
   MELALinearInterpFunc::T valj, valjpo;
   Int_t np;
   vector<MELALinearInterpFunc::T> const* coord=&XList;
   np=npoints();
  
   if (np<=1) bin=0;
   else{
     valjpo = coord->at(0);
     for (Int_t j=0; j<np-1; j++){
       valj = coord->at(j);
       valjpo = coord->at(j+1);
       if (val<valjpo && val>=valj){ bin=j; break; }
     }
     if (bin==-1 && val>=valjpo) bin=np-2;
     else if (bin==-1) bin=0;
   }
  
   return bin;
 }

◆ interpolateFcn()

MELALinearInterpFunc::T MELALinearInterpFunc::interpolateFcn	(	Int_t	code,
		const char *	rangeName = `0`
	)		const

protected

Definition at line 147 of file MELALinearInterpFunc.cc.

                                                                                                 {
   const Int_t xprime = 101;
   const bool intAlongX=(code>0 && code%xprime==0);
  
   DefaultAccumulator<MELALinearInterpFunc::T> res;
   Int_t coderem = (intAlongX ? code/xprime : code);
   if (coderem==1) coderem=0;
  
   if (verbosity==MELALinearInterpFunc::kVerbose){
     if (intAlongX) cout << "MELALinearInterpFunc(" << GetName() << ")::interpolateFcn integrates using code = " << code << ", coderem = " << coderem << endl;
     else cout << "MELALinearInterpFunc(" << GetName() << ")::interpolateFcn evaluates using code = " << code << ", coderem = " << coderem << endl;
   }
  
   // Get bins
   Int_t xbin=-1, xbinmin=-1, xbinmax=-1;
   MELALinearInterpFunc::T tx=0, txmin=0, txmax=0;
   if (!intAlongX){ // Case to just compute the value at x
     if (!testRangeValidity(theXVar)) return 0;
     xbin = getWhichBin(theXVar);
     tx = getTVar(theXVar);
   }
   else{ // Case to integrate along x
     MELALinearInterpFunc::T coordmin = theXVar.min(rangeName); cropValueForRange(coordmin);
     MELALinearInterpFunc::T coordmax = theXVar.max(rangeName); cropValueForRange(coordmax);
     xbinmin = getWhichBin(coordmin);
     txmin = getTVar(coordmin);
     xbinmax = getWhichBin(coordmax);
     txmax = getTVar(coordmax);
   }
  
   int nxbins = npoints()-1;
   if (nxbins==0){
     MELALinearInterpFunc::T fcnval;
     if (coderem==0) fcnval = dynamic_cast<const RooAbsReal*>(FcnList.at(0))->getVal();
     else fcnval = dynamic_cast<const RooAbsReal*>(FcnList.at(0))->analyticalIntegral(coderem, rangeName);
     res = fcnval;
     if (intAlongX) res *= (txmax-txmin);
   }
   else{
     for (int ix=0; ix<nxbins; ix++){
       if (
         (xbin>=0 && ix!=xbin)
         ||
         (xbinmin>=0 && xbinmax>=xbinmin && !(xbinmin<=ix && ix<=xbinmax))
         ) continue;
  
       MELALinearInterpFunc::T txlow=0, txhigh=1;
       if (intAlongX){
         if (ix==xbinmin) txlow=txmin;
         if (ix==xbinmax) txhigh=txmax;
       }
       else txhigh=tx;
  
       MELALinearInterpFunc::T fcnval[2]={ 0 };
       if (coderem==0){
         for (unsigned int j=0; j<2; j++) fcnval[j] = dynamic_cast<const RooAbsReal*>(FcnList.at(ix+j))->getVal();
       }
       else{
         for (unsigned int j=0; j<2; j++) fcnval[j] = dynamic_cast<const RooAbsReal*>(FcnList.at(ix+j))->analyticalIntegral(coderem, rangeName);
       }
  
       DefaultAccumulator<MELALinearInterpFunc::T> segval = fcnval[0];
       if (intAlongX) segval += (fcnval[1] - fcnval[0])*(pow(txhigh, 2)-pow(txlow, 2))/2.;
       else segval += (fcnval[1] - fcnval[0])*txhigh;
       res += segval;
  
       if (verbosity==MELALinearInterpFunc::kVerbose) cout
         << "MELALinearInterpFunc(" << GetName() << ")::interpolateFcn evaluated bin " << ix
         << " with txlow = " << txlow << ", txhigh = " << txhigh << ", fcnval[0] = " << fcnval[0] << ", fcnval[1] = " << fcnval[1]
         << endl;
     }
   }
  
   return res;
 }

◆ npoints()

unsigned int MELALinearInterpFunc::npoints ( ) const

inlineprotected

Definition at line 67 of file MELALinearInterpFunc.h.

67 { return XList.size(); }

◆ setEvalFloor()

void MELALinearInterpFunc::setEvalFloor ( MELALinearInterpFunc::T val )

Definition at line 105 of file MELALinearInterpFunc.cc.

105 { floorEval = val; }

◆ setIntFloor()

void MELALinearInterpFunc::setIntFloor ( MELALinearInterpFunc::T val )

Definition at line 106 of file MELALinearInterpFunc.cc.

106 { floorInt = val; }

◆ setRangeValidity()

void MELALinearInterpFunc::setRangeValidity	(	const T	valmin,
		const T	valmax
	)

Definition at line 306 of file MELALinearInterpFunc.cc.

                                                                          {
   T* range[2];
   range[0] = &rangeXmin;
   range[1] = &rangeXmax;
   *(range[0])=valmin;
   *(range[1])=valmax;
 }

◆ setVerbosity()

void MELALinearInterpFunc::setVerbosity ( VerbosityLevel flag )

Definition at line 104 of file MELALinearInterpFunc.cc.

104 { verbosity = flag; }

◆ testRangeValidity()

Bool_t MELALinearInterpFunc::testRangeValidity ( const T & val ) const

protected

Definition at line 300 of file MELALinearInterpFunc.cc.

                                                                 {
   const T* range[2];
   range[0] = &rangeXmin;
   range[1] = &rangeXmax;
   return (*(range[0])>*(range[1]) || (val>=*(range[0]) && val<=*(range[1])));
 }

Member Data Documentation

◆ FcnList

RooListProxy MELALinearInterpFunc::FcnList

protected

Definition at line 64 of file MELALinearInterpFunc.h.

◆ floorEval

T MELALinearInterpFunc::floorEval

protected

Definition at line 56 of file MELALinearInterpFunc.h.

◆ floorInt

T MELALinearInterpFunc::floorInt

protected

Definition at line 57 of file MELALinearInterpFunc.h.

◆ leafDepsList

RooListProxy MELALinearInterpFunc::leafDepsList

protected

Definition at line 65 of file MELALinearInterpFunc.h.

◆ rangeXmax

T MELALinearInterpFunc::rangeXmax

protected

Definition at line 60 of file MELALinearInterpFunc.h.

◆ rangeXmin

T MELALinearInterpFunc::rangeXmin

protected

Definition at line 59 of file MELALinearInterpFunc.h.

◆ theXVar

RooRealProxy MELALinearInterpFunc::theXVar

protected

Definition at line 63 of file MELALinearInterpFunc.h.

◆ useFloor

Bool_t MELALinearInterpFunc::useFloor

protected

Definition at line 55 of file MELALinearInterpFunc.h.

◆ verbosity

VerbosityLevel MELALinearInterpFunc::verbosity

protected

Definition at line 54 of file MELALinearInterpFunc.h.

◆ XList

std::vector<T> MELALinearInterpFunc::XList

protected

Definition at line 62 of file MELALinearInterpFunc.h.

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

MELA/interface/MELALinearInterpFunc.h
MELA/src/MELALinearInterpFunc.cc

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ T

Member Enumeration Documentation

◆ VerbosityLevel

Constructor & Destructor Documentation

◆ MELALinearInterpFunc() [1/4]

◆ MELALinearInterpFunc() [2/4]

◆ MELALinearInterpFunc() [3/4]

◆ MELALinearInterpFunc() [4/4]

◆ ~MELALinearInterpFunc()

Member Function Documentation

◆ analyticalIntegral()

◆ clone()

◆ cropValueForRange()

◆ doFloor()

◆ evaluate()

◆ getAnalyticalIntegral()

◆ getKappa()

◆ getTVar()

◆ getWhichBin()

◆ interpolateFcn()

◆ npoints()

◆ setEvalFloor()

◆ setIntFloor()

◆ setRangeValidity()

◆ setVerbosity()

◆ testRangeValidity()

Member Data Documentation

◆ FcnList

◆ floorEval

◆ floorInt

◆ leafDepsList

◆ rangeXmax

◆ rangeXmin

◆ theXVar

◆ useFloor

◆ verbosity

◆ XList