/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id$
 * 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
// RooAbsOptTestStatistic is the abstract base class for test
// statistics objects that evaluate a function or PDF at each point of a given
// dataset.  This class provides generic optimizations, such as
// caching and precalculation of constant terms that can be made for
// all such quantities
//
// Implementations should define evaluatePartition(), which calculates the
// value of a (sub)range of the dataset and optionally combinedValue(),
// which combines the values calculated for each partition. If combinedValue()
// is not overloaded, the default implementation will add the partition results
// to obtain the combined result
//
// Support for calculation in partitions is needed to allow multi-core
// parallelized calculation of test statistics
// END_HTML
//
//

#include "RooFit.h"

#include "Riostream.h"
#include <string.h>


#include "RooAbsOptTestStatistic.h"
#include "RooMsgService.h"
#include "RooAbsPdf.h"
#include "RooAbsData.h"
#include "RooDataHist.h"
#include "RooArgSet.h"
#include "RooRealVar.h"
#include "RooErrorHandler.h"
#include "RooGlobalFunc.h"
#include "RooBinning.h"
#include "RooAbsDataStore.h"
#include "RooCategory.h"
#include "RooDataSet.h"
#include "RooProdPdf.h"
#include "RooAddPdf.h"
#include "RooProduct.h"
#include "RooRealSumPdf.h"
#include "RooTrace.h"
#include "RooVectorDataStore.h" 

using namespace std;

ClassImp(RooAbsOptTestStatistic)
;


//_____________________________________________________________________________
RooAbsOptTestStatistic:: RooAbsOptTestStatistic()
{
  // Default Constructor

  // Initialize all non-persisted data members

  _funcObsSet = 0 ;
  _funcCloneSet = 0 ;
  _funcClone = 0 ;

  _normSet = 0 ;
  _dataClone = 0 ;
  _projDeps = 0 ;

  _origFunc = 0 ;
  _origData = 0 ;

  _ownData = kTRUE ;
  _sealed = kFALSE ;
  _optimized = kFALSE ;
}



//_____________________________________________________________________________
RooAbsOptTestStatistic::RooAbsOptTestStatistic(const char *name, const char *title, RooAbsReal& real, RooAbsData& indata,
					       const RooArgSet& projDeps, const char* rangeName, const char* addCoefRangeName,
					       Int_t nCPU, RooFit::MPSplit interleave, Bool_t verbose, Bool_t splitCutRange, Bool_t /*cloneInputData*/) : 
  RooAbsTestStatistic(name,title,real,indata,projDeps,rangeName, addCoefRangeName, nCPU, interleave, verbose, splitCutRange),
  _projDeps(0),
  _sealed(kFALSE), 
  _optimized(kFALSE)
{
  // Constructor taking function (real), a dataset (data), a set of projected observables (projSet). If 
  // rangeName is not null, only events in the dataset inside the range will be used in the test
  // statistic calculation. If addCoefRangeName is not null, all RooAddPdf component of 'real' will be
  // instructed to fix their fraction definitions to the given named range. If nCPU is greater than
  // 1 the test statistic calculation will be paralellized over multiple processes. By default the data
  // is split with 'bulk' partitioning (each process calculates a contigious block of fraction 1/nCPU
  // of the data). For binned data this approach may be suboptimal as the number of bins with >0 entries
  // in each processing block many vary greatly thereby distributing the workload rather unevenly.
  // If interleave is set to true, the interleave partitioning strategy is used where each partition
  // i takes all bins for which (ibin % ncpu == i) which is more likely to result in an even workload.
  // If splitCutRange is true, a different rangeName constructed as rangeName_{catName} will be used
  // as range definition for each index state of a RooSimultaneous

  // Don't do a thing in master mode

  if (operMode()!=Slave) {
    _funcObsSet = 0 ;
    _funcCloneSet = 0 ;
    _funcClone = 0 ;
    _normSet = 0 ;
    _dataClone = 0 ;
    _projDeps = 0 ;    
    _origFunc = 0 ;
    _origData = 0 ;
    _ownData = kFALSE ;
    _sealed = kFALSE ;
    return ;
  }

  _origFunc = 0 ; //other._origFunc ;
  _origData = 0 ; // other._origData ;

  initSlave(real,indata,projDeps,rangeName,addCoefRangeName) ;
}

//_____________________________________________________________________________
RooAbsOptTestStatistic::RooAbsOptTestStatistic(const RooAbsOptTestStatistic& other, const char* name) : 
  RooAbsTestStatistic(other,name), _sealed(other._sealed), _sealNotice(other._sealNotice), _optimized(kFALSE)
{
  // Copy constructor

  // Don't do a thing in master mode
  if (operMode()!=Slave) {    

    _funcObsSet = 0 ;
    _funcCloneSet = 0 ;
    _funcClone = 0 ;
    _normSet = other._normSet ? ((RooArgSet*) other._normSet->snapshot()) : 0 ;   
    _dataClone = 0 ;
    _projDeps = 0 ;    
    _origFunc = 0 ;
    _origData = 0 ;
    _ownData = kFALSE ;
    return ;
  }
  
  _origFunc = 0 ; //other._origFunc ;
  _origData = 0 ; // other._origData ;
  _projDeps = 0 ;
  
  initSlave(*other._funcClone,*other._dataClone,other._projDeps?*other._projDeps:RooArgSet(),other._rangeName.c_str(),other._addCoefRangeName.c_str()) ;
}



//_____________________________________________________________________________
void RooAbsOptTestStatistic::initSlave(RooAbsReal& real, RooAbsData& indata, const RooArgSet& projDeps, const char* rangeName, 
				       const char* addCoefRangeName) 
{
  RooArgSet obs(*indata.get()) ;
  obs.remove(projDeps,kTRUE,kTRUE) ;


  // ******************************************************************
  // *** PART 1 *** Clone incoming pdf, attach to each other *
  // ******************************************************************

  // Clone FUNC
  _funcClone = (RooAbsReal*) real.cloneTree() ;
  _funcCloneSet = 0 ;

  // Attach FUNC to data set  
  _funcObsSet = _funcClone->getObservables(indata) ;

  if (_funcClone->getAttribute("BinnedLikelihood")) {
    _funcClone->setAttribute("BinnedLikelihoodActive") ;
  }

  // Reattach FUNC to original parameters  
  RooArgSet* origParams = (RooArgSet*) real.getParameters(indata) ;
  _funcClone->recursiveRedirectServers(*origParams) ;

    // Mark all projected dependents as such
  if (projDeps.getSize()>0) {
    RooArgSet *projDataDeps = (RooArgSet*) _funcObsSet->selectCommon(projDeps) ;
    projDataDeps->setAttribAll("projectedDependent") ;
    delete projDataDeps ;    
  }

  // If PDF is a RooProdPdf (with possible constraint terms)
  // analyze pdf for actual parameters (i.e those in unconnected constraint terms should be
  // ignored as here so that the test statistic will not be recalculated if those
  // are changed
  RooProdPdf* pdfWithCons = dynamic_cast<RooProdPdf*>(_funcClone) ;
  if (pdfWithCons) {
    
    RooArgSet* connPars = pdfWithCons->getConnectedParameters(*indata.get()) ;
    // Add connected parameters as servers
    _paramSet.removeAll() ;
    _paramSet.add(*connPars) ;
    delete connPars ;

  } else {
    // Add parameters as servers
    _paramSet.add(*origParams) ;
  }


  delete origParams ;

  // Store normalization set  
  _normSet = (RooArgSet*) indata.get()->snapshot(kFALSE) ;

  // Expand list of observables with any observables used in parameterized ranges
  RooAbsArg* realDep ;
  RooFIter iter = _funcObsSet->fwdIterator() ;
  while((realDep=iter.next())) {
    RooAbsRealLValue* realDepRLV = dynamic_cast<RooAbsRealLValue*>(realDep) ;
    if (realDepRLV && realDepRLV->isDerived()) {
      RooArgSet tmp2 ;
      realDepRLV->leafNodeServerList(&tmp2, 0, kTRUE) ;
      _funcObsSet->add(tmp2,kTRUE) ;
    }
  }



  // ******************************************************************
  // *** PART 2 *** Clone and adjust incoming data, attach to PDF     *
  // ******************************************************************
  
  // Check if the fit ranges of the dependents in the data and in the FUNC are consistent
  const RooArgSet* dataDepSet = indata.get() ;
  iter = _funcObsSet->fwdIterator() ;
  RooAbsArg* arg ;
  while((arg=iter.next())) {

    // Check that both dataset and function argument are of type RooRealVar
    RooRealVar* realReal = dynamic_cast<RooRealVar*>(arg) ;
    if (!realReal) continue ;
    RooRealVar* datReal = dynamic_cast<RooRealVar*>(dataDepSet->find(realReal->GetName())) ;
    if (!datReal) continue ;
    
    // Check that range of observables in pdf is equal or contained in range of observables in data
 
   if (!realReal->getBinning().lowBoundFunc() && realReal->getMin()<(datReal->getMin()-1e-6)) {
      coutE(InputArguments) << "RooAbsOptTestStatistic: ERROR minimum of FUNC observable " << arg->GetName() 
			    << "(" << realReal->getMin() << ") is smaller than that of " 
			    << arg->GetName() << " in the dataset (" << datReal->getMin() << ")" << endl ;
      RooErrorHandler::softAbort() ;
      return ;
    }
    
    if (!realReal->getBinning().highBoundFunc() && realReal->getMax()>(datReal->getMax()+1e-6)) {
      coutE(InputArguments) << "RooAbsOptTestStatistic: ERROR maximum of FUNC observable " << arg->GetName() 
			    << " is larger than that of " << arg->GetName() << " in the dataset" << endl ;
      RooErrorHandler::softAbort() ;
      return ;
    }
    
  }
  
  // Copy data and strip entries lost by adjusted fit range, _dataClone ranges will be copied from realDepSet ranges
  if (rangeName && strlen(rangeName)) {
    _dataClone = ((RooAbsData&)indata).reduce(RooFit::SelectVars(*_funcObsSet),RooFit::CutRange(rangeName)) ;  
//     cout << "RooAbsOptTestStatistic: reducing dataset to fit in range named " << rangeName << " resulting dataset has " << _dataClone->sumEntries() << " events" << endl ;
  } else {
    _dataClone = (RooAbsData*) indata.Clone() ;
  }
  _ownData = kTRUE ;  
 

  // ******************************************************************
  // *** PART 3 *** Make adjustments for fit ranges, if specified     *
  // ****************************************************************** 

  RooArgSet* origObsSet = real.getObservables(indata) ;
  RooArgSet* dataObsSet = (RooArgSet*) _dataClone->get() ;
  if (rangeName && strlen(rangeName)) {    
    cxcoutI(Fitting) << "RooAbsOptTestStatistic::ctor(" << GetName() << ") constructing test statistic for sub-range named " << rangeName << endl ;    
    //cout << "now adjusting observable ranges to requested fit range" << endl ;

    // Adjust FUNC normalization ranges to requested fitRange, store original ranges for RooAddPdf coefficient interpretation
    iter = _funcObsSet->fwdIterator() ;
    while((arg=iter.next())) {

      RooRealVar* realObs = dynamic_cast<RooRealVar*>(arg) ;
      if (realObs) {

	// If no explicit range is given for RooAddPdf coefficients, create explicit named range equivalent to original observables range
        if (!(addCoefRangeName && strlen(addCoefRangeName))) {
	  realObs->setRange(Form("NormalizationRangeFor%s",rangeName),realObs->getMin(),realObs->getMax()) ;
// 	  cout << "RAOTS::ctor() setting range " << Form("NormalizationRangeFor%s",rangeName) << " on observable " 
// 	       << realObs->GetName() << " to [" << realObs->getMin() << "," << realObs->getMax() << "]" << endl ;
	}

	// Adjust range of function observable to those of given named range
	realObs->setRange(realObs->getMin(rangeName),realObs->getMax(rangeName)) ;	
//  	cout << "RAOTS::ctor() setting normalization range on observable " 
//  	     << realObs->GetName() << " to [" << realObs->getMin() << "," << realObs->getMax() << "]" << endl ;

	// Adjust range of data observable to those of given named range
	RooRealVar* dataObs = (RooRealVar*) dataObsSet->find(realObs->GetName()) ;
	dataObs->setRange(realObs->getMin(rangeName),realObs->getMax(rangeName)) ;	
       
	// Keep track of list of fit ranges in string attribute fit range of original p.d.f.
	if (!_splitRange) {
	  const char* origAttrib = real.getStringAttribute("fitrange") ;	  
	  if (origAttrib) {
	    real.setStringAttribute("fitrange",Form("%s,fit_%s",origAttrib,GetName())) ;
	  } else {
	    real.setStringAttribute("fitrange",Form("fit_%s",GetName())) ;
	  }
	  RooRealVar* origObs = (RooRealVar*) origObsSet->find(arg->GetName()) ;
	  if (origObs) {
	    origObs->setRange(Form("fit_%s",GetName()),realObs->getMin(rangeName),realObs->getMax(rangeName)) ;
	  }
	}
	
      }
    }
  }
  delete origObsSet ;

  // If dataset is binned, activate caching of bins that are invalid because the're outside the
  // updated range definition (WVE need to add virtual interface here)
  RooDataHist* tmph = dynamic_cast<RooDataHist*>(_dataClone) ;
  if (tmph) {
    tmph->cacheValidEntries() ;
  }
        
  // Fix RooAddPdf coefficients to original normalization range
  if (rangeName && strlen(rangeName)) {
    
    // WVE Remove projected dependents from normalization
    _funcClone->fixAddCoefNormalization(*_dataClone->get(),kFALSE) ;
    
    if (addCoefRangeName && strlen(addCoefRangeName)) {
      cxcoutI(Fitting) << "RooAbsOptTestStatistic::ctor(" << GetName() 
		       << ") fixing interpretation of coefficients of any RooAddPdf component to range " << addCoefRangeName << endl ;
      _funcClone->fixAddCoefRange(addCoefRangeName,kFALSE) ;
    } else {
	cxcoutI(Fitting) << "RooAbsOptTestStatistic::ctor(" << GetName() 
			 << ") fixing interpretation of coefficients of any RooAddPdf to full domain of observables " << endl ;
	_funcClone->fixAddCoefRange(Form("NormalizationRangeFor%s",rangeName),kFALSE) ;
    }
  }


  // This is deferred from part 2 - but must happen after part 3 - otherwise invalid bins cannot be properly marked in cacheValidEntries
  _dataClone->attachBuffers(*_funcObsSet) ;
  setEventCount(_dataClone->numEntries()) ;




  // *********************************************************************
  // *** PART 4 *** Adjust normalization range for projected observables *
  // *********************************************************************

  // Remove projected dependents from normalization set
  if (projDeps.getSize()>0) {

    _projDeps = (RooArgSet*) projDeps.snapshot(kFALSE) ;
    
    //RooArgSet* tobedel = (RooArgSet*) _normSet->selectCommon(*_projDeps) ;
    _normSet->remove(*_projDeps,kTRUE,kTRUE) ;

//     // Delete owned projected dependent copy in _normSet
//     TIterator* ii = tobedel->createIterator() ;
//     RooAbsArg* aa ;
//     while((aa=(RooAbsArg*)ii->Next())) {
//       delete aa ;
//     }
//     delete ii ;
//     delete tobedel ;

    // Mark all projected dependents as such
    RooArgSet *projDataDeps = (RooArgSet*) _funcObsSet->selectCommon(*_projDeps) ;
    projDataDeps->setAttribAll("projectedDependent") ;
    delete projDataDeps ;    
  } 


  coutI(Optimization) << "RooAbsOptTestStatistic::ctor(" << GetName() << ") optimizing internal clone of p.d.f for likelihood evaluation." 
			<< "Lazy evaluation and associated change tracking will disabled for all nodes that depend on observables" << endl ;


  // *********************************************************************
  // *** PART 4 *** Finalization and activation of optimization          *
  // *********************************************************************

  //_origFunc = _func ;
  //_origData = _data ;

  // Redirect pointers of base class to clone 
  _func = _funcClone ;
  _data = _dataClone ;

  _funcClone->getVal(_normSet) ;

//   cout << "ROATS::ctor(" << GetName() << ") funcClone structure dump BEFORE opt" << endl ;
//   _funcClone->Print("t") ;

  optimizeCaching() ;


//   cout << "ROATS::ctor(" << GetName() << ") funcClone structure dump AFTER opt" << endl ;
//   _funcClone->Print("t") ;

}


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

  if (operMode()==Slave) {
    delete _funcClone ;
    delete _funcObsSet ;
    if (_projDeps) {
      delete _projDeps ;
    }
    if (_ownData) {
      delete _dataClone ;
    }
  } 
  delete _normSet ;
}



//_____________________________________________________________________________
Double_t RooAbsOptTestStatistic::combinedValue(RooAbsReal** array, Int_t n) const
{
  // Method to combined test statistic results calculated into partitions into
  // the global result. This default implementation adds the partition return
  // values
  
  // Default implementation returns sum of components
  Double_t sum(0), carry(0);
  for (Int_t i = 0; i < n; ++i) {
    Double_t y = array[i]->getValV();
    carry += reinterpret_cast<RooAbsOptTestStatistic*>(array[i])->getCarry();
    y -= carry;
    const Double_t t = sum + y;
    carry = (t - sum) - y;
    sum = t;
  }
  _evalCarry = carry;
  return sum ;
}



//_____________________________________________________________________________
Bool_t RooAbsOptTestStatistic::redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) 
{
  // Catch server redirect calls and forward to internal clone of function

  RooAbsTestStatistic::redirectServersHook(newServerList,mustReplaceAll,nameChange,isRecursive) ;
  if (operMode()!=Slave) return kFALSE ;  
  Bool_t ret = _funcClone->recursiveRedirectServers(newServerList,kFALSE,nameChange) ;
  return ret ;
}



//_____________________________________________________________________________
void RooAbsOptTestStatistic::printCompactTreeHook(ostream& os, const char* indent) 
{
  // Catch print hook function and forward to function clone

  RooAbsTestStatistic::printCompactTreeHook(os,indent) ;
  if (operMode()!=Slave) return ;
  TString indent2(indent) ;
  indent2 += "opt >>" ;
  _funcClone->printCompactTree(os,indent2.Data()) ;
  os << indent2 << " dataset clone = " << _dataClone << " first obs = " << _dataClone->get()->first() << endl ;
}



//_____________________________________________________________________________
void RooAbsOptTestStatistic::constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlsoTrackingOpt) 
{
  // Driver function to propagate constant term optimizations in test statistic.
  // If code Activate is sent, constant term optimization will be executed.
  // If code Deacivate is sent, any existing constant term optimizations will
  // be abanoned. If codes ConfigChange or ValueChange are sent, any existing
  // constant term optimizations will be redone.

  //   cout << "ROATS::constOpt(" << GetName() << ") funcClone structure dump BEFORE const-opt" << endl ;
  //   _funcClone->Print("t") ;

  RooAbsTestStatistic::constOptimizeTestStatistic(opcode,doAlsoTrackingOpt);
  if (operMode()!=Slave) return ;
  
  if (_dataClone->hasFilledCache() && _dataClone->store()->cacheOwner()!=this) {
    if (opcode==Activate) {
      cxcoutW(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			    << ") dataset cache is owned by another object, no constant term optimization can be applied" << endl ;
    }
    return ;
  }

  if (!allowFunctionCache()) {
    if (opcode==Activate) {
      cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			    << ") function caching prohibited by test statistic, no constant term optimization is applied" << endl ;
    }
    return ;
  }

  if (_dataClone->hasFilledCache() && opcode==Activate) {
    opcode=ValueChange ;
  }

  switch(opcode) {
  case Activate:     
    cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			  << ") optimizing evaluation of test statistic by finding all nodes in p.d.f that depend exclusively"
			  << " on observables and constant parameters and precalculating their values" << endl ;
    optimizeConstantTerms(kTRUE,doAlsoTrackingOpt) ;
    break ;
    
  case DeActivate:  
    cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			  << ") deactivating optimization of constant terms in test statistic" << endl ;
    optimizeConstantTerms(kFALSE) ;
    break ;

  case ConfigChange: 
    cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			  << ") one ore more parameter were changed from constant to floating or vice versa, "
			  << "re-evaluating constant term optimization" << endl ;
    optimizeConstantTerms(kFALSE) ;
    optimizeConstantTerms(kTRUE,doAlsoTrackingOpt) ;
    break ;

  case ValueChange: 
    cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName() 
			  << ") the value of one ore more constant parameter were changed re-evaluating constant term optimization" << endl ;
    // Request a forcible cache update of all cached nodes
    _dataClone->store()->forceCacheUpdate() ;

    break ;
  }

//   cout << "ROATS::constOpt(" << GetName() << ") funcClone structure dump AFTER const-opt" << endl ;
//   _funcClone->Print("t") ;
}



//_____________________________________________________________________________
void RooAbsOptTestStatistic::optimizeCaching() 
{
  // This method changes the value caching logic for all nodes that depends on any of the observables
  // as defined by the given dataset. When evaluating a test statistic constructed from the RooAbsReal
  // with a dataset the observables are guaranteed to change with every call, thus there is no point
  // in tracking these changes which result in a net overhead. Thus for observable-dependent nodes, 
  // the evaluation mechanism is changed from being dependent on a 'valueDirty' flag to guaranteed evaluation. 
  // On the dataset side, the observables objects are modified to no longer send valueDirty messages
  // to their client 

//   cout << "RooAbsOptTestStatistic::optimizeCaching(" << GetName() << "," << this << ")" << endl ;

  // Trigger create of all object caches now in nodes that have deferred object creation
  // so that cache contents can be processed immediately
  _funcClone->getVal(_normSet) ;

  // Set value caching mode for all nodes that depend on any of the observables to ADirty
  _funcClone->optimizeCacheMode(*_funcObsSet) ;

  // Disable propagation of dirty state flags for observables
  _dataClone->setDirtyProp(kFALSE) ;  

  // Disable reading of observables that are not used
  _dataClone->optimizeReadingWithCaching(*_funcClone, RooArgSet(),requiredExtraObservables()) ;
}



//_____________________________________________________________________________
void RooAbsOptTestStatistic::optimizeConstantTerms(Bool_t activate, Bool_t applyTrackingOpt)
{
  // Driver function to activate global constant term optimization.
  // If activated constant terms are found and cached with the dataset
  // The operation mode of cached nodes is set to AClean meaning that
  // their getVal() call will never result in an evaluate call.
  // Finally the branches in the dataset that correspond to observables
  // that are exclusively used in constant terms are disabled as
  // they serve no more purpose

  if(activate) {

    if (_optimized) {
      return ;
    }
    
    // Trigger create of all object caches now in nodes that have deferred object creation
    // so that cache contents can be processed immediately
    _funcClone->getVal(_normSet) ;

    // Apply tracking optimization here. Default strategy is to track components
    // of RooAddPdfs and RooRealSumPdfs. If these components are a RooProdPdf
    // or a RooProduct respectively, track the components of these products instead
    // of the product term
    RooArgSet trackNodes ;


    // Add safety check here - applyTrackingOpt will only be applied if present
    // dataset is constructed in terms of a RooVectorDataStore
    if (applyTrackingOpt) {
      if (!dynamic_cast<RooVectorDataStore*>(_dataClone->store())) {
	coutW(Optimization) << "RooAbsOptTestStatistic::optimizeConstantTerms(" << GetName() 
			    << ") WARNING Cache-and-track optimization (Optimize level 2) is only available for datasets"
			    << " implement in terms of RooVectorDataStore - ignoring this option for current dataset" << endl ;
	applyTrackingOpt = kFALSE ;
      }
    }

    if (applyTrackingOpt) {
      RooArgSet branches ;
      _funcClone->branchNodeServerList(&branches) ;
      RooFIter iter = branches.fwdIterator() ;
      RooAbsArg* arg ;
      while((arg=iter.next())) {
	arg->setCacheAndTrackHints(trackNodes) ;
      }
      // Do not set CacheAndTrack on constant expressions
      RooArgSet* constNodes = (RooArgSet*) trackNodes.selectByAttrib("Constant",kTRUE) ;
      trackNodes.remove(*constNodes) ;
      delete constNodes ;

      // Set CacheAndTrack flag on all remaining nodes
      trackNodes.setAttribAll("CacheAndTrack",kTRUE) ;
    }
    
    // Find all nodes that depend exclusively on constant parameters
    _cachedNodes.removeAll() ;

    _funcClone->findConstantNodes(*_dataClone->get(),_cachedNodes) ;

//     cout << "ROATS::oCT(" << GetName() << ") funcClone structure dump BEFORE cacheArgs" << endl ;
//     _funcClone->Print("t") ;


    // Cache constant nodes with dataset - also cache entries corresponding to zero-weights in data when using BinnedLikelihood
    _dataClone->cacheArgs(this,_cachedNodes,_normSet,!_funcClone->getAttribute("BinnedLikelihood")) ;  

//     cout << "ROATS::oCT(" << GetName() << ") funcClone structure dump AFTER cacheArgs" << endl ;
//     _funcClone->Print("t") ;

    
    // Put all cached nodes in AClean value caching mode so that their evaluate() is never called
    TIterator* cIter = _cachedNodes.createIterator() ;
    RooAbsArg *cacheArg ;
    while((cacheArg=(RooAbsArg*)cIter->Next())){
      cacheArg->setOperMode(RooAbsArg::AClean) ;
    }
    delete cIter ;  


//     cout << "_cachedNodes = " << endl ;
//     RooFIter i = _cachedNodes.fwdIterator() ;
//     RooAbsArg* aa ;
//     while ((aa=i.next())) {
//       cout << aa->IsA()->GetName() << "::" << aa->GetName() << (aa->getAttribute("ConstantExpressionCached")?" CEC":"   ") << (aa->getAttribute("CacheAndTrack")?" CAT":"   ") << endl ;
//     }

    RooArgSet* constNodes = (RooArgSet*) _cachedNodes.selectByAttrib("ConstantExpressionCached",kTRUE) ;
    RooArgSet actualTrackNodes(_cachedNodes) ;
    actualTrackNodes.remove(*constNodes) ;
    if (constNodes->getSize()>0) {
      if (constNodes->getSize()<20) {
	coutI(Minimization) << " The following expressions have been identified as constant and will be precalculated and cached: " << *constNodes << endl ;
      } else {
	coutI(Minimization) << " A total of " << constNodes->getSize() << " expressions have been identified as constant and will be precalculated and cached." << endl ;
      }
//       RooFIter i = constNodes->fwdIterator() ;
//       RooAbsArg* cnode ;
//       while((cnode=i.next())) {
// 	cout << cnode->IsA()->GetName() << "::" << cnode->GetName() << endl ;
//       }      
    }
    if (actualTrackNodes.getSize()>0) {
      if (actualTrackNodes.getSize()<20) {
	coutI(Minimization) << " The following expressions will be evaluated in cache-and-track mode: " << actualTrackNodes << endl ;
// 	RooFIter iter = actualTrackNodes.fwdIterator() ;
// 	RooAbsArg* atn ;
// 	while((atn = iter.next())) {
// 	  cout << atn->IsA()->GetName() << "::" << atn->GetName() << endl ;
// 	}
      } else {
	coutI(Minimization) << " A total of " << constNodes->getSize() << " expressions will be evaluated in cache-and-track-mode." << endl ;
      }
    }
    delete constNodes ;
    
    // Disable reading of observables that are no longer used
    _dataClone->optimizeReadingWithCaching(*_funcClone, _cachedNodes,requiredExtraObservables()) ;

    _optimized = kTRUE ;

  } else {
    
    // Delete the cache
    _dataClone->resetCache() ;
    
    // Reactivate all tree branches
    _dataClone->setArgStatus(*_dataClone->get(),kTRUE) ;
    
    // Reset all nodes to ADirty   
    optimizeCaching() ;

    // Disable propagation of dirty state flags for observables
    _dataClone->setDirtyProp(kFALSE) ;  

    _cachedNodes.removeAll() ;


    _optimized = kFALSE ;
  }
}



//_____________________________________________________________________________
Bool_t RooAbsOptTestStatistic::setDataSlave(RooAbsData& indata, Bool_t cloneData, Bool_t ownNewData) 
{ 
//   cout << "RAOTS::setDataSlave(" << this << ") START" << endl ;
  // Change dataset that is used to given one. If cloneData is kTRUE, a clone of
  // in the input dataset is made.  If the test statistic was constructed with
  // a range specification on the data, the cloneData argument is ignore and
  // the data is always cloned.


  if (operMode()==SimMaster) {
    //cout << "ROATS::setDataSlave() ERROR this is SimMaster _funcClone = " << _funcClone << endl ;    
    return kFALSE ;
  }
  
  //cout << "ROATS::setDataSlave() new dataset size = " << indata.numEntries() << endl ;
  //indata.Print("v") ;


  // Delete previous dataset now, if it was owned
  if (_ownData) {
    delete _dataClone ;
    _dataClone = 0 ;
  }

  if (!cloneData && _rangeName.size()>0) {
    coutW(InputArguments) << "RooAbsOptTestStatistic::setData(" << GetName() << ") WARNING: test statistic was constructed with range selection on data, "
			 << "ignoring request to _not_ clone the input dataset" << endl ; 
    cloneData = kTRUE ;
  }

  if (cloneData) {
    // Cloning input dataset
    if (_rangeName.size()==0) {
      _dataClone = (RooAbsData*) indata.reduce(*indata.get()) ;
    } else {
      _dataClone = ((RooAbsData&)indata).reduce(RooFit::SelectVars(*indata.get()),RooFit::CutRange(_rangeName.c_str())) ;  
    }
    _ownData = kTRUE ;

  } else {
 
    // Taking input dataset
    _dataClone = &indata ;
    _ownData = ownNewData ;
    
  }    
  
  // Attach function clone to dataset
  _dataClone->attachBuffers(*_funcObsSet) ;
  _dataClone->setDirtyProp(kFALSE) ;  
  _data = _dataClone ;

  // ReCache constant nodes with dataset 
  if (_cachedNodes.getSize()>0) {
    _dataClone->cacheArgs(this,_cachedNodes,_normSet) ;      
  }

  // Adjust internal event count
  setEventCount(indata.numEntries()) ;

  setValueDirty() ;

//   cout << "RAOTS::setDataSlave(" << this << ") END" << endl ;

  return kTRUE ;
}




//_____________________________________________________________________________
RooAbsData& RooAbsOptTestStatistic::data() 
{ 
  if (_sealed) {
    Bool_t notice = (sealNotice() && strlen(sealNotice())) ;
    coutW(ObjectHandling) << "RooAbsOptTestStatistic::data(" << GetName() 
			  << ") WARNING: object sealed by creator - access to data is not permitted: " 
			  << (notice?sealNotice():"<no user notice>") << endl ;
    static RooDataSet dummy ("dummy","dummy",RooArgSet()) ;
    return dummy ;
  }
  return *_dataClone ; 
}


//_____________________________________________________________________________
const RooAbsData& RooAbsOptTestStatistic::data() const 
{ 
  if (_sealed) {
    Bool_t notice = (sealNotice() && strlen(sealNotice())) ;
    coutW(ObjectHandling) << "RooAbsOptTestStatistic::data(" << GetName() 
			  << ") WARNING: object sealed by creator - access to data is not permitted: " 
			  << (notice?sealNotice():"<no user notice>") << endl ;
    static RooDataSet dummy ("dummy","dummy",RooArgSet()) ;
    return dummy ;
  }
  return *_dataClone ; 
}


 RooAbsOptTestStatistic.cxx:1
 RooAbsOptTestStatistic.cxx:2
 RooAbsOptTestStatistic.cxx:3
 RooAbsOptTestStatistic.cxx:4
 RooAbsOptTestStatistic.cxx:5
 RooAbsOptTestStatistic.cxx:6
 RooAbsOptTestStatistic.cxx:7
 RooAbsOptTestStatistic.cxx:8
 RooAbsOptTestStatistic.cxx:9
 RooAbsOptTestStatistic.cxx:10
 RooAbsOptTestStatistic.cxx:11
 RooAbsOptTestStatistic.cxx:12
 RooAbsOptTestStatistic.cxx:13
 RooAbsOptTestStatistic.cxx:14
 RooAbsOptTestStatistic.cxx:15
 RooAbsOptTestStatistic.cxx:16
 RooAbsOptTestStatistic.cxx:17
 RooAbsOptTestStatistic.cxx:18
 RooAbsOptTestStatistic.cxx:19
 RooAbsOptTestStatistic.cxx:20
 RooAbsOptTestStatistic.cxx:21
 RooAbsOptTestStatistic.cxx:22
 RooAbsOptTestStatistic.cxx:23
 RooAbsOptTestStatistic.cxx:24
 RooAbsOptTestStatistic.cxx:25
 RooAbsOptTestStatistic.cxx:26
 RooAbsOptTestStatistic.cxx:27
 RooAbsOptTestStatistic.cxx:28
 RooAbsOptTestStatistic.cxx:29
 RooAbsOptTestStatistic.cxx:30
 RooAbsOptTestStatistic.cxx:31
 RooAbsOptTestStatistic.cxx:32
 RooAbsOptTestStatistic.cxx:33
 RooAbsOptTestStatistic.cxx:34
 RooAbsOptTestStatistic.cxx:35
 RooAbsOptTestStatistic.cxx:36
 RooAbsOptTestStatistic.cxx:37
 RooAbsOptTestStatistic.cxx:38
 RooAbsOptTestStatistic.cxx:39
 RooAbsOptTestStatistic.cxx:40
 RooAbsOptTestStatistic.cxx:41
 RooAbsOptTestStatistic.cxx:42
 RooAbsOptTestStatistic.cxx:43
 RooAbsOptTestStatistic.cxx:44
 RooAbsOptTestStatistic.cxx:45
 RooAbsOptTestStatistic.cxx:46
 RooAbsOptTestStatistic.cxx:47
 RooAbsOptTestStatistic.cxx:48
 RooAbsOptTestStatistic.cxx:49
 RooAbsOptTestStatistic.cxx:50
 RooAbsOptTestStatistic.cxx:51
 RooAbsOptTestStatistic.cxx:52
 RooAbsOptTestStatistic.cxx:53
 RooAbsOptTestStatistic.cxx:54
 RooAbsOptTestStatistic.cxx:55
 RooAbsOptTestStatistic.cxx:56
 RooAbsOptTestStatistic.cxx:57
 RooAbsOptTestStatistic.cxx:58
 RooAbsOptTestStatistic.cxx:59
 RooAbsOptTestStatistic.cxx:60
 RooAbsOptTestStatistic.cxx:61
 RooAbsOptTestStatistic.cxx:62
 RooAbsOptTestStatistic.cxx:63
 RooAbsOptTestStatistic.cxx:64
 RooAbsOptTestStatistic.cxx:65
 RooAbsOptTestStatistic.cxx:66
 RooAbsOptTestStatistic.cxx:67
 RooAbsOptTestStatistic.cxx:68
 RooAbsOptTestStatistic.cxx:69
 RooAbsOptTestStatistic.cxx:70
 RooAbsOptTestStatistic.cxx:71
 RooAbsOptTestStatistic.cxx:72
 RooAbsOptTestStatistic.cxx:73
 RooAbsOptTestStatistic.cxx:74
 RooAbsOptTestStatistic.cxx:75
 RooAbsOptTestStatistic.cxx:76
 RooAbsOptTestStatistic.cxx:77
 RooAbsOptTestStatistic.cxx:78
 RooAbsOptTestStatistic.cxx:79
 RooAbsOptTestStatistic.cxx:80
 RooAbsOptTestStatistic.cxx:81
 RooAbsOptTestStatistic.cxx:82
 RooAbsOptTestStatistic.cxx:83
 RooAbsOptTestStatistic.cxx:84
 RooAbsOptTestStatistic.cxx:85
 RooAbsOptTestStatistic.cxx:86
 RooAbsOptTestStatistic.cxx:87
 RooAbsOptTestStatistic.cxx:88
 RooAbsOptTestStatistic.cxx:89
 RooAbsOptTestStatistic.cxx:90
 RooAbsOptTestStatistic.cxx:91
 RooAbsOptTestStatistic.cxx:92
 RooAbsOptTestStatistic.cxx:93
 RooAbsOptTestStatistic.cxx:94
 RooAbsOptTestStatistic.cxx:95
 RooAbsOptTestStatistic.cxx:96
 RooAbsOptTestStatistic.cxx:97
 RooAbsOptTestStatistic.cxx:98
 RooAbsOptTestStatistic.cxx:99
 RooAbsOptTestStatistic.cxx:100
 RooAbsOptTestStatistic.cxx:101
 RooAbsOptTestStatistic.cxx:102
 RooAbsOptTestStatistic.cxx:103
 RooAbsOptTestStatistic.cxx:104
 RooAbsOptTestStatistic.cxx:105
 RooAbsOptTestStatistic.cxx:106
 RooAbsOptTestStatistic.cxx:107
 RooAbsOptTestStatistic.cxx:108
 RooAbsOptTestStatistic.cxx:109
 RooAbsOptTestStatistic.cxx:110
 RooAbsOptTestStatistic.cxx:111
 RooAbsOptTestStatistic.cxx:112
 RooAbsOptTestStatistic.cxx:113
 RooAbsOptTestStatistic.cxx:114
 RooAbsOptTestStatistic.cxx:115
 RooAbsOptTestStatistic.cxx:116
 RooAbsOptTestStatistic.cxx:117
 RooAbsOptTestStatistic.cxx:118
 RooAbsOptTestStatistic.cxx:119
 RooAbsOptTestStatistic.cxx:120
 RooAbsOptTestStatistic.cxx:121
 RooAbsOptTestStatistic.cxx:122
 RooAbsOptTestStatistic.cxx:123
 RooAbsOptTestStatistic.cxx:124
 RooAbsOptTestStatistic.cxx:125
 RooAbsOptTestStatistic.cxx:126
 RooAbsOptTestStatistic.cxx:127
 RooAbsOptTestStatistic.cxx:128
 RooAbsOptTestStatistic.cxx:129
 RooAbsOptTestStatistic.cxx:130
 RooAbsOptTestStatistic.cxx:131
 RooAbsOptTestStatistic.cxx:132
 RooAbsOptTestStatistic.cxx:133
 RooAbsOptTestStatistic.cxx:134
 RooAbsOptTestStatistic.cxx:135
 RooAbsOptTestStatistic.cxx:136
 RooAbsOptTestStatistic.cxx:137
 RooAbsOptTestStatistic.cxx:138
 RooAbsOptTestStatistic.cxx:139
 RooAbsOptTestStatistic.cxx:140
 RooAbsOptTestStatistic.cxx:141
 RooAbsOptTestStatistic.cxx:142
 RooAbsOptTestStatistic.cxx:143
 RooAbsOptTestStatistic.cxx:144
 RooAbsOptTestStatistic.cxx:145
 RooAbsOptTestStatistic.cxx:146
 RooAbsOptTestStatistic.cxx:147
 RooAbsOptTestStatistic.cxx:148
 RooAbsOptTestStatistic.cxx:149
 RooAbsOptTestStatistic.cxx:150
 RooAbsOptTestStatistic.cxx:151
 RooAbsOptTestStatistic.cxx:152
 RooAbsOptTestStatistic.cxx:153
 RooAbsOptTestStatistic.cxx:154
 RooAbsOptTestStatistic.cxx:155
 RooAbsOptTestStatistic.cxx:156
 RooAbsOptTestStatistic.cxx:157
 RooAbsOptTestStatistic.cxx:158
 RooAbsOptTestStatistic.cxx:159
 RooAbsOptTestStatistic.cxx:160
 RooAbsOptTestStatistic.cxx:161
 RooAbsOptTestStatistic.cxx:162
 RooAbsOptTestStatistic.cxx:163
 RooAbsOptTestStatistic.cxx:164
 RooAbsOptTestStatistic.cxx:165
 RooAbsOptTestStatistic.cxx:166
 RooAbsOptTestStatistic.cxx:167
 RooAbsOptTestStatistic.cxx:168
 RooAbsOptTestStatistic.cxx:169
 RooAbsOptTestStatistic.cxx:170
 RooAbsOptTestStatistic.cxx:171
 RooAbsOptTestStatistic.cxx:172
 RooAbsOptTestStatistic.cxx:173
 RooAbsOptTestStatistic.cxx:174
 RooAbsOptTestStatistic.cxx:175
 RooAbsOptTestStatistic.cxx:176
 RooAbsOptTestStatistic.cxx:177
 RooAbsOptTestStatistic.cxx:178
 RooAbsOptTestStatistic.cxx:179
 RooAbsOptTestStatistic.cxx:180
 RooAbsOptTestStatistic.cxx:181
 RooAbsOptTestStatistic.cxx:182
 RooAbsOptTestStatistic.cxx:183
 RooAbsOptTestStatistic.cxx:184
 RooAbsOptTestStatistic.cxx:185
 RooAbsOptTestStatistic.cxx:186
 RooAbsOptTestStatistic.cxx:187
 RooAbsOptTestStatistic.cxx:188
 RooAbsOptTestStatistic.cxx:189
 RooAbsOptTestStatistic.cxx:190
 RooAbsOptTestStatistic.cxx:191
 RooAbsOptTestStatistic.cxx:192
 RooAbsOptTestStatistic.cxx:193
 RooAbsOptTestStatistic.cxx:194
 RooAbsOptTestStatistic.cxx:195
 RooAbsOptTestStatistic.cxx:196
 RooAbsOptTestStatistic.cxx:197
 RooAbsOptTestStatistic.cxx:198
 RooAbsOptTestStatistic.cxx:199
 RooAbsOptTestStatistic.cxx:200
 RooAbsOptTestStatistic.cxx:201
 RooAbsOptTestStatistic.cxx:202
 RooAbsOptTestStatistic.cxx:203
 RooAbsOptTestStatistic.cxx:204
 RooAbsOptTestStatistic.cxx:205
 RooAbsOptTestStatistic.cxx:206
 RooAbsOptTestStatistic.cxx:207
 RooAbsOptTestStatistic.cxx:208
 RooAbsOptTestStatistic.cxx:209
 RooAbsOptTestStatistic.cxx:210
 RooAbsOptTestStatistic.cxx:211
 RooAbsOptTestStatistic.cxx:212
 RooAbsOptTestStatistic.cxx:213
 RooAbsOptTestStatistic.cxx:214
 RooAbsOptTestStatistic.cxx:215
 RooAbsOptTestStatistic.cxx:216
 RooAbsOptTestStatistic.cxx:217
 RooAbsOptTestStatistic.cxx:218
 RooAbsOptTestStatistic.cxx:219
 RooAbsOptTestStatistic.cxx:220
 RooAbsOptTestStatistic.cxx:221
 RooAbsOptTestStatistic.cxx:222
 RooAbsOptTestStatistic.cxx:223
 RooAbsOptTestStatistic.cxx:224
 RooAbsOptTestStatistic.cxx:225
 RooAbsOptTestStatistic.cxx:226
 RooAbsOptTestStatistic.cxx:227
 RooAbsOptTestStatistic.cxx:228
 RooAbsOptTestStatistic.cxx:229
 RooAbsOptTestStatistic.cxx:230
 RooAbsOptTestStatistic.cxx:231
 RooAbsOptTestStatistic.cxx:232
 RooAbsOptTestStatistic.cxx:233
 RooAbsOptTestStatistic.cxx:234
 RooAbsOptTestStatistic.cxx:235
 RooAbsOptTestStatistic.cxx:236
 RooAbsOptTestStatistic.cxx:237
 RooAbsOptTestStatistic.cxx:238
 RooAbsOptTestStatistic.cxx:239
 RooAbsOptTestStatistic.cxx:240
 RooAbsOptTestStatistic.cxx:241
 RooAbsOptTestStatistic.cxx:242
 RooAbsOptTestStatistic.cxx:243
 RooAbsOptTestStatistic.cxx:244
 RooAbsOptTestStatistic.cxx:245
 RooAbsOptTestStatistic.cxx:246
 RooAbsOptTestStatistic.cxx:247
 RooAbsOptTestStatistic.cxx:248
 RooAbsOptTestStatistic.cxx:249
 RooAbsOptTestStatistic.cxx:250
 RooAbsOptTestStatistic.cxx:251
 RooAbsOptTestStatistic.cxx:252
 RooAbsOptTestStatistic.cxx:253
 RooAbsOptTestStatistic.cxx:254
 RooAbsOptTestStatistic.cxx:255
 RooAbsOptTestStatistic.cxx:256
 RooAbsOptTestStatistic.cxx:257
 RooAbsOptTestStatistic.cxx:258
 RooAbsOptTestStatistic.cxx:259
 RooAbsOptTestStatistic.cxx:260
 RooAbsOptTestStatistic.cxx:261
 RooAbsOptTestStatistic.cxx:262
 RooAbsOptTestStatistic.cxx:263
 RooAbsOptTestStatistic.cxx:264
 RooAbsOptTestStatistic.cxx:265
 RooAbsOptTestStatistic.cxx:266
 RooAbsOptTestStatistic.cxx:267
 RooAbsOptTestStatistic.cxx:268
 RooAbsOptTestStatistic.cxx:269
 RooAbsOptTestStatistic.cxx:270
 RooAbsOptTestStatistic.cxx:271
 RooAbsOptTestStatistic.cxx:272
 RooAbsOptTestStatistic.cxx:273
 RooAbsOptTestStatistic.cxx:274
 RooAbsOptTestStatistic.cxx:275
 RooAbsOptTestStatistic.cxx:276
 RooAbsOptTestStatistic.cxx:277
 RooAbsOptTestStatistic.cxx:278
 RooAbsOptTestStatistic.cxx:279
 RooAbsOptTestStatistic.cxx:280
 RooAbsOptTestStatistic.cxx:281
 RooAbsOptTestStatistic.cxx:282
 RooAbsOptTestStatistic.cxx:283
 RooAbsOptTestStatistic.cxx:284
 RooAbsOptTestStatistic.cxx:285
 RooAbsOptTestStatistic.cxx:286
 RooAbsOptTestStatistic.cxx:287
 RooAbsOptTestStatistic.cxx:288
 RooAbsOptTestStatistic.cxx:289
 RooAbsOptTestStatistic.cxx:290
 RooAbsOptTestStatistic.cxx:291
 RooAbsOptTestStatistic.cxx:292
 RooAbsOptTestStatistic.cxx:293
 RooAbsOptTestStatistic.cxx:294
 RooAbsOptTestStatistic.cxx:295
 RooAbsOptTestStatistic.cxx:296
 RooAbsOptTestStatistic.cxx:297
 RooAbsOptTestStatistic.cxx:298
 RooAbsOptTestStatistic.cxx:299
 RooAbsOptTestStatistic.cxx:300
 RooAbsOptTestStatistic.cxx:301
 RooAbsOptTestStatistic.cxx:302
 RooAbsOptTestStatistic.cxx:303
 RooAbsOptTestStatistic.cxx:304
 RooAbsOptTestStatistic.cxx:305
 RooAbsOptTestStatistic.cxx:306
 RooAbsOptTestStatistic.cxx:307
 RooAbsOptTestStatistic.cxx:308
 RooAbsOptTestStatistic.cxx:309
 RooAbsOptTestStatistic.cxx:310
 RooAbsOptTestStatistic.cxx:311
 RooAbsOptTestStatistic.cxx:312
 RooAbsOptTestStatistic.cxx:313
 RooAbsOptTestStatistic.cxx:314
 RooAbsOptTestStatistic.cxx:315
 RooAbsOptTestStatistic.cxx:316
 RooAbsOptTestStatistic.cxx:317
 RooAbsOptTestStatistic.cxx:318
 RooAbsOptTestStatistic.cxx:319
 RooAbsOptTestStatistic.cxx:320
 RooAbsOptTestStatistic.cxx:321
 RooAbsOptTestStatistic.cxx:322
 RooAbsOptTestStatistic.cxx:323
 RooAbsOptTestStatistic.cxx:324
 RooAbsOptTestStatistic.cxx:325
 RooAbsOptTestStatistic.cxx:326
 RooAbsOptTestStatistic.cxx:327
 RooAbsOptTestStatistic.cxx:328
 RooAbsOptTestStatistic.cxx:329
 RooAbsOptTestStatistic.cxx:330
 RooAbsOptTestStatistic.cxx:331
 RooAbsOptTestStatistic.cxx:332
 RooAbsOptTestStatistic.cxx:333
 RooAbsOptTestStatistic.cxx:334
 RooAbsOptTestStatistic.cxx:335
 RooAbsOptTestStatistic.cxx:336
 RooAbsOptTestStatistic.cxx:337
 RooAbsOptTestStatistic.cxx:338
 RooAbsOptTestStatistic.cxx:339
 RooAbsOptTestStatistic.cxx:340
 RooAbsOptTestStatistic.cxx:341
 RooAbsOptTestStatistic.cxx:342
 RooAbsOptTestStatistic.cxx:343
 RooAbsOptTestStatistic.cxx:344
 RooAbsOptTestStatistic.cxx:345
 RooAbsOptTestStatistic.cxx:346
 RooAbsOptTestStatistic.cxx:347
 RooAbsOptTestStatistic.cxx:348
 RooAbsOptTestStatistic.cxx:349
 RooAbsOptTestStatistic.cxx:350
 RooAbsOptTestStatistic.cxx:351
 RooAbsOptTestStatistic.cxx:352
 RooAbsOptTestStatistic.cxx:353
 RooAbsOptTestStatistic.cxx:354
 RooAbsOptTestStatistic.cxx:355
 RooAbsOptTestStatistic.cxx:356
 RooAbsOptTestStatistic.cxx:357
 RooAbsOptTestStatistic.cxx:358
 RooAbsOptTestStatistic.cxx:359
 RooAbsOptTestStatistic.cxx:360
 RooAbsOptTestStatistic.cxx:361
 RooAbsOptTestStatistic.cxx:362
 RooAbsOptTestStatistic.cxx:363
 RooAbsOptTestStatistic.cxx:364
 RooAbsOptTestStatistic.cxx:365
 RooAbsOptTestStatistic.cxx:366
 RooAbsOptTestStatistic.cxx:367
 RooAbsOptTestStatistic.cxx:368
 RooAbsOptTestStatistic.cxx:369
 RooAbsOptTestStatistic.cxx:370
 RooAbsOptTestStatistic.cxx:371
 RooAbsOptTestStatistic.cxx:372
 RooAbsOptTestStatistic.cxx:373
 RooAbsOptTestStatistic.cxx:374
 RooAbsOptTestStatistic.cxx:375
 RooAbsOptTestStatistic.cxx:376
 RooAbsOptTestStatistic.cxx:377
 RooAbsOptTestStatistic.cxx:378
 RooAbsOptTestStatistic.cxx:379
 RooAbsOptTestStatistic.cxx:380
 RooAbsOptTestStatistic.cxx:381
 RooAbsOptTestStatistic.cxx:382
 RooAbsOptTestStatistic.cxx:383
 RooAbsOptTestStatistic.cxx:384
 RooAbsOptTestStatistic.cxx:385
 RooAbsOptTestStatistic.cxx:386
 RooAbsOptTestStatistic.cxx:387
 RooAbsOptTestStatistic.cxx:388
 RooAbsOptTestStatistic.cxx:389
 RooAbsOptTestStatistic.cxx:390
 RooAbsOptTestStatistic.cxx:391
 RooAbsOptTestStatistic.cxx:392
 RooAbsOptTestStatistic.cxx:393
 RooAbsOptTestStatistic.cxx:394
 RooAbsOptTestStatistic.cxx:395
 RooAbsOptTestStatistic.cxx:396
 RooAbsOptTestStatistic.cxx:397
 RooAbsOptTestStatistic.cxx:398
 RooAbsOptTestStatistic.cxx:399
 RooAbsOptTestStatistic.cxx:400
 RooAbsOptTestStatistic.cxx:401
 RooAbsOptTestStatistic.cxx:402
 RooAbsOptTestStatistic.cxx:403
 RooAbsOptTestStatistic.cxx:404
 RooAbsOptTestStatistic.cxx:405
 RooAbsOptTestStatistic.cxx:406
 RooAbsOptTestStatistic.cxx:407
 RooAbsOptTestStatistic.cxx:408
 RooAbsOptTestStatistic.cxx:409
 RooAbsOptTestStatistic.cxx:410
 RooAbsOptTestStatistic.cxx:411
 RooAbsOptTestStatistic.cxx:412
 RooAbsOptTestStatistic.cxx:413
 RooAbsOptTestStatistic.cxx:414
 RooAbsOptTestStatistic.cxx:415
 RooAbsOptTestStatistic.cxx:416
 RooAbsOptTestStatistic.cxx:417
 RooAbsOptTestStatistic.cxx:418
 RooAbsOptTestStatistic.cxx:419
 RooAbsOptTestStatistic.cxx:420
 RooAbsOptTestStatistic.cxx:421
 RooAbsOptTestStatistic.cxx:422
 RooAbsOptTestStatistic.cxx:423
 RooAbsOptTestStatistic.cxx:424
 RooAbsOptTestStatistic.cxx:425
 RooAbsOptTestStatistic.cxx:426
 RooAbsOptTestStatistic.cxx:427
 RooAbsOptTestStatistic.cxx:428
 RooAbsOptTestStatistic.cxx:429
 RooAbsOptTestStatistic.cxx:430
 RooAbsOptTestStatistic.cxx:431
 RooAbsOptTestStatistic.cxx:432
 RooAbsOptTestStatistic.cxx:433
 RooAbsOptTestStatistic.cxx:434
 RooAbsOptTestStatistic.cxx:435
 RooAbsOptTestStatistic.cxx:436
 RooAbsOptTestStatistic.cxx:437
 RooAbsOptTestStatistic.cxx:438
 RooAbsOptTestStatistic.cxx:439
 RooAbsOptTestStatistic.cxx:440
 RooAbsOptTestStatistic.cxx:441
 RooAbsOptTestStatistic.cxx:442
 RooAbsOptTestStatistic.cxx:443
 RooAbsOptTestStatistic.cxx:444
 RooAbsOptTestStatistic.cxx:445
 RooAbsOptTestStatistic.cxx:446
 RooAbsOptTestStatistic.cxx:447
 RooAbsOptTestStatistic.cxx:448
 RooAbsOptTestStatistic.cxx:449
 RooAbsOptTestStatistic.cxx:450
 RooAbsOptTestStatistic.cxx:451
 RooAbsOptTestStatistic.cxx:452
 RooAbsOptTestStatistic.cxx:453
 RooAbsOptTestStatistic.cxx:454
 RooAbsOptTestStatistic.cxx:455
 RooAbsOptTestStatistic.cxx:456
 RooAbsOptTestStatistic.cxx:457
 RooAbsOptTestStatistic.cxx:458
 RooAbsOptTestStatistic.cxx:459
 RooAbsOptTestStatistic.cxx:460
 RooAbsOptTestStatistic.cxx:461
 RooAbsOptTestStatistic.cxx:462
 RooAbsOptTestStatistic.cxx:463
 RooAbsOptTestStatistic.cxx:464
 RooAbsOptTestStatistic.cxx:465
 RooAbsOptTestStatistic.cxx:466
 RooAbsOptTestStatistic.cxx:467
 RooAbsOptTestStatistic.cxx:468
 RooAbsOptTestStatistic.cxx:469
 RooAbsOptTestStatistic.cxx:470
 RooAbsOptTestStatistic.cxx:471
 RooAbsOptTestStatistic.cxx:472
 RooAbsOptTestStatistic.cxx:473
 RooAbsOptTestStatistic.cxx:474
 RooAbsOptTestStatistic.cxx:475
 RooAbsOptTestStatistic.cxx:476
 RooAbsOptTestStatistic.cxx:477
 RooAbsOptTestStatistic.cxx:478
 RooAbsOptTestStatistic.cxx:479
 RooAbsOptTestStatistic.cxx:480
 RooAbsOptTestStatistic.cxx:481
 RooAbsOptTestStatistic.cxx:482
 RooAbsOptTestStatistic.cxx:483
 RooAbsOptTestStatistic.cxx:484
 RooAbsOptTestStatistic.cxx:485
 RooAbsOptTestStatistic.cxx:486
 RooAbsOptTestStatistic.cxx:487
 RooAbsOptTestStatistic.cxx:488
 RooAbsOptTestStatistic.cxx:489
 RooAbsOptTestStatistic.cxx:490
 RooAbsOptTestStatistic.cxx:491
 RooAbsOptTestStatistic.cxx:492
 RooAbsOptTestStatistic.cxx:493
 RooAbsOptTestStatistic.cxx:494
 RooAbsOptTestStatistic.cxx:495
 RooAbsOptTestStatistic.cxx:496
 RooAbsOptTestStatistic.cxx:497
 RooAbsOptTestStatistic.cxx:498
 RooAbsOptTestStatistic.cxx:499
 RooAbsOptTestStatistic.cxx:500
 RooAbsOptTestStatistic.cxx:501
 RooAbsOptTestStatistic.cxx:502
 RooAbsOptTestStatistic.cxx:503
 RooAbsOptTestStatistic.cxx:504
 RooAbsOptTestStatistic.cxx:505
 RooAbsOptTestStatistic.cxx:506
 RooAbsOptTestStatistic.cxx:507
 RooAbsOptTestStatistic.cxx:508
 RooAbsOptTestStatistic.cxx:509
 RooAbsOptTestStatistic.cxx:510
 RooAbsOptTestStatistic.cxx:511
 RooAbsOptTestStatistic.cxx:512
 RooAbsOptTestStatistic.cxx:513
 RooAbsOptTestStatistic.cxx:514
 RooAbsOptTestStatistic.cxx:515
 RooAbsOptTestStatistic.cxx:516
 RooAbsOptTestStatistic.cxx:517
 RooAbsOptTestStatistic.cxx:518
 RooAbsOptTestStatistic.cxx:519
 RooAbsOptTestStatistic.cxx:520
 RooAbsOptTestStatistic.cxx:521
 RooAbsOptTestStatistic.cxx:522
 RooAbsOptTestStatistic.cxx:523
 RooAbsOptTestStatistic.cxx:524
 RooAbsOptTestStatistic.cxx:525
 RooAbsOptTestStatistic.cxx:526
 RooAbsOptTestStatistic.cxx:527
 RooAbsOptTestStatistic.cxx:528
 RooAbsOptTestStatistic.cxx:529
 RooAbsOptTestStatistic.cxx:530
 RooAbsOptTestStatistic.cxx:531
 RooAbsOptTestStatistic.cxx:532
 RooAbsOptTestStatistic.cxx:533
 RooAbsOptTestStatistic.cxx:534
 RooAbsOptTestStatistic.cxx:535
 RooAbsOptTestStatistic.cxx:536
 RooAbsOptTestStatistic.cxx:537
 RooAbsOptTestStatistic.cxx:538
 RooAbsOptTestStatistic.cxx:539
 RooAbsOptTestStatistic.cxx:540
 RooAbsOptTestStatistic.cxx:541
 RooAbsOptTestStatistic.cxx:542
 RooAbsOptTestStatistic.cxx:543
 RooAbsOptTestStatistic.cxx:544
 RooAbsOptTestStatistic.cxx:545
 RooAbsOptTestStatistic.cxx:546
 RooAbsOptTestStatistic.cxx:547
 RooAbsOptTestStatistic.cxx:548
 RooAbsOptTestStatistic.cxx:549
 RooAbsOptTestStatistic.cxx:550
 RooAbsOptTestStatistic.cxx:551
 RooAbsOptTestStatistic.cxx:552
 RooAbsOptTestStatistic.cxx:553
 RooAbsOptTestStatistic.cxx:554
 RooAbsOptTestStatistic.cxx:555
 RooAbsOptTestStatistic.cxx:556
 RooAbsOptTestStatistic.cxx:557
 RooAbsOptTestStatistic.cxx:558
 RooAbsOptTestStatistic.cxx:559
 RooAbsOptTestStatistic.cxx:560
 RooAbsOptTestStatistic.cxx:561
 RooAbsOptTestStatistic.cxx:562
 RooAbsOptTestStatistic.cxx:563
 RooAbsOptTestStatistic.cxx:564
 RooAbsOptTestStatistic.cxx:565
 RooAbsOptTestStatistic.cxx:566
 RooAbsOptTestStatistic.cxx:567
 RooAbsOptTestStatistic.cxx:568
 RooAbsOptTestStatistic.cxx:569
 RooAbsOptTestStatistic.cxx:570
 RooAbsOptTestStatistic.cxx:571
 RooAbsOptTestStatistic.cxx:572
 RooAbsOptTestStatistic.cxx:573
 RooAbsOptTestStatistic.cxx:574
 RooAbsOptTestStatistic.cxx:575
 RooAbsOptTestStatistic.cxx:576
 RooAbsOptTestStatistic.cxx:577
 RooAbsOptTestStatistic.cxx:578
 RooAbsOptTestStatistic.cxx:579
 RooAbsOptTestStatistic.cxx:580
 RooAbsOptTestStatistic.cxx:581
 RooAbsOptTestStatistic.cxx:582
 RooAbsOptTestStatistic.cxx:583
 RooAbsOptTestStatistic.cxx:584
 RooAbsOptTestStatistic.cxx:585
 RooAbsOptTestStatistic.cxx:586
 RooAbsOptTestStatistic.cxx:587
 RooAbsOptTestStatistic.cxx:588
 RooAbsOptTestStatistic.cxx:589
 RooAbsOptTestStatistic.cxx:590
 RooAbsOptTestStatistic.cxx:591
 RooAbsOptTestStatistic.cxx:592
 RooAbsOptTestStatistic.cxx:593
 RooAbsOptTestStatistic.cxx:594
 RooAbsOptTestStatistic.cxx:595
 RooAbsOptTestStatistic.cxx:596
 RooAbsOptTestStatistic.cxx:597
 RooAbsOptTestStatistic.cxx:598
 RooAbsOptTestStatistic.cxx:599
 RooAbsOptTestStatistic.cxx:600
 RooAbsOptTestStatistic.cxx:601
 RooAbsOptTestStatistic.cxx:602
 RooAbsOptTestStatistic.cxx:603
 RooAbsOptTestStatistic.cxx:604
 RooAbsOptTestStatistic.cxx:605
 RooAbsOptTestStatistic.cxx:606
 RooAbsOptTestStatistic.cxx:607
 RooAbsOptTestStatistic.cxx:608
 RooAbsOptTestStatistic.cxx:609
 RooAbsOptTestStatistic.cxx:610
 RooAbsOptTestStatistic.cxx:611
 RooAbsOptTestStatistic.cxx:612
 RooAbsOptTestStatistic.cxx:613
 RooAbsOptTestStatistic.cxx:614
 RooAbsOptTestStatistic.cxx:615
 RooAbsOptTestStatistic.cxx:616
 RooAbsOptTestStatistic.cxx:617
 RooAbsOptTestStatistic.cxx:618
 RooAbsOptTestStatistic.cxx:619
 RooAbsOptTestStatistic.cxx:620
 RooAbsOptTestStatistic.cxx:621
 RooAbsOptTestStatistic.cxx:622
 RooAbsOptTestStatistic.cxx:623
 RooAbsOptTestStatistic.cxx:624
 RooAbsOptTestStatistic.cxx:625
 RooAbsOptTestStatistic.cxx:626
 RooAbsOptTestStatistic.cxx:627
 RooAbsOptTestStatistic.cxx:628
 RooAbsOptTestStatistic.cxx:629
 RooAbsOptTestStatistic.cxx:630
 RooAbsOptTestStatistic.cxx:631
 RooAbsOptTestStatistic.cxx:632
 RooAbsOptTestStatistic.cxx:633
 RooAbsOptTestStatistic.cxx:634
 RooAbsOptTestStatistic.cxx:635
 RooAbsOptTestStatistic.cxx:636
 RooAbsOptTestStatistic.cxx:637
 RooAbsOptTestStatistic.cxx:638
 RooAbsOptTestStatistic.cxx:639
 RooAbsOptTestStatistic.cxx:640
 RooAbsOptTestStatistic.cxx:641
 RooAbsOptTestStatistic.cxx:642
 RooAbsOptTestStatistic.cxx:643
 RooAbsOptTestStatistic.cxx:644
 RooAbsOptTestStatistic.cxx:645
 RooAbsOptTestStatistic.cxx:646
 RooAbsOptTestStatistic.cxx:647
 RooAbsOptTestStatistic.cxx:648
 RooAbsOptTestStatistic.cxx:649
 RooAbsOptTestStatistic.cxx:650
 RooAbsOptTestStatistic.cxx:651
 RooAbsOptTestStatistic.cxx:652
 RooAbsOptTestStatistic.cxx:653
 RooAbsOptTestStatistic.cxx:654
 RooAbsOptTestStatistic.cxx:655
 RooAbsOptTestStatistic.cxx:656
 RooAbsOptTestStatistic.cxx:657
 RooAbsOptTestStatistic.cxx:658
 RooAbsOptTestStatistic.cxx:659
 RooAbsOptTestStatistic.cxx:660
 RooAbsOptTestStatistic.cxx:661
 RooAbsOptTestStatistic.cxx:662
 RooAbsOptTestStatistic.cxx:663
 RooAbsOptTestStatistic.cxx:664
 RooAbsOptTestStatistic.cxx:665
 RooAbsOptTestStatistic.cxx:666
 RooAbsOptTestStatistic.cxx:667
 RooAbsOptTestStatistic.cxx:668
 RooAbsOptTestStatistic.cxx:669
 RooAbsOptTestStatistic.cxx:670
 RooAbsOptTestStatistic.cxx:671
 RooAbsOptTestStatistic.cxx:672
 RooAbsOptTestStatistic.cxx:673
 RooAbsOptTestStatistic.cxx:674
 RooAbsOptTestStatistic.cxx:675
 RooAbsOptTestStatistic.cxx:676
 RooAbsOptTestStatistic.cxx:677
 RooAbsOptTestStatistic.cxx:678
 RooAbsOptTestStatistic.cxx:679
 RooAbsOptTestStatistic.cxx:680
 RooAbsOptTestStatistic.cxx:681
 RooAbsOptTestStatistic.cxx:682
 RooAbsOptTestStatistic.cxx:683
 RooAbsOptTestStatistic.cxx:684
 RooAbsOptTestStatistic.cxx:685
 RooAbsOptTestStatistic.cxx:686
 RooAbsOptTestStatistic.cxx:687
 RooAbsOptTestStatistic.cxx:688
 RooAbsOptTestStatistic.cxx:689
 RooAbsOptTestStatistic.cxx:690
 RooAbsOptTestStatistic.cxx:691
 RooAbsOptTestStatistic.cxx:692
 RooAbsOptTestStatistic.cxx:693
 RooAbsOptTestStatistic.cxx:694
 RooAbsOptTestStatistic.cxx:695
 RooAbsOptTestStatistic.cxx:696
 RooAbsOptTestStatistic.cxx:697
 RooAbsOptTestStatistic.cxx:698
 RooAbsOptTestStatistic.cxx:699
 RooAbsOptTestStatistic.cxx:700
 RooAbsOptTestStatistic.cxx:701
 RooAbsOptTestStatistic.cxx:702
 RooAbsOptTestStatistic.cxx:703
 RooAbsOptTestStatistic.cxx:704
 RooAbsOptTestStatistic.cxx:705
 RooAbsOptTestStatistic.cxx:706
 RooAbsOptTestStatistic.cxx:707
 RooAbsOptTestStatistic.cxx:708
 RooAbsOptTestStatistic.cxx:709
 RooAbsOptTestStatistic.cxx:710
 RooAbsOptTestStatistic.cxx:711
 RooAbsOptTestStatistic.cxx:712
 RooAbsOptTestStatistic.cxx:713
 RooAbsOptTestStatistic.cxx:714
 RooAbsOptTestStatistic.cxx:715
 RooAbsOptTestStatistic.cxx:716
 RooAbsOptTestStatistic.cxx:717
 RooAbsOptTestStatistic.cxx:718
 RooAbsOptTestStatistic.cxx:719
 RooAbsOptTestStatistic.cxx:720
 RooAbsOptTestStatistic.cxx:721
 RooAbsOptTestStatistic.cxx:722
 RooAbsOptTestStatistic.cxx:723
 RooAbsOptTestStatistic.cxx:724
 RooAbsOptTestStatistic.cxx:725
 RooAbsOptTestStatistic.cxx:726
 RooAbsOptTestStatistic.cxx:727
 RooAbsOptTestStatistic.cxx:728
 RooAbsOptTestStatistic.cxx:729
 RooAbsOptTestStatistic.cxx:730
 RooAbsOptTestStatistic.cxx:731
 RooAbsOptTestStatistic.cxx:732
 RooAbsOptTestStatistic.cxx:733
 RooAbsOptTestStatistic.cxx:734
 RooAbsOptTestStatistic.cxx:735
 RooAbsOptTestStatistic.cxx:736
 RooAbsOptTestStatistic.cxx:737
 RooAbsOptTestStatistic.cxx:738
 RooAbsOptTestStatistic.cxx:739
 RooAbsOptTestStatistic.cxx:740
 RooAbsOptTestStatistic.cxx:741
 RooAbsOptTestStatistic.cxx:742
 RooAbsOptTestStatistic.cxx:743
 RooAbsOptTestStatistic.cxx:744
 RooAbsOptTestStatistic.cxx:745
 RooAbsOptTestStatistic.cxx:746
 RooAbsOptTestStatistic.cxx:747
 RooAbsOptTestStatistic.cxx:748
 RooAbsOptTestStatistic.cxx:749
 RooAbsOptTestStatistic.cxx:750
 RooAbsOptTestStatistic.cxx:751
 RooAbsOptTestStatistic.cxx:752
 RooAbsOptTestStatistic.cxx:753
 RooAbsOptTestStatistic.cxx:754
 RooAbsOptTestStatistic.cxx:755
 RooAbsOptTestStatistic.cxx:756
 RooAbsOptTestStatistic.cxx:757
 RooAbsOptTestStatistic.cxx:758
 RooAbsOptTestStatistic.cxx:759
 RooAbsOptTestStatistic.cxx:760
 RooAbsOptTestStatistic.cxx:761
 RooAbsOptTestStatistic.cxx:762
 RooAbsOptTestStatistic.cxx:763
 RooAbsOptTestStatistic.cxx:764
 RooAbsOptTestStatistic.cxx:765
 RooAbsOptTestStatistic.cxx:766
 RooAbsOptTestStatistic.cxx:767
 RooAbsOptTestStatistic.cxx:768
 RooAbsOptTestStatistic.cxx:769
 RooAbsOptTestStatistic.cxx:770
 RooAbsOptTestStatistic.cxx:771
 RooAbsOptTestStatistic.cxx:772
 RooAbsOptTestStatistic.cxx:773
 RooAbsOptTestStatistic.cxx:774
 RooAbsOptTestStatistic.cxx:775
 RooAbsOptTestStatistic.cxx:776
 RooAbsOptTestStatistic.cxx:777
 RooAbsOptTestStatistic.cxx:778
 RooAbsOptTestStatistic.cxx:779
 RooAbsOptTestStatistic.cxx:780
 RooAbsOptTestStatistic.cxx:781
 RooAbsOptTestStatistic.cxx:782
 RooAbsOptTestStatistic.cxx:783
 RooAbsOptTestStatistic.cxx:784
 RooAbsOptTestStatistic.cxx:785
 RooAbsOptTestStatistic.cxx:786
 RooAbsOptTestStatistic.cxx:787
 RooAbsOptTestStatistic.cxx:788
 RooAbsOptTestStatistic.cxx:789
 RooAbsOptTestStatistic.cxx:790
 RooAbsOptTestStatistic.cxx:791
 RooAbsOptTestStatistic.cxx:792
 RooAbsOptTestStatistic.cxx:793
 RooAbsOptTestStatistic.cxx:794
 RooAbsOptTestStatistic.cxx:795
 RooAbsOptTestStatistic.cxx:796
 RooAbsOptTestStatistic.cxx:797
 RooAbsOptTestStatistic.cxx:798
 RooAbsOptTestStatistic.cxx:799
 RooAbsOptTestStatistic.cxx:800
 RooAbsOptTestStatistic.cxx:801
 RooAbsOptTestStatistic.cxx:802
 RooAbsOptTestStatistic.cxx:803
 RooAbsOptTestStatistic.cxx:804
 RooAbsOptTestStatistic.cxx:805
 RooAbsOptTestStatistic.cxx:806
 RooAbsOptTestStatistic.cxx:807
 RooAbsOptTestStatistic.cxx:808
 RooAbsOptTestStatistic.cxx:809
 RooAbsOptTestStatistic.cxx:810
 RooAbsOptTestStatistic.cxx:811
 RooAbsOptTestStatistic.cxx:812
 RooAbsOptTestStatistic.cxx:813
 RooAbsOptTestStatistic.cxx:814
 RooAbsOptTestStatistic.cxx:815
 RooAbsOptTestStatistic.cxx:816
 RooAbsOptTestStatistic.cxx:817
 RooAbsOptTestStatistic.cxx:818
 RooAbsOptTestStatistic.cxx:819
 RooAbsOptTestStatistic.cxx:820
 RooAbsOptTestStatistic.cxx:821
 RooAbsOptTestStatistic.cxx:822
 RooAbsOptTestStatistic.cxx:823
 RooAbsOptTestStatistic.cxx:824
 RooAbsOptTestStatistic.cxx:825
 RooAbsOptTestStatistic.cxx:826
 RooAbsOptTestStatistic.cxx:827
 RooAbsOptTestStatistic.cxx:828
 RooAbsOptTestStatistic.cxx:829
 RooAbsOptTestStatistic.cxx:830
 RooAbsOptTestStatistic.cxx:831
 RooAbsOptTestStatistic.cxx:832
 RooAbsOptTestStatistic.cxx:833
 RooAbsOptTestStatistic.cxx:834
 RooAbsOptTestStatistic.cxx:835
 RooAbsOptTestStatistic.cxx:836
 RooAbsOptTestStatistic.cxx:837
 RooAbsOptTestStatistic.cxx:838
 RooAbsOptTestStatistic.cxx:839
 RooAbsOptTestStatistic.cxx:840
 RooAbsOptTestStatistic.cxx:841
 RooAbsOptTestStatistic.cxx:842
 RooAbsOptTestStatistic.cxx:843
 RooAbsOptTestStatistic.cxx:844