/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 *    File: $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)             *
 *****************************************************************************/
#ifndef ROO_VECTOR_DATA_STORE
#define ROO_VECTOR_DATA_STORE

#include <list>
#include <vector>
#include <string>
#include <algorithm>
#include "RooAbsDataStore.h" 
#include "TString.h"
#include "RooCatType.h"
#include "RooAbsCategory.h"
#include "RooAbsReal.h"
#include "RooChangeTracker.h"

#define VECTOR_BUFFER_SIZE 1024

class RooAbsArg ;
class RooArgList ;
class TTree ;
class RooFormulaVar ;
class RooArgSet ;

class RooVectorDataStore : public RooAbsDataStore {
public:

  RooVectorDataStore() ; 

  // Empty ctor
  RooVectorDataStore(const char* name, const char* title, const RooArgSet& vars, const char* wgtVarName=0) ;
  virtual RooAbsDataStore* clone(const char* newname=0) const { return new RooVectorDataStore(*this,newname) ; }
  virtual RooAbsDataStore* clone(const RooArgSet& vars, const char* newname=0) const { return new RooVectorDataStore(*this,vars,newname) ; }

  RooVectorDataStore(const RooVectorDataStore& other, const char* newname=0) ;
  RooVectorDataStore(const RooTreeDataStore& other, const RooArgSet& vars, const char* newname=0) ;
  RooVectorDataStore(const RooVectorDataStore& other, const RooArgSet& vars, const char* newname=0) ;


  RooVectorDataStore(const char *name, const char *title, RooAbsDataStore& tds, 
		     const RooArgSet& vars, const RooFormulaVar* cutVar, const char* cutRange,
		     Int_t nStart, Int_t nStop, Bool_t /*copyCache*/, const char* wgtVarName=0) ;

  virtual ~RooVectorDataStore() ;

  RooArgSet varsNoWeight(const RooArgSet& allVars, const char* wgtName) ;
  RooRealVar* weightVar(const RooArgSet& allVars, const char* wgtName) ;

  // Write current row
  virtual Int_t fill() ;

  // reserve storage for nEvt entries
  virtual void reserve(Int_t nEvt);

  // Retrieve a row
  using RooAbsDataStore::get ;
  virtual const RooArgSet* get(Int_t index) const ;
  virtual const RooArgSet* getNative(Int_t index) const ;
  virtual Double_t weight() const ;
  virtual Double_t weightError(RooAbsData::ErrorType etype=RooAbsData::Poisson) const ;
  virtual void weightError(Double_t& lo, Double_t& hi, RooAbsData::ErrorType etype=RooAbsData::Poisson) const ; 
  virtual Double_t weight(Int_t index) const ;
  virtual Bool_t isWeighted() const { return (_wgtVar!=0||_extWgtArray!=0) ; }

  // Change observable name
  virtual Bool_t changeObservableName(const char* from, const char* to) ;
  
  // Add one or more columns
  virtual RooAbsArg* addColumn(RooAbsArg& var, Bool_t adjustRange=kTRUE) ;
  virtual RooArgSet* addColumns(const RooArgList& varList) ;

  // Merge column-wise
  RooAbsDataStore* merge(const RooArgSet& allvars, std::list<RooAbsDataStore*> dstoreList) ;

  // Add rows 
  virtual void append(RooAbsDataStore& other) ;

  // General & bookkeeping methods
  virtual Bool_t valid() const ;
  virtual Int_t numEntries() const ;
  virtual Double_t sumEntries() const { return _sumWeight ; }
  virtual void reset() ;

  // Buffer redirection routines used in inside RooAbsOptTestStatistics
  virtual void attachBuffers(const RooArgSet& extObs) ; 
  virtual void resetBuffers() ;
  
  
  // Constant term  optimizer interface
  virtual const RooAbsArg* cacheOwner() { return _cacheOwner ; }
  virtual void cacheArgs(const RooAbsArg* owner, RooArgSet& varSet, const RooArgSet* nset=0, Bool_t skipZeroWeights=kTRUE) ;
  virtual void attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) ;
  virtual void resetCache() ;
  virtual void recalculateCache(const RooArgSet* /*proj*/, Int_t firstEvent, Int_t lastEvent, Int_t stepSize, Bool_t skipZeroWeights) ;

  virtual void setArgStatus(const RooArgSet& set, Bool_t active) ;

  const RooVectorDataStore* cache() const { return _cache ; }

  void loadValues(const RooAbsDataStore *tds, const RooFormulaVar* select=0, const char* rangeName=0, Int_t nStart=0, Int_t nStop=2000000000) ;
  
  void dump() ;

  void setExternalWeightArray(Double_t* arrayWgt, Double_t* arrayWgtErrLo, Double_t* arrayWgtErrHi, Double_t* arraySumW2) { 
    _extWgtArray = arrayWgt ; 
    _extWgtErrLoArray = arrayWgtErrLo ;
    _extWgtErrHiArray = arrayWgtErrHi ;
    _extSumW2Array = arraySumW2 ;
  }

  virtual void setDirtyProp(Bool_t flag) { 
    _doDirtyProp = flag ; 
    if (_cache) {
      _cache->setDirtyProp(flag) ;
    }
  }

  //virtual void checkInit() const;

  const RooArgSet& row() { return _varsww ; }

  class RealVector {
  public:
    RealVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) : 
      _nativeReal(0), _real(0), _buf(0), _nativeBuf(0), _vec0(0), _tracker(0), _nset(0) { 
      _vec.reserve(initialCapacity);
    }

    RealVector(RooAbsReal* arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) : 
      _nativeReal(arg), _real(0), _buf(0), _nativeBuf(0), _vec0(0), _tracker(0), _nset(0) { 
      _vec.reserve(initialCapacity);
    }

    virtual ~RealVector() {
      delete _tracker;
      if (_nset) delete _nset ;
    }

    RealVector(const RealVector& other, RooAbsReal* real=0) : 
      _vec(other._vec), _nativeReal(real?real:other._nativeReal), _real(real?real:other._real), _buf(other._buf), _nativeBuf(other._nativeBuf), _nset(0)   {
      _vec0 = _vec.size()>0 ? &_vec.front() : 0 ;
      if (other._tracker) {
	_tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName()),"tracker",other._tracker->parameters()) ;
      } else {
	_tracker = 0 ;
      }
      if (other._nset) {
	_nset = new RooArgSet(*other._nset) ;
      }
    }

    RealVector& operator=(const RealVector& other) {
      if (&other==this) return *this;
      _nativeReal = other._nativeReal;
      _real = other._real;
      _buf = other._buf;
      _nativeBuf = other._nativeBuf;
      if (other._vec.size() <= _vec.capacity() / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
	std::vector<Double_t> tmp;
	tmp.reserve(std::max(other._vec.size(), VECTOR_BUFFER_SIZE / sizeof(Double_t)));
	tmp.assign(other._vec.begin(), other._vec.end());
	_vec.swap(tmp);
      } else {
	_vec = other._vec;
      }
      _vec0 = _vec.size()>0 ? &_vec.front() : 0;
      return *this;
    }
    
    void setNset(RooArgSet* newNset) { _nset = newNset ? new RooArgSet(*newNset) : 0 ; }

    RooArgSet* nset() const { return _nset ; }

    void setBufArg(RooAbsReal* arg) { _nativeReal = arg ; }
    const RooAbsReal* bufArg() const { return _nativeReal ; }

    void setBuffer(RooAbsReal* real, Double_t* newBuf) { 
      _real = real ;
      _buf = newBuf ; 
      if (_nativeBuf==0) {
	_nativeBuf=newBuf ;
      }
    }

    void setNativeBuffer(Double_t* newBuf=0) {       
      _nativeBuf = newBuf ? newBuf : _buf ; 
    }

    void setDependents(const RooArgSet& deps) {
      if (_tracker) {
	delete _tracker ;
      }
      _tracker = new RooChangeTracker(Form("track_%s",_nativeReal->GetName()),"tracker",deps) ;
    }
    
    Bool_t needRecalc() {
      if (!_tracker) return kFALSE ;
      return _tracker->hasChanged(kTRUE) ;
    }

    void fill() { 
      _vec.push_back(*_buf) ; 
      _vec0 = &_vec.front() ;
    } ;

    void write(Int_t i) {
/*         std::cout << "write(" << this << ") [" << i << "] nativeReal = " << _nativeReal << " = " << _nativeReal->GetName() << " real = " << _real << " buf = " << _buf << " value = " << *_buf << " native getVal() = " << _nativeReal->getVal() << " getVal() = " << _real->getVal() << std::endl ;  */
      _vec[i] = *_buf ;
    }
    
    void reset() { 
      // make sure the vector releases the underlying memory
      std::vector<Double_t> tmp;
      _vec.swap(tmp);
      _vec0 = 0;
    }

    inline void get(Int_t idx) const { 
      *_buf = *(_vec0+idx) ; 
    }

    inline void getNative(Int_t idx) const { 
      *_nativeBuf = *(_vec0+idx) ; 
    }

    Int_t size() const { return _vec.size() ; }

    void resize(Int_t siz) {
      if (siz < Int_t(_vec.capacity()) / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
	// do an expensive copy, if we save at least a factor 2 in size
	std::vector<Double_t> tmp;
	tmp.reserve(std::max(siz, Int_t(VECTOR_BUFFER_SIZE / sizeof(Double_t))));
	if (!_vec.empty())
	    tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz));
	if (Int_t(tmp.size()) != siz) 
	    tmp.resize(siz);
	_vec.swap(tmp);
      } else {
	_vec.resize(siz);
      }
      _vec0 = _vec.size() > 0 ? &_vec.front() : 0;
    }

    void reserve(Int_t siz) {
      _vec.reserve(siz);
      _vec0 = _vec.size() > 0 ? &_vec.front() : 0;
    }

  protected:
    std::vector<Double_t> _vec ;

  private:
    friend class RooVectorDataStore ;
    RooAbsReal* _nativeReal ;
    RooAbsReal* _real ;
    Double_t* _buf ; //!
    Double_t* _nativeBuf ; //!
    Double_t* _vec0 ; //!
    RooChangeTracker* _tracker ; //
    RooArgSet* _nset ; //! 
    ClassDef(RealVector,1) // STL-vector-based Data Storage class
  } ;
  

  class RealFullVector : public RealVector {
  public:
    RealFullVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) : RealVector(initialCapacity),
      _bufE(0), _bufEL(0), _bufEH(0), 
      _nativeBufE(0), _nativeBufEL(0), _nativeBufEH(0), 
      _vecE(0), _vecEL(0), _vecEH(0) { 
    }

    RealFullVector(RooAbsReal* arg, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(Double_t))) : 
      RealVector(arg,initialCapacity), 
      _bufE(0), _bufEL(0), _bufEH(0), 
      _nativeBufE(0), _nativeBufEL(0), _nativeBufEH(0), 
      _vecE(0), _vecEL(0), _vecEH(0) { 
    }

    virtual ~RealFullVector() {
      if (_vecE) delete _vecE ;
      if (_vecEL) delete _vecEL ;
      if (_vecEH) delete _vecEH ;
    }
    
    RealFullVector(const RealFullVector& other, RooAbsReal* real=0) : RealVector(other,real),
      _bufE(other._bufE), _bufEL(other._bufEL), _bufEH(other._bufEH),
      _nativeBufE(other._nativeBufE), _nativeBufEL(other._nativeBufEL), _nativeBufEH(other._nativeBufEH) {
      _vecE = (other._vecE) ? new std::vector<Double_t>(*other._vecE) : 0 ;
      _vecEL = (other._vecEL) ? new std::vector<Double_t>(*other._vecEL) : 0 ;
      _vecEH = (other._vecEH) ? new std::vector<Double_t>(*other._vecEH) : 0 ;
    }

    RealFullVector(const RealVector& other, RooAbsReal* real=0) : RealVector(other,real), 
      _bufE(0), _bufEL(0), _bufEH(0),
      _nativeBufE(0), _nativeBufEL(0), _nativeBufEH(0) {
      _vecE = 0 ;
      _vecEL = 0 ; 
      _vecEH = 0 ; 
    }

    RealFullVector& operator=(const RealFullVector& other) {
      if (&other==this) return *this;
      RealVector::operator=(other);
      _bufE = other._bufE;
      _bufEL = other._bufEL;
      _bufEH = other._bufEH;
      _nativeBufE = other._nativeBufE;
      _nativeBufEL = other._nativeBufEL;
      _nativeBufEH = other._nativeBufEH;
      std::vector<Double_t>* src[3] = { other._vecE, other._vecEL, other._vecEH };
      std::vector<Double_t>* dst[3] = { _vecE, _vecEL, _vecEH };
      for (unsigned i = 0; i < 3; ++i) {
	if (src[i]) {
	  if (dst[i]) {
	    if (dst[i]->size() <= src[i]->capacity() / 2 &&
		src[i]->capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
	      std::vector<Double_t> tmp;
	      tmp.reserve(std::max(src[i]->size(), VECTOR_BUFFER_SIZE / sizeof(Double_t)));
	      tmp.assign(src[i]->begin(), src[i]->end());
	      dst[i]->swap(tmp);
	    } else {
	      *dst[i] = *src[i];
	    }
	  } else {
	    dst[i] = new std::vector<Double_t>(*src[i]);
	  }
	} else {
	  delete dst[i];
	  dst[i] = 0;
	}
      }
      return *this;
    }
    
    void setErrorBuffer(Double_t* newBuf) { 
/*       std::cout << "setErrorBuffer(" << _nativeReal->GetName() << ") newBuf = " << newBuf << std::endl ; */
      _bufE = newBuf ; 
      if (!_vecE) _vecE = new std::vector<Double_t> ;
      _vecE->reserve(_vec.capacity()) ;
      if (!_nativeBufE) _nativeBufE = _bufE ;
    }
    void setAsymErrorBuffer(Double_t* newBufL, Double_t* newBufH) { 
      _bufEL = newBufL ; _bufEH = newBufH ; 
      if (!_vecEL) {
        _vecEL = new std::vector<Double_t> ;
	_vecEH = new std::vector<Double_t> ;
	_vecEL->reserve(_vec.capacity()) ;
	_vecEH->reserve(_vec.capacity()) ;
      }
      if (!_nativeBufEL) {
	_nativeBufEL = _bufEL ;
	_nativeBufEH = _bufEH ;
      }
    }

    inline void getNative(Int_t idx) const { 
      RealVector::getNative(idx) ;
      if (_vecE) {
	*_nativeBufE = (*_vecE)[idx] ; 
      }
      if (_vecEL) {
	*_nativeBufEL = (*_vecEL)[idx] ; 
	*_nativeBufEH = (*_vecEH)[idx] ; 
      }
    }
        
    void fill() { 
      RealVector::fill() ;
      if (_vecE) _vecE->push_back(*_bufE) ;
      if (_vecEL) _vecEL->push_back(*_bufEL) ;
      if (_vecEH) _vecEH->push_back(*_bufEH) ;
    } ;

    void write(Int_t i) {
      RealVector::write(i) ;
      if (_vecE) (*_vecE)[i] = *_bufE ;
      if (_vecEL) (*_vecEL)[i] = *_bufEL ;
      if (_vecEH) (*_vecEH)[i] = *_bufEH ;
    }
    
    void reset() { 
      RealVector::reset();
      if (_vecE) {
	std::vector<Double_t> tmp;
	_vecE->swap(tmp);
      }
      if (_vecEL) {
	std::vector<Double_t> tmp;
	_vecEL->swap(tmp);
      }
      if (_vecEH) {
	std::vector<Double_t> tmp;
	_vecEH->swap(tmp);
      }
    }

    inline void get(Int_t idx) const { 
      RealVector::get(idx) ;
      if (_vecE) *_bufE = (*_vecE)[idx];
      if (_vecEL) *_bufEL = (*_vecEL)[idx] ;
      if (_vecEH) *_bufEH = (*_vecEH)[idx] ;
    }

    void resize(Int_t siz) {
      RealVector::resize(siz);
      std::vector<Double_t>* vlist[3] = { _vecE, _vecEL, _vecEH };
      for (unsigned i = 0; i < 3; ++i) {
	if (!vlist[i]) continue;
	if (vlist[i]) {
	  if (siz < Int_t(vlist[i]->capacity()) / 2 && vlist[i]->capacity() > (VECTOR_BUFFER_SIZE / sizeof(Double_t))) {
	    // if we gain a factor of 2 in memory, we copy and swap
	    std::vector<Double_t> tmp;
	    tmp.reserve(std::max(siz, Int_t(VECTOR_BUFFER_SIZE / sizeof(Double_t))));
	    if (!vlist[i]->empty())
		tmp.assign(vlist[i]->begin(),
			std::min(_vec.end(), _vec.begin() + siz));
	    if (Int_t(tmp.size()) != siz) 
		tmp.resize(siz);
	    vlist[i]->swap(tmp);
	  } else {
	    vlist[i]->resize(siz);
	  }
	}
      }
    }

    void reserve(Int_t siz) {
      RealVector::reserve(siz);
      if (_vecE) _vecE->reserve(siz);
      if (_vecEL) _vecEL->reserve(siz);
      if (_vecEH) _vecEH->reserve(siz);
    }

  private:
    friend class RooVectorDataStore ;
    Double_t *_bufE ; //!
    Double_t *_bufEL ; //!
    Double_t *_bufEH ; //!
    Double_t *_nativeBufE ; //!
    Double_t *_nativeBufEL ; //! 
    Double_t *_nativeBufEH ; //!
    std::vector<Double_t> *_vecE, *_vecEL, *_vecEH ;
    ClassDef(RealFullVector,1) // STL-vector-based Data Storage class
  } ;
  

  class CatVector {
  public:
    CatVector(UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(RooCatType))) : 
      _cat(0), _buf(0), _nativeBuf(0), _vec0(0)
    {
      _vec.reserve(initialCapacity);
    }

    CatVector(RooAbsCategory* cat, UInt_t initialCapacity=(VECTOR_BUFFER_SIZE / sizeof(RooCatType))) : 
      _cat(cat), _buf(0), _nativeBuf(0), _vec0(0)
    {
      _vec.reserve(initialCapacity);
    }

    virtual ~CatVector() {
    }

    CatVector(const CatVector& other, RooAbsCategory* cat=0) : 
      _cat(cat?cat:other._cat), _buf(other._buf), _nativeBuf(other._nativeBuf), _vec(other._vec) 
      {
	_vec0 = _vec.size()>0 ? &_vec.front() : 0 ;
      }

    CatVector& operator=(const CatVector& other) {
      if (&other==this) return *this;
      _cat = other._cat;
      _buf = other._buf;
      _nativeBuf = other._nativeBuf;
      if (other._vec.size() <= _vec.capacity() / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(RooCatType))) {
	std::vector<RooCatType> tmp;
	tmp.reserve(std::max(other._vec.size(), VECTOR_BUFFER_SIZE / sizeof(RooCatType)));
	tmp.assign(other._vec.begin(), other._vec.end());
	_vec.swap(tmp);
      } else {
	_vec = other._vec;
      }
      _vec0 = _vec.size()>0 ? &_vec.front() : 0;
      return *this;
    }

    void setBuffer(RooCatType* newBuf) { 
      _buf = newBuf ; 
      if (_nativeBuf==0) _nativeBuf=newBuf ;
    }

    void setNativeBuffer(RooCatType* newBuf=0) {       
      _nativeBuf = newBuf ? newBuf : _buf ; 
    }
    
    void fill() { 
      _vec.push_back(*_buf) ; 
      _vec0 = &_vec.front() ;
    } ;
    void write(Int_t i) { 
      _vec[i]=*_buf ; 
    } ;
    void reset() { 
      // make sure the vector releases the underlying memory
      std::vector<RooCatType> tmp;
      _vec.swap(tmp);
      _vec0 = 0;
    }
    inline void get(Int_t idx) const { 
      _buf->assignFast(*(_vec0+idx)) ;
    }
    inline void getNative(Int_t idx) const { 
      _nativeBuf->assignFast(*(_vec0+idx)) ;
    }
    Int_t size() const { return _vec.size() ; }

    void resize(Int_t siz) {
      if (siz < Int_t(_vec.capacity()) / 2 && _vec.capacity() > (VECTOR_BUFFER_SIZE / sizeof(RooCatType))) {
	// do an expensive copy, if we save at least a factor 2 in size
	std::vector<RooCatType> tmp;
	tmp.reserve(std::max(siz, Int_t(VECTOR_BUFFER_SIZE / sizeof(RooCatType))));
	if (!_vec.empty())
	    tmp.assign(_vec.begin(), std::min(_vec.end(), _vec.begin() + siz));
	if (Int_t(tmp.size()) != siz) 
	    tmp.resize(siz);
	_vec.swap(tmp);
      } else {
	_vec.resize(siz);
      }
      _vec0 = _vec.size() > 0 ? &_vec.front() : 0;
    }

    void reserve(Int_t siz) {
      _vec.reserve(siz);
      _vec0 = _vec.size() > 0 ? &_vec.front() : 0;
    }

    void setBufArg(RooAbsCategory* arg) { _cat = arg; }
    const RooAbsCategory* bufArg() const { return _cat; }

  private:
    friend class RooVectorDataStore ;
    RooAbsCategory* _cat ;
    RooCatType* _buf ;  //!
    RooCatType* _nativeBuf ;  //!
    std::vector<RooCatType> _vec ;
    RooCatType* _vec0 ; //!
    ClassDef(CatVector,1) // STL-vector-based Data Storage class
  } ;
  

 protected:

  friend class RooAbsReal ;
  friend class RooAbsCategory ;
  friend class RooRealVar ;
  std::vector<RealVector*>& realStoreList() { return _realStoreList ; }
  std::vector<RealFullVector*>& realfStoreList() { return _realfStoreList ; }
  std::vector<CatVector*>& catStoreList() { return _catStoreList ; }

  CatVector* addCategory(RooAbsCategory* cat) {

    CatVector* cv(0) ;

    // First try a match by name
    std::vector<CatVector*>::iterator iter = _catStoreList.begin() ;
    for (; iter!=_catStoreList.end() ; ++iter) {
      if (std::string((*iter)->bufArg()->GetName())==cat->GetName()) {
	cv = (*iter)  ;
	return cv ;
      }
    }

    // If nothing found this will make an entry
    _catStoreList.push_back(new CatVector(cat)) ;
    _nCat++ ;

    // Update cached ptr to first element as push_back may have reallocated
    _firstCat = &_catStoreList.front() ;

    return _catStoreList.back() ;
  }

  RealVector* addReal(RooAbsReal* real) {

    RealVector* rv(0) ;
    
    // First try a match by name
    std::vector<RealVector*>::iterator iter = _realStoreList.begin() ;
    for (; iter!=_realStoreList.end() ; ++iter) {
      //if (std::string((*iter)->bufArg()->GetName())==real->GetName()) {
      if ((*iter)->bufArg()->namePtr()==real->namePtr()) {
	rv = (*iter) ;
	return rv ;
      }
    }    

    // Then check if an entry already exists for a full real    
    std::vector<RealFullVector*>::iterator iter2 = _realfStoreList.begin() ;
    for (; iter2!=_realfStoreList.end() ; ++iter2) {
      //if (std::string((*iter2)->bufArg()->GetName())==real->GetName()) {
      if ((*iter2)->bufArg()->namePtr()==real->namePtr()) {
	// Return full vector as RealVector base class here
	return (*iter2) ;
      }
    }    


    // If nothing found this will make an entry
    _realStoreList.push_back(new RealVector(real)) ;
    _nReal++ ;

    // Update cached ptr to first element as push_back may have reallocated
    _firstReal = &_realStoreList.front() ;


    return _realStoreList.back() ;
  }

  Bool_t isFullReal(RooAbsReal* real) {
    
    // First try a match by name
    std::vector<RealFullVector*>::iterator iter = _realfStoreList.begin() ;
    for (; iter!=_realfStoreList.end() ; ++iter) {
      if (std::string((*iter)->bufArg()->GetName())==real->GetName()) {
	return kTRUE ;
      }
    }        
    return kFALSE ;
  }

  Bool_t hasError(RooAbsReal* real) {
    
    // First try a match by name
    std::vector<RealFullVector*>::iterator iter = _realfStoreList.begin() ;
    for (; iter!=_realfStoreList.end() ; ++iter) {
      if (std::string((*iter)->bufArg()->GetName())==real->GetName()) {
	return (*iter)->_vecE ? kTRUE : kFALSE ;
      }
    }        
    return kFALSE ;
  }

  Bool_t hasAsymError(RooAbsReal* real) {
    
    // First try a match by name
    std::vector<RealFullVector*>::iterator iter = _realfStoreList.begin() ;
    for (; iter!=_realfStoreList.end() ; ++iter) {
      if (std::string((*iter)->bufArg()->GetName())==real->GetName()) {
	return (*iter)->_vecEL ? kTRUE : kFALSE ;
      }
    }        
    return kFALSE ;
  }

  RealFullVector* addRealFull(RooAbsReal* real) {
    
    RealFullVector* rv(0) ;
    
    // First try a match by name
    std::vector<RealFullVector*>::iterator iter = _realfStoreList.begin() ;
    for (; iter!=_realfStoreList.end() ; ++iter) {
      if (std::string((*iter)->bufArg()->GetName())==real->GetName()) {
	rv = (*iter) ;
	return rv ;
      }
    }    

    // Then check if an entry already exists for a bare real    
    std::vector<RealVector*>::iterator iter2 = _realStoreList.begin() ;
    for (; iter2!=_realStoreList.end() ; ++iter2) {
      if (std::string((*iter2)->bufArg()->GetName())==real->GetName()) {

	// Convert element to full and add to full list
	_realfStoreList.push_back(new RealFullVector(*(*iter2),real)) ;
	_nRealF++ ;
	_firstRealF = &_realfStoreList.front() ;
	
	// Delete bare element
	RealVector* tmp = *iter2 ;
	_realStoreList.erase(iter2) ;
	delete tmp ;
        if (_realStoreList.size() > 0)
        _firstReal = &_realStoreList.front() ;
	else
        _firstReal = 0;
	_nReal-- ;

	return _realfStoreList.back() ;
      }
    }    

    // If nothing found this will make an entry
    _realfStoreList.push_back(new RealFullVector(real)) ;
    _nRealF++ ;

    // Update cached ptr to first element as push_back may have reallocated
    _firstRealF = &_realfStoreList.front() ;


    return _realfStoreList.back() ;
  }

  virtual Bool_t hasFilledCache() const { return _cache ? kTRUE : kFALSE ; }  

  void forceCacheUpdate() ; 

 private:
  RooArgSet _varsww ;
  RooRealVar* _wgtVar ;     // Pointer to weight variable (if set)

  std::vector<RealVector*> _realStoreList ;
  std::vector<RealFullVector*> _realfStoreList ;
  std::vector<CatVector*> _catStoreList ;

  void setAllBuffersNative() ;

  Int_t _nReal ;
  Int_t _nRealF ;
  Int_t _nCat ;
  Int_t _nEntries ;
  RealVector** _firstReal ; //! do not persist
  RealFullVector** _firstRealF ; //! do not persist
  CatVector** _firstCat ; //! do not persist
  Double_t _sumWeight ; 
  Double_t _sumWeightCarry;

  Double_t* _extWgtArray ;         //! External weight array
  Double_t* _extWgtErrLoArray ;    //! External weight array - low error
  Double_t* _extWgtErrHiArray ;    //! External weight array - high error
  Double_t* _extSumW2Array ;       //! External sum of weights array

  mutable Double_t  _curWgt ;      // Weight of current event
  mutable Double_t  _curWgtErrLo ; // Weight of current event
  mutable Double_t  _curWgtErrHi ; // Weight of current event
  mutable Double_t  _curWgtErr ;   // Weight of current event

  RooVectorDataStore* _cache ; //! Optimization cache
  RooAbsArg* _cacheOwner ; //! Cache owner

  Bool_t _forcedUpdate ; //! Request for forced cache update 

  ClassDef(RooVectorDataStore,2) // STL-vector-based Data Storage class
};


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