ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooAddition.cxx 42265 2011-11-27 10:05:30Z 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
// RooAddition calculates the sum of a set of RooAbsReal terms, or
// when constructed with two sets, it sums the product of the terms
// in the two sets. This class does not (yet) do any smart handling of integrals, 
// i.e. all integrals of the product are handled numerically
// END_HTML
//


#include "RooFit.h"

#include "Riostream.h"
#include <math.h>
#include <memory>
#include <list>
#include <algorithm>
using namespace std ;

#include "RooAddition.h"
#include "RooProduct.h"
#include "RooAbsReal.h"
#include "RooErrorHandler.h"
#include "RooArgSet.h"
#include "RooNameReg.h"
#include "RooNLLVar.h"
#include "RooChi2Var.h"
#include "RooMsgService.h"

ClassImp(RooAddition)
;


//_____________________________________________________________________________
RooAddition::RooAddition()
  : _setIter( _set.createIterator() )
{
}



//_____________________________________________________________________________
RooAddition::RooAddition(const char* name, const char* title, const RooArgSet& sumSet, Bool_t takeOwnership) 
  : RooAbsReal(name, title)
  , _set("!set","set of components",this)
  , _setIter( _set.createIterator() ) // yes, _setIter is defined _after_ _set ;-)
  , _cacheMgr(this,10)
{
  // Constructor with a single set of RooAbsReals. The value of the function will be
  // the sum of the values in sumSet. If takeOwnership is true the RooAddition object
  // will take ownership of the arguments in sumSet

  std::auto_ptr<TIterator> inputIter( sumSet.createIterator() );
  RooAbsArg* comp ;
  while((comp = (RooAbsArg*)inputIter->Next())) {
    if (!dynamic_cast<RooAbsReal*>(comp)) {
      coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp->GetName() 
			    << " is not of type RooAbsReal" << endl ;
      RooErrorHandler::softAbort() ;
    }
    _set.add(*comp) ;
    if (takeOwnership) _ownedList.addOwned(*comp) ;
  }

}



//_____________________________________________________________________________
RooAddition::RooAddition(const char* name, const char* title, const RooArgList& sumSet1, const RooArgList& sumSet2, Bool_t takeOwnership) 
    : RooAbsReal(name, title)
    , _set("!set","set of components",this)
    , _setIter( _set.createIterator() ) // yes, _setIter is defined _after_ _set ;-)
    , _cacheMgr(this,10)
{
  // Constructor with two set of RooAbsReals. The value of the function will be
  //
  //  A = sum_i sumSet1(i)*sumSet2(i) 
  //
  // If takeOwnership is true the RooAddition object will take ownership of the arguments in sumSet

  if (sumSet1.getSize() != sumSet2.getSize()) {
    coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: input lists should be of equal length" << endl ;
    RooErrorHandler::softAbort() ;    
  }

  std::auto_ptr<TIterator> inputIter1( sumSet1.createIterator() );
  std::auto_ptr<TIterator> inputIter2( sumSet2.createIterator() );
  RooAbsArg *comp1(0),*comp2(0) ;
  while((comp1 = (RooAbsArg*)inputIter1->Next())) {
    if (!dynamic_cast<RooAbsReal*>(comp1)) {
      coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp1->GetName() 
			    << " in first list is not of type RooAbsReal" << endl ;
      RooErrorHandler::softAbort() ;
    }
    comp2 = (RooAbsArg*)inputIter2->Next();
    if (!dynamic_cast<RooAbsReal*>(comp2)) {
      coutE(InputArguments) << "RooAddition::ctor(" << GetName() << ") ERROR: component " << comp2->GetName() 
			    << " in first list is not of type RooAbsReal" << endl ;
      RooErrorHandler::softAbort() ;
    }
    // TODO: add flag to RooProduct c'tor to make it assume ownership...
    TString _name(name);
    _name.Append( "_[");
    _name.Append(comp1->GetName());
    _name.Append( "_x_");
    _name.Append(comp2->GetName());
    _name.Append( "]");
    RooProduct  *prod = new RooProduct( _name, _name , RooArgSet(*comp1, *comp2) /*, takeOwnership */ ) ;
    _set.add(*prod);
    _ownedList.addOwned(*prod) ;
    if (takeOwnership) {
        _ownedList.addOwned(*comp1) ;
        _ownedList.addOwned(*comp2) ;
    }
  }
}



//_____________________________________________________________________________
RooAddition::RooAddition(const RooAddition& other, const char* name) 
    : RooAbsReal(other, name)
    , _set("!set",this,other._set)
    , _setIter( _set.createIterator() ) // yes, _setIter is defined _after_ _set ;-)
    , _cacheMgr(other._cacheMgr,this)
{
  // Copy constructor
  
  // Member _ownedList is intentionally not copy-constructed -- ownership is not transferred
}


//_____________________________________________________________________________
RooAddition::~RooAddition() 
{ // Destructor
  delete _setIter ;
}

//_____________________________________________________________________________
Double_t RooAddition::evaluate() const 
{
  // Calculate and return current value of self
  Double_t sum(0);
  const RooArgSet* nset = _set.nset() ;

//   cout << "RooAddition::eval sum = " ;

  RooFIter setIter = _set.fwdIterator() ;
  RooAbsReal* comp ;
  while((comp=(RooAbsReal*)setIter.next())) {
    Double_t tmp = comp->getVal(nset) ;
//     cout << tmp << " " ;
    sum += tmp ;
  }
//   cout << " = " << sum << endl ;
  return sum ;
}

//_____________________________________________________________________________
Double_t RooAddition::defaultErrorLevel() const 
{
  // Return the default error level for MINUIT error analysis
  // If the addition contains one or more RooNLLVars and 
  // no RooChi2Vars, return the defaultErrorLevel() of
  // RooNLLVar. If the addition contains one ore more RooChi2Vars
  // and no RooNLLVars, return the defaultErrorLevel() of
  // RooChi2Var. If the addition contains neither or both
  // issue a warning message and return a value of 1

  RooAbsReal* nllArg(0) ;
  RooAbsReal* chi2Arg(0) ;

  RooAbsArg* arg ;

  RooArgSet* comps = getComponents() ;
  TIterator* iter = comps->createIterator() ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (dynamic_cast<RooNLLVar*>(arg)) {
      nllArg = (RooAbsReal*)arg ;
    }
    if (dynamic_cast<RooChi2Var*>(arg)) {
      chi2Arg = (RooAbsReal*)arg ;
    }
  }
  delete iter ;
  delete comps ;

  if (nllArg && !chi2Arg) {
    coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() 
		   << ") Summation contains a RooNLLVar, using its error level" << endl ;
    return nllArg->defaultErrorLevel() ;
  } else if (chi2Arg && !nllArg) {
    coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() 
		   << ") Summation contains a RooChi2Var, using its error level" << endl ;
    return chi2Arg->defaultErrorLevel() ;
  } else if (!nllArg && !chi2Arg) {
    coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
		   << "Summation contains neither RooNLLVar nor RooChi2Var server, using default level of 1.0" << endl ;
  } else {
    coutI(Fitting) << "RooAddition::defaultErrorLevel(" << GetName() << ") WARNING: "
		   << "Summation contains BOTH RooNLLVar and RooChi2Var server, using default level of 1.0" << endl ;
  }

  return 1.0 ;
}



//_____________________________________________________________________________
Bool_t RooAddition::setData(RooAbsData& data, Bool_t cloneData) 
{
  _setIter->Reset() ;

  RooAbsReal* arg;
  while((arg=(RooAbsReal*)_setIter->Next())) {
    arg->setData(data,cloneData) ;
  }  
  return kTRUE ;
}



//_____________________________________________________________________________
void RooAddition::printMetaArgs(ostream& os) const 
{
  _setIter->Reset() ;

  Bool_t first(kTRUE) ;
  RooAbsArg* arg;
  while((arg=(RooAbsArg*)_setIter->Next())) {
    if (!first) { os << " + " ;
    } else { first = kFALSE ; 
    }
    os << arg->GetName() ; 
  }  
  os << " " ;    
}

//_____________________________________________________________________________
Int_t RooAddition::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const
{
  
  // we always do things ourselves -- actually, always delegate further down the line ;-)
  analVars.add(allVars);

  // check if we already have integrals for this combination of factors
  Int_t sterileIndex(-1);
  CacheElem* cache = (CacheElem*) _cacheMgr.getObj(&analVars,&analVars,&sterileIndex,RooNameReg::ptr(rangeName));
  if (cache!=0) {
    Int_t code = _cacheMgr.lastIndex();
    return code+1;
  }

  // we don't, so we make it right here....
  cache = new CacheElem;
  _setIter->Reset();
  RooAbsReal *arg(0);
  while( (arg=(RooAbsReal*)_setIter->Next())!=0 ) {  // checked in c'tor that this will work...
      RooAbsReal *I = arg->createIntegral(analVars,rangeName);
      cache->_I.addOwned(*I);
  }

  Int_t code = _cacheMgr.setObj(&analVars,&analVars,(RooAbsCacheElement*)cache,RooNameReg::ptr(rangeName));
  return 1+code;
}

//_____________________________________________________________________________
Double_t RooAddition::analyticalIntegral(Int_t code, const char* rangeName) const 
{
  // Calculate integral internally from appropriate integral cache

  // note: rangeName implicit encoded in code: see _cacheMgr.setObj in getPartIntList...
  CacheElem *cache = (CacheElem*) _cacheMgr.getObjByIndex(code-1);
  if (cache==0) {
    // cache got sterilized, trigger repopulation of this slot, then try again...
    std::auto_ptr<RooArgSet> vars( getParameters(RooArgSet()) );
    std::auto_ptr<RooArgSet> iset(  _cacheMgr.nameSet2ByIndex(code-1)->select(*vars) );
    RooArgSet dummy;
    Int_t code2 = getAnalyticalIntegral(*iset,dummy,rangeName);
    assert(code==code2); // must have revived the right (sterilized) slot...
    return analyticalIntegral(code2,rangeName);
  }
  assert(cache!=0);

  // loop over cache, and sum...
  std::auto_ptr<TIterator> iter( cache->_I.createIterator() );
  RooAbsReal *I;
  double result(0);
  while ( ( I=(RooAbsReal*)iter->Next() ) != 0 ) result += I->getVal();
  return result;

}



//_____________________________________________________________________________
std::list<Double_t>* RooAddition::binBoundaries(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const
{
  std::list<Double_t>* sumBinB = 0 ;
  Bool_t needClean(kFALSE) ;
  
  RooFIter iter = _set.fwdIterator() ;
  RooAbsReal* func ;
  // Loop over components pdf
  while((func=(RooAbsReal*)iter.next())) {

    std::list<Double_t>* funcBinB = func->binBoundaries(obs,xlo,xhi) ;
    
    // Process hint
    if (funcBinB) {
      if (!sumBinB) {
	// If this is the first hint, then just save it
	sumBinB = funcBinB ;
      } else {
	
	std::list<Double_t>* newSumBinB = new std::list<Double_t>(sumBinB->size()+funcBinB->size()) ;

	// Merge hints into temporary array
	merge(funcBinB->begin(),funcBinB->end(),sumBinB->begin(),sumBinB->end(),newSumBinB->begin()) ;
	
	// Copy merged array without duplicates to new sumBinBArrau
	delete sumBinB ;
	delete funcBinB ;
	sumBinB = newSumBinB ;
	needClean = kTRUE ;	
      }
    }
  }

  // Remove consecutive duplicates
  if (needClean) {
    std::list<Double_t>::iterator new_end = unique(sumBinB->begin(),sumBinB->end()) ;
    sumBinB->erase(new_end,sumBinB->end()) ;
  }

  return sumBinB ;
}


//_____________________________________________________________________________B
Bool_t RooAddition::isBinnedDistribution(const RooArgSet& obs) const 
{
  // If all components that depend on obs are binned that so is the product
  
  RooFIter iter = _set.fwdIterator() ;
  RooAbsReal* func ;
  while((func=(RooAbsReal*)iter.next())) {
    if (func->dependsOn(obs) && !func->isBinnedDistribution(obs)) {
      return kFALSE ;
    }
  }
  
  return kTRUE  ;  
}




//_____________________________________________________________________________
std::list<Double_t>* RooAddition::plotSamplingHint(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const
{
  std::list<Double_t>* sumHint = 0 ;
  Bool_t needClean(kFALSE) ;
  
  RooFIter iter = _set.fwdIterator() ;
  RooAbsReal* func ;
  // Loop over components pdf
  while((func=(RooAbsReal*)iter.next())) {
    
    std::list<Double_t>* funcHint = func->plotSamplingHint(obs,xlo,xhi) ;
    
    // Process hint
    if (funcHint) {
      if (!sumHint) {

	// If this is the first hint, then just save it
	sumHint = funcHint ;

      } else {
	
	std::list<Double_t>* newSumHint = new std::list<Double_t>(sumHint->size()+funcHint->size()) ;
	
	// Merge hints into temporary array
	merge(funcHint->begin(),funcHint->end(),sumHint->begin(),sumHint->end(),newSumHint->begin()) ;

	// Copy merged array without duplicates to new sumHintArrau
	delete sumHint ;
	sumHint = newSumHint ;
	needClean = kTRUE ;	
      }
    }
  }

  // Remove consecutive duplicates
  if (needClean) {
    std::list<Double_t>::iterator new_end = unique(sumHint->begin(),sumHint->end()) ;
    sumHint->erase(new_end,sumHint->end()) ;
  }

  return sumHint ;
}



//_____________________________________________________________________________
RooArgList RooAddition::CacheElem::containedArgs(Action)
{
  // Return list of all RooAbsArgs in cache element
  RooArgList ret(_I) ;
  return ret ;
}

RooAddition::CacheElem::~CacheElem()
{
  // Destructor
}


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