#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 &resEta) 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 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.
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.
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 2695 of file Functions.h.

Constructor & Destructor Documentation

backgroundFunctionBase::backgroundFunctionBase	(	const double &	lowerLimit,
		const double &	upperLimit
	)		`[inline]`

Definition at line 2697 of file Functions.h.

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

virtual backgroundFunctionBase::~backgroundFunctionBase ( ) [inline, virtual]

Definition at line 2699 of file Functions.h.

References functionForIntegral_.

  {
    delete functionForIntegral_;
  };

Member Function Documentation

virtual double backgroundFunctionBase::fracVsEta	(	const double *	parval,
		const double &	resEta
	)		const `[inline, virtual]`

Reimplemented in backgroundFunctionType4.

Definition at line 2714 of file Functions.h.

{ return 1.; }

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

Definition at line 2707 of file Functions.h.

References functionForIntegral_, lowerLimit_, parNum_, and upperLimit_.

Referenced by BackgroundHandler::rescale().

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

virtual double backgroundFunctionBase::operator()	(	const double *	parval,
		const double &	mass,
		const double &	eta
	)		const `[pure virtual]`

Implemented in backgroundFunctionType1, backgroundFunctionType2, backgroundFunctionType4, and backgroundFunctionType5.

virtual int backgroundFunctionBase::parNum ( ) const [inline, virtual]

Definition at line 2704 of file Functions.h.

References parNum_.

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

{ return parNum_; }

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
	)		`[inline, protected, virtual]`

This method sets the parameters.

Definition at line 2721 of file Functions.h.

References parNum_.

Referenced by backgroundFunctionType5::setParameters(), backgroundFunctionType4::setParameters(), backgroundFunctionType2::setParameters(), and backgroundFunctionType1::setParameters().

                                                                                                   {
    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);
      parname[iPar] = thisParName[iPar];
    }
  }

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]`