backgroundFunctionBase Class Reference

#include <Functions.h>

Inheritance diagram for backgroundFunctionBase:

Classes
class	FunctionForIntegral

Public Member Functions
	backgroundFunctionBase (const double &lowerLimit, const double &upperLimit)
virtual double	fracVsEta (const double *parval, const double &eta1, const double &eta2) const
virtual TF1 *	functionForIntegral (const std::vector< double >::const_iterator &parBgrIt) const
virtual double	operator() (const double *parval, const double &mass, const double &eta) const =0
virtual double	operator() (const double *parval, const double &mass, const double &eta1, const double &eta2) const
virtual int	parNum () const
virtual void	setParameters (double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, const int muonType)=0
	This method is used to differentiate parameters among the different functions. More...
virtual	~backgroundFunctionBase ()

Protected Member Functions
virtual void	setPar (double *Start, double *Step, double *Mini, double *Maxi, int *ind, TString *parname, const std::vector< double >::const_iterator &parBgrIt, const std::vector< int >::const_iterator &parBgrOrderIt, double *thisStep, double *thisMini, double *thisMaxi, TString *thisParName)
	This method sets the parameters. More...

Protected Attributes
FunctionForIntegral *	functionForIntegral_
double	lowerLimit_
int	parNum_
double	upperLimit_

Detailed Description

Background functors.
MuScleFit uses different background functions for each resonance. This is done because the background shape can change from a region to another so that it is not well described just one of the following functions. Since we are only interested in getting the correct shape and fraction in the resonance region we can split it in several parts and fit them separately.

When fitting the background function:

• we define three regions:
  – Psis region: centered in the mean value of J/Psi and Psi2S masses.
  – Upsilons region: centered in the mean value of all the Upsilon masses.
  – Z region.
  
• In this case we thus have only three background functions, that is three sets of parameters.
  When not fitting the background function:
  
• the windows considered are much narrower and centered around each resonance.
  
• In this case we compute a rescaled background fraction parameter for each resonance and we use the rest of the parameters for the corresponding region.
  ATTENTION: we are assuming that J/Psi and Psi2S have the same bin width. The same assumption is done for the Upsilons.
  This is the case in the present probability root file. If this changes, the background function for the different regions must keep it into account.
  
  All this is handled in MuScleFit by a single functor: BackgroundHandler defined in another file in this dir.
  ATTENTION: The BackgroundHandler assumes that the background fraction is always the first parameter (parBgr[0]).

Definition at line 1368 of file Functions.h.

Constructor & Destructor Documentation

backgroundFunctionBase()

backgroundFunctionBase::backgroundFunctionBase ( const double &  lowerLimit, const double &  upperLimit  )

inline

Definition at line 1370 of file Functions.h.

      : lowerLimit_(lowerLimit), upperLimit_(upperLimit) {}

~backgroundFunctionBase()

virtual backgroundFunctionBase::~backgroundFunctionBase ( )

inlinevirtual

Definition at line 1372 of file Functions.h.

{ delete functionForIntegral_; };

References functionForIntegral_.

Member Function Documentation

fracVsEta()

virtual double backgroundFunctionBase::fracVsEta ( const double *  parval, const double &  eta1, const double &  eta2  ) const

inlinevirtual

Reimplemented in backgroundFunctionType11, backgroundFunctionType10, backgroundFunctionType9, backgroundFunctionType8, backgroundFunctionType7, and backgroundFunctionType6.

Definition at line 1394 of file Functions.h.

{ return 1.; }

functionForIntegral()

virtual TF1* backgroundFunctionBase::functionForIntegral ( const std::vector< double >::const_iterator &  parBgrIt ) const

inlinevirtual

Definition at line 1388 of file Functions.h.

                                                                                          {
    functionForIntegral_ = new FunctionForIntegral(this, parBgrIt);
    TF1* backgroundFunctionForIntegral =
        new TF1("backgroundFunctionForIntegral", functionForIntegral_, lowerLimit_, upperLimit_, this->parNum_);
    return (backgroundFunctionForIntegral);
  }

References functionForIntegral_, lowerLimit_, parNum_, and upperLimit_.

operator()() [1/2]

virtual double backgroundFunctionBase::operator() ( const double *  parval, const double &  mass, const double &  eta  ) const

pure virtual

Implemented in backgroundFunctionType11, backgroundFunctionType10, backgroundFunctionType9, backgroundFunctionType8, backgroundFunctionType7, backgroundFunctionType6, backgroundFunctionType5, backgroundFunctionType4, backgroundFunctionType2, and backgroundFunctionType1.

Referenced by operator()().

operator()() [2/2]

virtual double backgroundFunctionBase::operator() ( const double *  parval, const double &  mass, const double &  eta1, const double &  eta2  ) const

inlinevirtual

Reimplemented in backgroundFunctionType11, backgroundFunctionType10, backgroundFunctionType9, backgroundFunctionType8, backgroundFunctionType7, and backgroundFunctionType6.

Definition at line 1374 of file Functions.h.

                                                                                                                    {
    return operator()(parval, mass, eta1);
  }

References HLT_FULL_cff::eta1, EgHLTOffHistBins_cfi::mass, and operator()().

parNum()

virtual int backgroundFunctionBase::parNum ( ) const

inlinevirtual

Definition at line 1377 of file Functions.h.

{ return parNum_; }

References parNum_.

Referenced by backgroundFunctionBase::FunctionForIntegral::FunctionForIntegral().

setPar()

virtual void backgroundFunctionBase::setPar ( double *  Start, double *  Step, double *  Mini, double *  Maxi, int *  ind, TString *  parname, const std::vector< double >::const_iterator &  parBgrIt, const std::vector< int >::const_iterator &  parBgrOrderIt, double *  thisStep, double *  thisMini, double *  thisMaxi, TString *  thisParName  )

inlineprotectedvirtual

This method sets the parameters.

Definition at line 1401 of file Functions.h.

                                            {
    for (int iPar = 0; iPar < this->parNum_; ++iPar) {
      Start[iPar] = *(parBgrIt + iPar);
      Step[iPar] = thisStep[iPar];
      Mini[iPar] = thisMini[iPar];
      Maxi[iPar] = thisMaxi[iPar];
      ind[iPar] = *(parBgrOrderIt + iPar);
      // EM 2012.05.22 this line is crashing cmsRun (need to be fixed)      parname[iPar] = thisParName[iPar];
    }
  }

References parNum_.

Referenced by backgroundFunctionType1::setParameters(), backgroundFunctionType2::setParameters(), backgroundFunctionType4::setParameters(), backgroundFunctionType5::setParameters(), backgroundFunctionType6::setParameters(), backgroundFunctionType7::setParameters(), backgroundFunctionType8::setParameters(), backgroundFunctionType9::setParameters(), backgroundFunctionType10::setParameters(), and backgroundFunctionType11::setParameters().

setParameters()

virtual void backgroundFunctionBase::setParameters ( double *  Start, double *  Step, double *  Mini, double *  Maxi, int *  ind, TString *  parname, const std::vector< double >::const_iterator &  parBgrIt, const std::vector< int >::const_iterator &  parBgrOrderIt, const int  muonType  )

pure virtual

This method is used to differentiate parameters among the different functions.

Implemented in backgroundFunctionType11, backgroundFunctionType10, backgroundFunctionType9, backgroundFunctionType8, backgroundFunctionType7, backgroundFunctionType6, backgroundFunctionType5, backgroundFunctionType4, backgroundFunctionType2, and backgroundFunctionType1.

Member Data Documentation

functionForIntegral_

FunctionForIntegral* backgroundFunctionBase::functionForIntegral_

mutableprotected

Definition at line 1441 of file Functions.h.

Referenced by functionForIntegral(), and ~backgroundFunctionBase().

lowerLimit_

double backgroundFunctionBase::lowerLimit_

protected

Definition at line 1398 of file Functions.h.

Referenced by functionForIntegral(), backgroundFunctionType1::operator()(), backgroundFunctionType2::operator()(), backgroundFunctionType4::operator()(), backgroundFunctionType5::operator()(), backgroundFunctionType6::operator()(), backgroundFunctionType7::operator()(), backgroundFunctionType8::operator()(), backgroundFunctionType9::operator()(), backgroundFunctionType10::operator()(), and backgroundFunctionType11::operator()().

parNum_

int backgroundFunctionBase::parNum_

protected

Definition at line 1397 of file Functions.h.

Referenced by backgroundFunctionType1::backgroundFunctionType1(), backgroundFunctionType10::backgroundFunctionType10(), backgroundFunctionType11::backgroundFunctionType11(), backgroundFunctionType2::backgroundFunctionType2(), backgroundFunctionType4::backgroundFunctionType4(), backgroundFunctionType5::backgroundFunctionType5(), backgroundFunctionType6::backgroundFunctionType6(), backgroundFunctionType7::backgroundFunctionType7(), backgroundFunctionType8::backgroundFunctionType8(), backgroundFunctionType9::backgroundFunctionType9(), functionForIntegral(), parNum(), and setPar().

upperLimit_

double backgroundFunctionBase::upperLimit_

protected

Definition at line 1399 of file Functions.h.

Referenced by functionForIntegral(), backgroundFunctionType1::operator()(), backgroundFunctionType2::operator()(), backgroundFunctionType4::operator()(), backgroundFunctionType5::operator()(), backgroundFunctionType6::operator()(), backgroundFunctionType7::operator()(), backgroundFunctionType8::operator()(), backgroundFunctionType9::operator()(), backgroundFunctionType10::operator()(), and backgroundFunctionType11::operator()().