RooAddModel

RooAddModel(const char *name, const char *title, const RooArgList& modelList, const RooArgList& coefList)

 Constructor from list of PDFs and list of coefficients.
 Each model list element (i) is paired with coefficient list element (i).
 The number of coefficients must be one less than the number of PDFs.

 All modelss must inherit from RooResolutionModel. All
 coefficients must inherit from RooAbsReal

RooAddModel(const RooAddModel& other, const char* name)

 Copy constructor

~RooAddModel()

 Destructor

RooResolutionModel* convolution(RooFormulaVar* basis, RooAbsArg* owner)

 Instantiate a clone of this resolution model representing a convolution with given
 basis function. The owners object name is incorporated in the clones name
 to avoid multiple convolution objects with the same name in complex PDF structures.

 RooAddModel will clone all the component models to create a composite convolution object

Int_t basisCode(const char* name)

 Return code for basis function representing by 'name' string.
 The basis code of the first component model will be returned,
 if the basis is supported by all components. Otherwise 0
 is returned

Double_t evaluate()

 Calculate current value of object

 MODEL = sum(i=0,n-1) coef_i * model_i + (1 - sum(i=0,n-1) coef_i) * model_n

Double_t getNorm(const RooArgSet* nset)

 Calculate current normalization of object

 Norm = sum(i=0,n-1) coef_i * norm(model_i) + (1 - sum(i=0,n-1)coef_i) * norm(model_n)

Bool_t checkObservables(const RooArgSet* set)

 Check if model is valid with dependent configuration given by specified data set
 Each model may not share any dependents with its coefficient

void normLeafServerList(RooArgSet& list)

 Fill list with leaf server nodes of normalization integral

Bool_t syncNormalization(const RooArgSet* nset, Bool_t adjustProxies)

 Fan out syncNormalization call to component models

Int_t getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet, const char* /*rangeName*/)

{
 Determine which part (if any) of given integral can be performed analytically.
 If any analytical integration is possible, return integration scenario code

 RooAddModel queries each component model for its analytical integration capability of the requested
 set ('allVars'). It finds the largest common set of variables that can be integrated
 by all components. If such a set exists, it reconfirms that each component is capable of
 analytically integrating the common set, and combines the components individual integration
 codes into a single integration code valid for RooAddModel.

 Analytical integrations are only supported in non-convoluted form
if (_basisCode!=0) {
return 0 ;
}

_modelProxyIter->Reset() ;
RooResolutionModel* model ;
RooArgSet allAnalVars(allVars) ;
TIterator* avIter = allVars.createIterator() ;

Int_t n(0) ;
 First iteration, determine what each component can integrate analytically
RooRealProxy* proxy ;
while((proxy=(RooRealProxy*)_modelProxyIter->Next())) {
model = (RooResolutionModel*) proxy->absArg() ;
RooArgSet subAnalVars ;
model->getAnalyticalIntegralWN(allVars,subAnalVars,normSet) ;
Int_t subCode = model->getAnalyticalIntegralWN(allVars,subAnalVars,normSet) ;
cout << "RooAddModel::getAI(" << GetName() << ") ITER1 subCode(" << n << "," << model->GetName() << ") = " << subCode << endl ;

Bool_t isDirectGenSafe(const RooAbsArg& arg)

Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK)

 Ask all the components what they can generate

void initGenerator(Int_t code)

 Setup fraction threshold table

TObject* clone(const char* newname)

Bool_t forceAnalyticalInt(const RooAbsArg& dep)

Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName=0)

Bool_t selfNormalized()

void generateEvent(Int_t code)

RooAddModel

class RooAddModel : public RooResolutionModel

Data Members

Class Description