MELALinearInterpFunc Class Reference

#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.

{}

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.

{ 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.

{ 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.

{ return XList.size(); }

setEvalFloor()

void MELALinearInterpFunc::setEvalFloor

(

MELALinearInterpFunc::T

val

)

Definition at line 105 of file MELALinearInterpFunc.cc.

{ floorEval = val; }

setIntFloor()

void MELALinearInterpFunc::setIntFloor

(

MELALinearInterpFunc::T

val

)

Definition at line 106 of file MELALinearInterpFunc.cc.

{ 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.

{ 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