ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooFormula.cxx 24278 2008-06-15 15:21:16Z wouter $
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//
// BEGIN_HTML
// RooFormula an implementation of TFormula that interfaces it to RooAbsArg
// value objects. It allows to use the value of a given list of RooAbsArg objects in the formula
// expression. Reference is done either by the RooAbsArgs name
// or by list ordinal postion ('@0,@1,...'). State information
// of RooAbsCategories can be accessed used the '::' operator,
// e.g. 'tagCat::Kaon' will resolve to the numerical value of
// the 'Kaon' state of the RooAbsCategory object named tagCat.
// END_HTML
//

#include "RooFit.h"

#include "Riostream.h"
#include "Riostream.h"
#include <stdlib.h>
#include "TROOT.h"
#include "TClass.h"
#include "TObjString.h"
#include "RooFormula.h"
#include "RooAbsReal.h"
#include "RooAbsCategory.h"
#include "RooArgList.h"
#include "RooMsgService.h"

ClassImp(RooFormula)


//_____________________________________________________________________________
RooFormula::RooFormula() : TFormula(), _nset(0)
{
  // Default constructor
}


//_____________________________________________________________________________
RooFormula::RooFormula(const char* name, const char* formula, const RooArgList& list) : 
  TFormula(), _isOK(kTRUE), _compiled(kFALSE)
{
  // Constructor with expression string and list of RooAbsArg variables

  SetName(name) ;
  SetTitle(formula) ;

  TIterator* iter = list.createIterator() ;
  RooAbsArg* arg ;
  while ((arg=(RooAbsArg*)iter->Next())) {
    _origList.Add(arg) ;
  }
  delete iter ;

  _compiled = kTRUE ;
  if (Compile()) {
    coutE(InputArguments) << "RooFormula::RooFormula(" << GetName() << "): compile error" << endl ;
    _isOK = kFALSE ;
    return ;
  }
}



//_____________________________________________________________________________
RooFormula::RooFormula(const RooFormula& other, const char* name) : 
  TFormula(), RooPrintable(other), _isOK(other._isOK), _compiled(kFALSE) 
{
  // Copy constructor

  SetName(name?name:other.GetName()) ;
  SetTitle(other.GetTitle()) ;

  TIterator* iter = other._origList.MakeIterator() ;
  RooAbsArg* arg ;
  while ((arg=(RooAbsArg*)iter->Next())) {
    _origList.Add(arg) ;
  }
  delete iter ;
  
  Compile() ;
  _compiled=kTRUE ;
}



//_____________________________________________________________________________
Bool_t RooFormula::reCompile(const char* newFormula) 
{
  // Recompile formula with new expression

  fNval=0 ;
  _useList.Clear() ;  

  TString oldFormula=GetTitle() ;
  if (Compile(newFormula)) {
    coutE(InputArguments) << "RooFormula::reCompile: new equation doesn't compile, formula unchanged" << endl ;
    reCompile(oldFormula) ;    
    return kTRUE ;
  }

  SetTitle(newFormula) ;
  return kFALSE ;
}



//_____________________________________________________________________________
RooFormula::~RooFormula() 
{
  // Destructor

  _labelList.Delete() ;
}



//_____________________________________________________________________________
RooArgSet& RooFormula::actualDependents() const
{
  // Return list of RooAbsArg dependents that is actually used by formula expression

  if (!_compiled) {
    _isOK = !((RooFormula*)this)->Compile() ;
    _compiled = kTRUE ;
  }

  // Return list of dependents used in formula expression

  _actual.removeAll();
  
  int i ;
  for (i=0 ; i<_useList.GetSize() ; i++) {
    _actual.add((RooAbsArg&)*_useList.At(i),kTRUE) ;
  }

  return _actual ;
}



//_____________________________________________________________________________
void RooFormula::dump() 
{
  // DEBUG: Dump state information

  int i ;
  cout << "RooFormula::dump()" << endl ;
  cout << "useList:" << endl ;
  for (i=0 ; i<_useList.GetSize() ; i++) {
    cout << "[" << i << "] = " << (void*) _useList.At(i) << " " << _useList.At(i)->GetName() << endl ;
  }
  cout << "labelList:" << endl ;
  for (i=0 ; i<_labelList.GetSize() ; i++) {
    cout << "[" << i << "] = " << (void*) _labelList.At(i) << " " << _labelList.At(i)->GetName() <<  endl ;
  }
  cout << "origList:" << endl ;
  for (i=0 ; i<_origList.GetSize() ; i++) {
    cout << "[" << i << "] = " << (void*) _origList.At(i)  << " " << _origList.At(i)->GetName() <<  endl ;
  }
}



//_____________________________________________________________________________
Bool_t RooFormula::changeDependents(const RooAbsCollection& newDeps, Bool_t mustReplaceAll, Bool_t nameChange) 
{
  // Change used variables to those with the same name in given list
  // If mustReplaceAll is true and error is generated if one of the
  // elements of newDeps is not found as a server
  
  //Change current servers to new servers with the same name given in list
  Bool_t errorStat(kFALSE) ;
  int i ;

  for (i=0 ; i<_useList.GetSize() ; i++) {
    RooAbsReal* replace = (RooAbsReal*) ((RooAbsArg*)_useList.At(i))->findNewServer(newDeps,nameChange) ;
    if (replace) {
      _useList.Replace(_useList.At(i),replace) ;
    } else if (mustReplaceAll) {
      coutE(LinkStateMgmt) << "RooFormula::changeDependents(1): cannot find replacement for " 
			   << _useList.At(i)->GetName() << endl ;
      errorStat = kTRUE ;
    }
  }  

  TIterator* iter = _origList.MakeIterator() ;
  RooAbsArg* arg ;
  while ((arg=(RooAbsArg*)iter->Next())) {
    RooAbsReal* replace = (RooAbsReal*) arg->findNewServer(newDeps,nameChange) ;
    if (replace) {
      _origList.Replace(arg,replace) ;
    } else if (mustReplaceAll) {
      errorStat = kTRUE ;
    }
  }
  delete iter ;

  return errorStat ;
}



//_____________________________________________________________________________
Double_t RooFormula::eval(const RooArgSet* nset)
{ 
  // Evaluate TFormula using given normalization set to be used as
  // observables definition passed to RooAbsReal::getVal()

  if (!_compiled) {
    _isOK = !Compile() ;
    _compiled = kTRUE ;
  }

  // WVE sanity check should go here
  if (!_isOK) {
    coutE(Eval) << "RooFormula::eval(" << GetName() << "): Formula doesn't compile: " << GetTitle() << endl ;
    return 0. ;
  }

  // Pass current dataset pointer to DefinedValue
  _nset = (RooArgSet*) nset ;

  return EvalPar(0,0) ; 
}


Double_t

//_____________________________________________________________________________
RooFormula::DefinedValue(Int_t code) 
{
  // Interface to TFormula, return value defined by object with id 'code'
  // Object ids are mapped from object names by method DefinedVariable()

  // Return current value for variable indicated by internal reference code
  if (code>=_useList.GetSize()) return 0 ;
  RooAbsArg* arg=(RooAbsArg*)_useList.At(code) ;

  const RooAbsReal *absReal= dynamic_cast<const RooAbsReal*>(arg);  
  if(0 != absReal) {
    return absReal->getVal(_nset) ;
  } else {
    const RooAbsCategory *absCat= dynamic_cast<const RooAbsCategory*>(arg);
    if(0 != absCat) {
      TString& label=((TObjString*)_labelList.At(code))->String() ;
      if (label.IsNull()) {
	return absCat->getIndex() ;
      } else {
	return absCat->lookupType(label)->getVal() ; // DK: why not call getVal(_nset) here also?
      }
    }
  }
  assert(0) ;
  return 0 ;
}



//_____________________________________________________________________________
Int_t RooFormula::DefinedVariable(TString &name, int& action)
{
  // Interface to TFormula. If name passed by TFormula is recognized
  // as one of our RooAbsArg servers, return a unique id integer
  // that represent this variable.

  Int_t ret = DefinedVariable(name) ;
  if (ret>=0) {

#if ROOT_VERSION_CODE >= ROOT_VERSION(4,0,1)
     action = kDefinedVariable;
#else
     action = 0 ; // prevents compiler warning
#endif

  }
  return ret ;
}



//_____________________________________________________________________________
Int_t RooFormula::DefinedVariable(TString &name) 
{
  // Interface to TFormula. If name passed by TFormula is recognized
  // as one of our RooAbsArg servers, return a unique id integer
  // that represent this variable.

  char argName[1024];
  strcpy(argName,name.Data()) ;

  // Find :: operator and split string if found
  char *labelName = strstr(argName,"::") ;
  if (labelName) {
    *labelName = 0 ;
    labelName+= 2 ;
  }

  // Defined internal reference code for given named variable 
  RooAbsArg *arg = 0;
  if (argName[0] == '@') {
    // Access by ordinal number
    Int_t index = atoi(argName+1) ;
    if (index>=0 && index<_origList.GetSize()) {
      arg = (RooAbsArg*) _origList.At(index) ;
    } else {
      coutE(Eval) << "RooFormula::DefinedVariable(" << GetName() 
		  << ") ERROR: ordinal variable reference " << name 
		  << " out of range (0 - " << _origList.GetSize()-1 << ")" << endl ;
    }
  } else {
    // Access by name
    arg= (RooAbsArg*) _origList.FindObject(argName) ;
  }

  // Check that arg exists
  if (!arg) return -1 ;

  // Check that optional label corresponds to actual category state
  if (labelName) {
    RooAbsCategory* cat = dynamic_cast<RooAbsCategory*>(arg) ;
    if (!cat) {
      coutE(Eval) << "RooFormula::DefinedVariable(" << GetName() << ") ERROR: " 
		  << arg->GetName() << "' is not a RooAbsCategory" << endl ;
      return -1 ;
    }

    if (!cat->lookupType(labelName)) {
      coutE(Eval) << "RooFormula::DefinedVariable(" << GetName() << ") ERROR '" 
		  << labelName << "' is not a state of " << arg->GetName() << endl ;
      return -1 ;
    }

  }


  // Check if already registered
  Int_t i ;
  for(i=0 ; i<_useList.GetSize() ; i++) {
    RooAbsArg* var = (RooAbsArg*) _useList.At(i) ;
    Bool_t varMatch = !TString(var->GetName()).CompareTo(arg->GetName()) ;

    if (varMatch) {
      TString& lbl= ((TObjString*) _labelList.At(i))->String() ;
      Bool_t lblMatch(kFALSE) ;
      if (!labelName && lbl.IsNull()) {
	lblMatch=kTRUE ;
      } else if (labelName && !lbl.CompareTo(labelName)) {
	lblMatch=kTRUE ;
      }

      if (lblMatch) {
	// Label and variable name match, recycle entry
	return i ;
      }
    }
  }

  // Register new entry ;
  _useList.Add(arg) ;
  if (!labelName) {
    _labelList.Add(new TObjString("")) ;
  } else {
    _labelList.Add(new TObjString(labelName)) ;
  }

   return (_useList.GetSize()-1) ;
}



//_____________________________________________________________________________
void RooFormula::printMultiline(ostream& os, Int_t /*contents*/, Bool_t /*verbose*/, TString indent) const 
{
  // Printing interface

  os << indent << "--- RooFormula ---" << endl;
  os << indent << "  Formula: \"" << GetTitle() << "\"" << endl;
  indent.Append("  ");
  os << indent << actualDependents() << endl ;
}


//_____________________________________________________________________________
void RooFormula::printValue(ostream& os) const 
{
  // Print value of formula

  os << const_cast<RooFormula*>(this)->eval(0) ;
}


//_____________________________________________________________________________
void RooFormula::printName(ostream& os) const 
{
  // Print name of formula

  os << GetName() ;
}


//_____________________________________________________________________________
void RooFormula::printTitle(ostream& os) const 
{
  // Print title of formula

  os << GetTitle() ;
}


//_____________________________________________________________________________
void RooFormula::printClassName(ostream& os) const 
{
  // Print class name of formula

  os << IsA()->GetName() ;
}


//_____________________________________________________________________________
void RooFormula::printArgs(ostream& os) const 
{
  // Print arguments of formula, i.e. dependents that are actually used

  os << "[ actualVars=" << _actual << " ]" ;
}
 RooFormula.cxx:1
 RooFormula.cxx:2
 RooFormula.cxx:3
 RooFormula.cxx:4
 RooFormula.cxx:5
 RooFormula.cxx:6
 RooFormula.cxx:7
 RooFormula.cxx:8
 RooFormula.cxx:9
 RooFormula.cxx:10
 RooFormula.cxx:11
 RooFormula.cxx:12
 RooFormula.cxx:13
 RooFormula.cxx:14
 RooFormula.cxx:15
 RooFormula.cxx:16
 RooFormula.cxx:17
 RooFormula.cxx:18
 RooFormula.cxx:19
 RooFormula.cxx:20
 RooFormula.cxx:21
 RooFormula.cxx:22
 RooFormula.cxx:23
 RooFormula.cxx:24
 RooFormula.cxx:25
 RooFormula.cxx:26
 RooFormula.cxx:27
 RooFormula.cxx:28
 RooFormula.cxx:29
 RooFormula.cxx:30
 RooFormula.cxx:31
 RooFormula.cxx:32
 RooFormula.cxx:33
 RooFormula.cxx:34
 RooFormula.cxx:35
 RooFormula.cxx:36
 RooFormula.cxx:37
 RooFormula.cxx:38
 RooFormula.cxx:39
 RooFormula.cxx:40
 RooFormula.cxx:41
 RooFormula.cxx:42
 RooFormula.cxx:43
 RooFormula.cxx:44
 RooFormula.cxx:45
 RooFormula.cxx:46
 RooFormula.cxx:47
 RooFormula.cxx:48
 RooFormula.cxx:49
 RooFormula.cxx:50
 RooFormula.cxx:51
 RooFormula.cxx:52
 RooFormula.cxx:53
 RooFormula.cxx:54
 RooFormula.cxx:55
 RooFormula.cxx:56
 RooFormula.cxx:57
 RooFormula.cxx:58
 RooFormula.cxx:59
 RooFormula.cxx:60
 RooFormula.cxx:61
 RooFormula.cxx:62
 RooFormula.cxx:63
 RooFormula.cxx:64
 RooFormula.cxx:65
 RooFormula.cxx:66
 RooFormula.cxx:67
 RooFormula.cxx:68
 RooFormula.cxx:69
 RooFormula.cxx:70
 RooFormula.cxx:71
 RooFormula.cxx:72
 RooFormula.cxx:73
 RooFormula.cxx:74
 RooFormula.cxx:75
 RooFormula.cxx:76
 RooFormula.cxx:77
 RooFormula.cxx:78
 RooFormula.cxx:79
 RooFormula.cxx:80
 RooFormula.cxx:81
 RooFormula.cxx:82
 RooFormula.cxx:83
 RooFormula.cxx:84
 RooFormula.cxx:85
 RooFormula.cxx:86
 RooFormula.cxx:87
 RooFormula.cxx:88
 RooFormula.cxx:89
 RooFormula.cxx:90
 RooFormula.cxx:91
 RooFormula.cxx:92
 RooFormula.cxx:93
 RooFormula.cxx:94
 RooFormula.cxx:95
 RooFormula.cxx:96
 RooFormula.cxx:97
 RooFormula.cxx:98
 RooFormula.cxx:99
 RooFormula.cxx:100
 RooFormula.cxx:101
 RooFormula.cxx:102
 RooFormula.cxx:103
 RooFormula.cxx:104
 RooFormula.cxx:105
 RooFormula.cxx:106
 RooFormula.cxx:107
 RooFormula.cxx:108
 RooFormula.cxx:109
 RooFormula.cxx:110
 RooFormula.cxx:111
 RooFormula.cxx:112
 RooFormula.cxx:113
 RooFormula.cxx:114
 RooFormula.cxx:115
 RooFormula.cxx:116
 RooFormula.cxx:117
 RooFormula.cxx:118
 RooFormula.cxx:119
 RooFormula.cxx:120
 RooFormula.cxx:121
 RooFormula.cxx:122
 RooFormula.cxx:123
 RooFormula.cxx:124
 RooFormula.cxx:125
 RooFormula.cxx:126
 RooFormula.cxx:127
 RooFormula.cxx:128
 RooFormula.cxx:129
 RooFormula.cxx:130
 RooFormula.cxx:131
 RooFormula.cxx:132
 RooFormula.cxx:133
 RooFormula.cxx:134
 RooFormula.cxx:135
 RooFormula.cxx:136
 RooFormula.cxx:137
 RooFormula.cxx:138
 RooFormula.cxx:139
 RooFormula.cxx:140
 RooFormula.cxx:141
 RooFormula.cxx:142
 RooFormula.cxx:143
 RooFormula.cxx:144
 RooFormula.cxx:145
 RooFormula.cxx:146
 RooFormula.cxx:147
 RooFormula.cxx:148
 RooFormula.cxx:149
 RooFormula.cxx:150
 RooFormula.cxx:151
 RooFormula.cxx:152
 RooFormula.cxx:153
 RooFormula.cxx:154
 RooFormula.cxx:155
 RooFormula.cxx:156
 RooFormula.cxx:157
 RooFormula.cxx:158
 RooFormula.cxx:159
 RooFormula.cxx:160
 RooFormula.cxx:161
 RooFormula.cxx:162
 RooFormula.cxx:163
 RooFormula.cxx:164
 RooFormula.cxx:165
 RooFormula.cxx:166
 RooFormula.cxx:167
 RooFormula.cxx:168
 RooFormula.cxx:169
 RooFormula.cxx:170
 RooFormula.cxx:171
 RooFormula.cxx:172
 RooFormula.cxx:173
 RooFormula.cxx:174
 RooFormula.cxx:175
 RooFormula.cxx:176
 RooFormula.cxx:177
 RooFormula.cxx:178
 RooFormula.cxx:179
 RooFormula.cxx:180
 RooFormula.cxx:181
 RooFormula.cxx:182
 RooFormula.cxx:183
 RooFormula.cxx:184
 RooFormula.cxx:185
 RooFormula.cxx:186
 RooFormula.cxx:187
 RooFormula.cxx:188
 RooFormula.cxx:189
 RooFormula.cxx:190
 RooFormula.cxx:191
 RooFormula.cxx:192
 RooFormula.cxx:193
 RooFormula.cxx:194
 RooFormula.cxx:195
 RooFormula.cxx:196
 RooFormula.cxx:197
 RooFormula.cxx:198
 RooFormula.cxx:199
 RooFormula.cxx:200
 RooFormula.cxx:201
 RooFormula.cxx:202
 RooFormula.cxx:203
 RooFormula.cxx:204
 RooFormula.cxx:205
 RooFormula.cxx:206
 RooFormula.cxx:207
 RooFormula.cxx:208
 RooFormula.cxx:209
 RooFormula.cxx:210
 RooFormula.cxx:211
 RooFormula.cxx:212
 RooFormula.cxx:213
 RooFormula.cxx:214
 RooFormula.cxx:215
 RooFormula.cxx:216
 RooFormula.cxx:217
 RooFormula.cxx:218
 RooFormula.cxx:219
 RooFormula.cxx:220
 RooFormula.cxx:221
 RooFormula.cxx:222
 RooFormula.cxx:223
 RooFormula.cxx:224
 RooFormula.cxx:225
 RooFormula.cxx:226
 RooFormula.cxx:227
 RooFormula.cxx:228
 RooFormula.cxx:229
 RooFormula.cxx:230
 RooFormula.cxx:231
 RooFormula.cxx:232
 RooFormula.cxx:233
 RooFormula.cxx:234
 RooFormula.cxx:235
 RooFormula.cxx:236
 RooFormula.cxx:237
 RooFormula.cxx:238
 RooFormula.cxx:239
 RooFormula.cxx:240
 RooFormula.cxx:241
 RooFormula.cxx:242
 RooFormula.cxx:243
 RooFormula.cxx:244
 RooFormula.cxx:245
 RooFormula.cxx:246
 RooFormula.cxx:247
 RooFormula.cxx:248
 RooFormula.cxx:249
 RooFormula.cxx:250
 RooFormula.cxx:251
 RooFormula.cxx:252
 RooFormula.cxx:253
 RooFormula.cxx:254
 RooFormula.cxx:255
 RooFormula.cxx:256
 RooFormula.cxx:257
 RooFormula.cxx:258
 RooFormula.cxx:259
 RooFormula.cxx:260
 RooFormula.cxx:261
 RooFormula.cxx:262
 RooFormula.cxx:263
 RooFormula.cxx:264
 RooFormula.cxx:265
 RooFormula.cxx:266
 RooFormula.cxx:267
 RooFormula.cxx:268
 RooFormula.cxx:269
 RooFormula.cxx:270
 RooFormula.cxx:271
 RooFormula.cxx:272
 RooFormula.cxx:273
 RooFormula.cxx:274
 RooFormula.cxx:275
 RooFormula.cxx:276
 RooFormula.cxx:277
 RooFormula.cxx:278
 RooFormula.cxx:279
 RooFormula.cxx:280
 RooFormula.cxx:281
 RooFormula.cxx:282
 RooFormula.cxx:283
 RooFormula.cxx:284
 RooFormula.cxx:285
 RooFormula.cxx:286
 RooFormula.cxx:287
 RooFormula.cxx:288
 RooFormula.cxx:289
 RooFormula.cxx:290
 RooFormula.cxx:291
 RooFormula.cxx:292
 RooFormula.cxx:293
 RooFormula.cxx:294
 RooFormula.cxx:295
 RooFormula.cxx:296
 RooFormula.cxx:297
 RooFormula.cxx:298
 RooFormula.cxx:299
 RooFormula.cxx:300
 RooFormula.cxx:301
 RooFormula.cxx:302
 RooFormula.cxx:303
 RooFormula.cxx:304
 RooFormula.cxx:305
 RooFormula.cxx:306
 RooFormula.cxx:307
 RooFormula.cxx:308
 RooFormula.cxx:309
 RooFormula.cxx:310
 RooFormula.cxx:311
 RooFormula.cxx:312
 RooFormula.cxx:313
 RooFormula.cxx:314
 RooFormula.cxx:315
 RooFormula.cxx:316
 RooFormula.cxx:317
 RooFormula.cxx:318
 RooFormula.cxx:319
 RooFormula.cxx:320
 RooFormula.cxx:321
 RooFormula.cxx:322
 RooFormula.cxx:323
 RooFormula.cxx:324
 RooFormula.cxx:325
 RooFormula.cxx:326
 RooFormula.cxx:327
 RooFormula.cxx:328
 RooFormula.cxx:329
 RooFormula.cxx:330
 RooFormula.cxx:331
 RooFormula.cxx:332
 RooFormula.cxx:333
 RooFormula.cxx:334
 RooFormula.cxx:335
 RooFormula.cxx:336
 RooFormula.cxx:337
 RooFormula.cxx:338
 RooFormula.cxx:339
 RooFormula.cxx:340
 RooFormula.cxx:341
 RooFormula.cxx:342
 RooFormula.cxx:343
 RooFormula.cxx:344
 RooFormula.cxx:345
 RooFormula.cxx:346
 RooFormula.cxx:347
 RooFormula.cxx:348
 RooFormula.cxx:349
 RooFormula.cxx:350
 RooFormula.cxx:351
 RooFormula.cxx:352
 RooFormula.cxx:353
 RooFormula.cxx:354
 RooFormula.cxx:355
 RooFormula.cxx:356
 RooFormula.cxx:357
 RooFormula.cxx:358
 RooFormula.cxx:359
 RooFormula.cxx:360
 RooFormula.cxx:361
 RooFormula.cxx:362
 RooFormula.cxx:363
 RooFormula.cxx:364
 RooFormula.cxx:365
 RooFormula.cxx:366
 RooFormula.cxx:367
 RooFormula.cxx:368
 RooFormula.cxx:369
 RooFormula.cxx:370
 RooFormula.cxx:371
 RooFormula.cxx:372
 RooFormula.cxx:373
 RooFormula.cxx:374
 RooFormula.cxx:375
 RooFormula.cxx:376
 RooFormula.cxx:377
 RooFormula.cxx:378
 RooFormula.cxx:379
 RooFormula.cxx:380
 RooFormula.cxx:381
 RooFormula.cxx:382
 RooFormula.cxx:383
 RooFormula.cxx:384
 RooFormula.cxx:385
 RooFormula.cxx:386
 RooFormula.cxx:387
 RooFormula.cxx:388
 RooFormula.cxx:389
 RooFormula.cxx:390
 RooFormula.cxx:391
 RooFormula.cxx:392
 RooFormula.cxx:393
 RooFormula.cxx:394
 RooFormula.cxx:395
 RooFormula.cxx:396
 RooFormula.cxx:397
 RooFormula.cxx:398
 RooFormula.cxx:399
 RooFormula.cxx:400
 RooFormula.cxx:401
 RooFormula.cxx:402
 RooFormula.cxx:403
 RooFormula.cxx:404
 RooFormula.cxx:405
 RooFormula.cxx:406
 RooFormula.cxx:407
 RooFormula.cxx:408
 RooFormula.cxx:409
 RooFormula.cxx:410
 RooFormula.cxx:411
 RooFormula.cxx:412
 RooFormula.cxx:413
 RooFormula.cxx:414
 RooFormula.cxx:415
 RooFormula.cxx:416
 RooFormula.cxx:417
 RooFormula.cxx:418
 RooFormula.cxx:419
 RooFormula.cxx:420
 RooFormula.cxx:421
 RooFormula.cxx:422
 RooFormula.cxx:423
 RooFormula.cxx:424
 RooFormula.cxx:425
 RooFormula.cxx:426
 RooFormula.cxx:427
 RooFormula.cxx:428
 RooFormula.cxx:429
 RooFormula.cxx:430
 RooFormula.cxx:431
 RooFormula.cxx:432
 RooFormula.cxx:433
 RooFormula.cxx:434
 RooFormula.cxx:435
 RooFormula.cxx:436
 RooFormula.cxx:437
 RooFormula.cxx:438
 RooFormula.cxx:439
 RooFormula.cxx:440
 RooFormula.cxx:441