RooHistPdf.cxx

Go to the documentation of this file.

/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofit:$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)             *
 *****************************************************************************/
 
/**
\file RooHistPdf.cxx
\class RooHistPdf
\ingroup Roofitcore
 
A probability density function sampled from a
multidimensional histogram. The histogram distribution is explicitly
normalized by RooHistPdf and can have an arbitrary number of real or
discrete dimensions.
 
A p.d.f. cannot be negative. If the input histogram contains bins with
negative content, the bin contents are clipped to zero and the bin errors are kept the same.
The input histogram is not modified.
**/
 
#include "Riostream.h"
 
#include "RooCategory.h"
#include "RooCurve.h"
#include "RooDataHist.h"
#include "RooFitImplHelpers.h"
#include "RooGlobalFunc.h"
#include "RooHistPdf.h"
#include "RooMsgService.h"
#include "RooRealVar.h"
#include "RooUniformBinning.h"
#include "RooWorkspace.h"
 
#include "TError.h"
#include "TBuffer.h"
 
#include <algorithm>
#include <cmath>
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor from a RooDataHist. RooDataHist dimensions
/// can be either real or discrete. See RooDataHist::RooDataHist for details on the binning.
/// RooHistPdf neither owns or clone 'dhist' and the user must ensure the input histogram exists
/// for the entire life span of this PDF.
/// The only exception is a 'dhist' that contains bins with negative content: those are set to
/// zero in an internally-owned clone that is used instead (see clampNegativeBins()).
 
RooHistPdf::RooHistPdf(const char *name, const char *title, const RooArgSet& vars,
             const RooDataHist& dhist, Int_t intOrder) :
  RooAbsPdf(name,title),
  _pdfObsList("pdfObs","List of p.d.f. observables",this),
  _dataHist(const_cast<RooDataHist*>(&dhist)),
  _intOrder(intOrder)
{
  _histObsList.addClone(vars) ;
  _pdfObsList.add(vars) ;
 
  // Verify that vars and dhist.get() have identical contents
  const RooArgSet* dvars = dhist.get() ;
  if (vars.size()!=dvars->size()) {
    coutE(InputArguments) << "RooHistPdf::ctor(" << GetName()
           << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
    assert(0) ;
  }
  for (const auto arg : vars) {
    if (!dvars->find(arg->GetName())) {
      coutE(InputArguments) << "RooHistPdf::ctor(" << GetName()
             << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
      assert(0) ;
    }
  }
 
 
  // Adjust ranges of _histObsList to those of _dataHist
  for (const auto hobs : _histObsList) {
    // Guaranteed to succeed, since checked above in constructor
    RooAbsArg* dhobs = dhist.get()->find(hobs->GetName()) ;
    RooRealVar* dhreal = dynamic_cast<RooRealVar*>(dhobs) ;
    if (dhreal){
      (static_cast<RooRealVar*>(hobs))->setRange(dhreal->getMin(),dhreal->getMax()) ;
    }
  }
 
  clampNegativeBins();
}
 
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor from a RooDataHist. The first list of observables are the p.d.f.
/// observables, which may any RooAbsReal (function or variable). The second list
/// are the corresponding observables in the RooDataHist which must be of type
/// RooRealVar or RooCategory This constructor thus allows to apply a coordinate transformation
/// on the histogram data to be applied.
 
RooHistPdf::RooHistPdf(const char *name, const char *title, const RooArgList& pdfObs,
             const RooArgList& histObs, const RooDataHist& dhist, Int_t intOrder) :
  RooAbsPdf(name,title),
  _pdfObsList("pdfObs","List of p.d.f. observables",this),
  _dataHist(const_cast<RooDataHist*>(&dhist)),
  _intOrder(intOrder)
{
  _histObsList.addClone(histObs) ;
  _pdfObsList.add(pdfObs) ;
 
  // Verify that vars and dhist.get() have identical contents
  const RooArgSet* dvars = dhist.get() ;
  if (histObs.size()!=dvars->size()) {
    coutE(InputArguments) << "RooHistPdf::ctor(" << GetName()
           << ") ERROR histogram variable list and RooDataHist must contain the same variables." << std::endl ;
    throw(std::string("RooHistPdf::ctor() ERROR: histogram variable list and RooDataHist must contain the same variables")) ;
  }
 
  for (const auto arg : histObs) {
    if (!dvars->find(arg->GetName())) {
      coutE(InputArguments) << "RooHistPdf::ctor(" << GetName()
             << ") ERROR variable list and RooDataHist must contain the same variables." << std::endl ;
      throw(std::string("RooHistPdf::ctor() ERROR: histogram variable list and RooDataHist must contain the same variables")) ;
    }
    if (!arg->isFundamental()) {
      coutE(InputArguments) << "RooHistPdf::ctor(" << GetName()
             << ") ERROR all elements of histogram observables set must be of type RooRealVar or RooCategory." << std::endl ;
      throw(std::string("RooHistPdf::ctor() ERROR all elements of histogram observables set must be of type RooRealVar or RooCategory.")) ;
    }
  }
 
 
  // Adjust ranges of _histObsList to those of _dataHist
  for (const auto hobs : _histObsList) {
    // Guaranteed to succeed, since checked above in constructor
    RooAbsArg* dhobs = dhist.get()->find(hobs->GetName()) ;
    RooRealVar* dhreal = dynamic_cast<RooRealVar*>(dhobs) ;
    if (dhreal){
      (static_cast<RooRealVar*>(hobs))->setRange(dhreal->getMin(),dhreal->getMax()) ;
    }
  }
 
  clampNegativeBins();
}
 
RooHistPdf::RooHistPdf(const char *name, const char *title, const RooArgSet &vars, std::unique_ptr<RooDataHist> dhist,
                       int intOrder)
   : RooHistPdf{name, title, vars, *dhist, intOrder}
{
   initializeOwnedDataHist(std::move(dhist));
}
RooHistPdf::RooHistPdf(const char *name, const char *title, const RooArgList &pdfObs, const RooArgList &histObs,
                       std::unique_ptr<RooDataHist> dhist, int intOrder)
   : RooHistPdf{name, title, pdfObs, histObs, *dhist, intOrder}
{
   initializeOwnedDataHist(std::move(dhist));
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor
 
RooHistPdf::RooHistPdf(const RooHistPdf& other, const char* name) :
  RooAbsPdf(other,name),
  _pdfObsList("pdfObs",this,other._pdfObsList),
  _dataHist(other._dataHist),
  _intOrder(other._intOrder),
  _cdfBoundaries(other._cdfBoundaries),
  _totVolume(other._totVolume),
  _unitNorm(other._unitNorm)
{
  _histObsList.addClone(other._histObsList) ;
}
 
RooDataHist* RooHistPdf::cloneAndOwnDataHist(const char* newname) {
   if (_ownedDataHist) return _ownedDataHist.get();
   _ownedDataHist.reset(static_cast<RooDataHist*>(_dataHist->Clone(newname)));
   _dataHist = _ownedDataHist.get();
   return _dataHist;
}
 
void RooHistPdf::clampNegativeBins()
{
   const std::size_t nBins = _dataHist->numEntries();
 
   std::size_t nNegative = 0;
   double sumNegative = 0.;
   for (std::size_t i = 0; i < nBins; ++i) {
      if (_dataHist->weight(i) < 0.) {
         ++nNegative;
         sumNegative += _dataHist->weight(i);
      }
   }
   if (nNegative == 0) {
      return;
   }
 
   coutW(InputArguments) << "RooHistPdf::ctor(" << GetName() << ") WARNING: input histogram \"" << _dataHist->GetName()
                         << "\" contains " << nNegative
                         << " bins with negative content (sum of negative contents: " << sumNegative
                         << "). A p.d.f. cannot be negative, so these bins contents are clipped to zero while "
                            "preserving the error. The input "
                            "histogram is not modified. To avoid this message, remove the negative bin contents "
                            "before constructing the RooHistPdf."
                         << std::endl;
 
   RooDataHist *dh = cloneAndOwnDataHist();
   const bool hasSumW2 = dh->sumW2Array() != nullptr;
   for (std::size_t i = 0; i < nBins; ++i) {
      if (dh->weight(i) < 0.) {
         // Keep the original bin error: clamping the content is a
         // normalization-consistency measure, not a statement that the bin is
         // now known exactly. The error still quantifies the statistical
         // uncertainty of the original bin content estimate (e.g. whether the
         // negative content is compatible with a fluctuation around zero),
         // and setting it to zero would introduce undercoverage, which is
         // always undesired. It would also irreversibly discard information
         // for anyone retrieving the histogram via dataHist(), including any
         // future per-bin MC-stat treatment, where a zero error would wrongly
         // fix the bin at exactly zero.
         const double wgtErr = hasSumW2 ? std::sqrt(std::max(dh->weightSquared(i), 0.)) : 0.;
         dh->set(i, 0., wgtErr);
      }
   }
}
 
void RooHistPdf::doEval(RooFit::EvalContext &ctx) const
{
   std::span<double> output = ctx.output();
 
   // For interpolation and histograms of higher dimension, use base function
   if (_pdfObsList.size() > 1) {
      RooAbsReal::doEval(ctx);
      return;
   }
 
   auto xVals = ctx.at(_pdfObsList[0]);
   _dataHist->weights(output.data(), xVals, _intOrder, true, _cdfBoundaries);
   for (auto &ret : output) {
      ret = std::max(ret, 0.0);
   }
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return the current value: The value of the bin enclosing the current coordinates
/// of the observables, normalized by the histograms contents. Interpolation
/// is applied if the RooHistPdf is configured to do that.
 
double RooHistPdf::evaluate() const
{
  // Transfer values from
  for (unsigned int i=0; i < _pdfObsList.size(); ++i) {
    RooAbsArg* harg = _histObsList[i];
    RooAbsArg* parg = _pdfObsList[i];
 
    if (harg != parg) {
      parg->syncCache() ;
      harg->copyCache(parg,true) ;
      if (!harg->inRange(nullptr)) {
        return 0 ;
      }
    }
  }
 
  double ret = _dataHist->weightFast(_histObsList, _intOrder, !_unitNorm, _cdfBoundaries);
 
  return std::max(ret, 0.0);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return the total volume spanned by the observables of the RooHistPdf
 
double RooHistPdf::totVolume() const
{
  // Return previously calculated value, if any
  if (_totVolume>0) {
    return _totVolume ;
  }
  _totVolume = 1. ;
 
  for (const auto arg : _histObsList) {
    RooRealVar* real = dynamic_cast<RooRealVar*>(arg) ;
    if (real) {
      _totVolume *= (real->getMax()-real->getMin()) ;
    } else {
      RooCategory* cat = dynamic_cast<RooCategory*>(arg) ;
      if (cat) {
   _totVolume *= cat->numTypes() ;
      }
    }
  }
 
  return _totVolume ;
}
 
namespace {
 
bool fullRange(const RooAbsArg& x, const RooAbsArg& y ,const char* range)
{
  const RooAbsRealLValue *_x = dynamic_cast<const RooAbsRealLValue*>(&x);
  const RooAbsRealLValue *_y = dynamic_cast<const RooAbsRealLValue*>(&y);
  if (!_x || !_y) return false;
  if (!range || !strlen(range) || !_x->hasRange(range) ||
      _x->getBinningPtr(range)->isParameterized()) {
    // parameterized ranges may be full range now, but that might change,
    // so return false
    if (range && strlen(range) && _x->getBinningPtr(range)->isParameterized())
      return false;
    return (_x->getMin() == _y->getMin() && _x->getMax() == _y->getMax());
  }
  return (_x->getMin(range) == _y->getMin() && _x->getMax(range) == _y->getMax());
}
 
bool okayForAnalytical(RooAbsArg const& obs, RooArgSet const& allVars)
{
   auto lobs = dynamic_cast<RooAbsRealLValue const*>(&obs);
   if(lobs == nullptr) return false;
 
   bool isOkayForAnalyticalInt = false;
 
   for(RooAbsArg *var : allVars) {
      if(obs.dependsOn(*var)) {
         if(!lobs->isJacobianOK(*var)) return false;
         isOkayForAnalyticalInt = true;
      }
   }
 
   return isOkayForAnalyticalInt;
}
 
} // namespace
 
 
Int_t RooHistPdf::getAnalyticalIntegral(RooArgSet& allVars,
                                        RooArgSet& analVars,
                                        const char* rangeName,
                                        RooArgSet const& histObsList,
                                        RooArgSet const& pdfObsList,
                                        Int_t intOrder)
{
  // First make list of pdf observables to histogram observables
  // and select only those for which the integral is over the full range
 
  Int_t code = 0;
  Int_t frcode = 0;
  bool directSubRange = false;
  for (unsigned int n=0; n < pdfObsList.size() && n < histObsList.size(); ++n) {
    const auto pa = pdfObsList[n];
    const auto ha = histObsList[n];
 
    if (okayForAnalytical(*pa, allVars)) {
      code |= 2 << n;
      analVars.add(*pa);
      if (fullRange(*pa, *ha, rangeName)) {
        frcode |= 2 << n;
      } else if (pa->isFundamental()) {
        // Sub-range integral over the histogram observable itself (no transform).
        directSubRange = true;
      }
    }
  }
 
  if (code == frcode) {
    // integrate over full range of all observables - use bit 0 to indicate
    // full range integration over all observables
    code |= 1;
  }
 
  // the full range. For interpolated histograms (intOrder > 0), fall back to
  // numerical integration over a direct sub-range of the histogram observable.
  // A derived (non-fundamental) observable, such as a linear transform used to
  // renormalize the components of a RooMomentMorphFuncND, keeps the analytical
  // path it relies on.
  if (intOrder > 0 && directSubRange) {
    analVars.removeAll();
    return 0;
  }
  return (code >= 2) ? code : 0;
}
 
 
double RooHistPdf::analyticalIntegral(Int_t code,
                                        const char* rangeName,
                                        RooArgSet const& histObsList,
                                        RooArgSet const& pdfObsList,
                                        RooDataHist& dataHist,
                                        bool histFuncMode) {
  // Simplest scenario, full-range integration over all dependents
  if (((2 << histObsList.size()) - 1) == code) {
    return dataHist.sum(histFuncMode);
  }
 
  // Partial integration scenario, retrieve set of variables, calculate partial
  // sum, figure out integration ranges (if needed)
  RooArgSet intSet;
  std::map<const RooAbsArg*, std::pair<double, double> > ranges;
  for (unsigned int n=0; n < pdfObsList.size() && n < histObsList.size(); ++n) {
    const auto pa = pdfObsList[n];
    const auto ha = histObsList[n];
 
    if (code & (2 << n)) {
      intSet.add(*ha);
    }
    if (!(code & 1)) {
      ranges[ha] = RooHelpers::getRangeOrBinningInterval(pa, rangeName);
    }
    // WVE must sync hist slice list values to pdf slice list
    // Transfer values from
    if (ha != pa) {
      pa->syncCache();
      ha->copyCache(pa,true);
    }
  }
 
  double ret = (code & 1) ? dataHist.sum(intSet,histObsList,true,!histFuncMode) :
                              dataHist.sum(intSet,histObsList,true,!histFuncMode, ranges);
 
  return ret ;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Determine integration scenario. If no interpolation is used,
/// RooHistPdf can perform all integrals over its dependents
/// analytically via partial or complete summation of the input
/// histogram. If interpolation is used on the integral over
/// all histogram observables is supported
 
Int_t RooHistPdf::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const
{
  return getAnalyticalIntegral(allVars, analVars, rangeName, _histObsList, _pdfObsList, _intOrder);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return integral identified by 'code'. The actual integration
/// is deferred to RooDataHist::sum() which implements partial
/// or complete summation over the histograms contents.
 
double RooHistPdf::analyticalIntegral(Int_t code, const char* rangeName) const
{
    return analyticalIntegral(code, rangeName, _histObsList, _pdfObsList, *_dataHist, false);
}
 
 
bool RooHistPdf::forceAnalyticalInt(RooArgSet const& pdfObsList, const RooAbsArg& dep)
{
   bool isOkayForAnalyticalInt = false;
 
   for (RooAbsArg * obs : pdfObsList) {
      if(obs->dependsOn(dep)) {
         // If the observable doesn't depend linearly on the integration
         // variable we will not do analytical integration.
         auto lvalue = dynamic_cast<RooAbsRealLValue const*>(obs);
         if(!(lvalue && lvalue->isJacobianOK(dep))) return false;
         isOkayForAnalyticalInt = true;
      }
   }
 
   return isOkayForAnalyticalInt;
}
 
 
bool RooHistPdf::forceAnalyticalInt(const RooAbsArg& dep) const
{
   return forceAnalyticalInt(_pdfObsList, dep);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return sampling hint for making curves of (projections) of this function
/// as the recursive division strategy of RooCurve cannot deal efficiently
/// with the vertical lines that occur in a non-interpolated histogram
 
std::list<double>* RooHistPdf::plotSamplingHint(RooAbsRealLValue& obs, double xlo, double xhi) const
{
  return plotSamplingHint(*_dataHist, _pdfObsList, _histObsList, _intOrder, obs, xlo, xhi);
}
 
 
std::list<double>* RooHistPdf::plotSamplingHint(RooDataHist const& dataHist,
                                                RooArgSet const& pdfObsList,
                                                RooArgSet const& histObsList,
                                                int intOrder,
                                                RooAbsRealLValue& obs,
                                                double xlo,
                                                double xhi)
{
  // No hints are required when interpolation is used
  if (intOrder>0) {
    return nullptr;
  }
 
  // Check that observable is in dataset, if not no hint is generated
  RooAbsArg* dhObs = nullptr;
  for (unsigned int i=0; i < pdfObsList.size(); ++i) {
    RooAbsArg* histObs = histObsList[i];
    RooAbsArg* pdfObs = pdfObsList[i];
    if (std::string(obs.GetName())==pdfObs->GetName()) {
      dhObs = dataHist.get()->find(histObs->GetName()) ;
      break;
    }
  }
 
  if (!dhObs) {
    return nullptr;
  }
  RooAbsLValue* lval = dynamic_cast<RooAbsLValue*>(dhObs) ;
  if (!lval) {
    return nullptr;
  }
 
  // Retrieve position of all bin boundaries
 
  const RooAbsBinning* binning = lval->getBinningPtr(nullptr);
  std::span<const double> boundaries{binning->array(), static_cast<std::size_t>(binning->numBoundaries())};
 
  // Use the helper function from RooCurve to make sure to get sampling hints
  // that work with the RooFitPlotting.
  return RooCurve::plotSamplingHintForBinBoundaries(boundaries, xlo, xhi);
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Return sampling hint for making curves of (projections) of this function
/// as the recursive division strategy of RooCurve cannot deal efficiently
/// with the vertical lines that occur in a non-interpolated histogram
 
std::list<double>* RooHistPdf::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const
{
  // No hints are required when interpolation is used
  if (_intOrder>0) {
    return nullptr;
  }
 
  // Check that observable is in dataset, if not no hint is generated
  RooAbsLValue* lvarg = dynamic_cast<RooAbsLValue*>(_dataHist->get()->find(obs.GetName())) ;
  if (!lvarg) {
    return nullptr ;
  }
 
  // Retrieve position of all bin boundaries
  const RooAbsBinning* binning = lvarg->getBinningPtr(nullptr);
  double* boundaries = binning->array() ;
 
  auto hint = new std::list<double> ;
 
  // Construct array with pairs of points positioned epsilon to the left and
  // right of the bin boundaries
  for (Int_t i=0 ; i<binning->numBoundaries() ; i++) {
    if (boundaries[i]>=xlo && boundaries[i]<=xhi) {
      hint->push_back(boundaries[i]) ;
    }
  }
 
  return hint ;
}
 
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Only handle case of maximum in all variables
 
Int_t RooHistPdf::getMaxVal(const RooArgSet& vars) const
{
  std::unique_ptr<RooAbsCollection> common{_pdfObsList.selectCommon(vars)};
  if (common->size()==_pdfObsList.size()) {
    return 1;
  }
  return 0 ;
}
 
 
////////////////////////////////////////////////////////////////////////////////
 
double RooHistPdf::maxVal(Int_t code) const
{
  R__ASSERT(code==1) ;
 
  double max(-1) ;
  for (Int_t i=0 ; i<_dataHist->numEntries() ; i++) {
    double wgt = _dataHist->weight(i) ;
    if (wgt>max) max=wgt ;
  }
 
  return max*1.05 ;
}
 
 
 
 
////////////////////////////////////////////////////////////////////////////////
 
bool RooHistPdf::areIdentical(const RooDataHist& dh1, const RooDataHist& dh2)
{
  if (std::abs(dh1.sumEntries()-dh2.sumEntries())>1e-8) return false ;
  if (dh1.numEntries() != dh2.numEntries()) return false ;
  for (int i=0 ; i < dh1.numEntries() ; i++) {
    if (std::abs(dh1.weight(i)-dh2.weight(i))>1e-8) return false ;
  }
  return true ;
}
 
 
 
////////////////////////////////////////////////////////////////////////////////
/// Check if our datahist is already in the workspace
 
bool RooHistPdf::importWorkspaceHook(RooWorkspace& ws)
{
  for(auto const& data : ws.allData()) {
    // If your dataset is already in this workspace nothing needs to be done
    if (data == _dataHist) {
      return false ;
    }
  }
 
  // Check if dataset with given name already exists
  if (RooAbsData* wsdata = ws.embeddedData(_dataHist->GetName())) {
 
    // Yes it exists - now check if it is identical to our internal histogram
    if (wsdata->InheritsFrom(RooDataHist::Class())) {
 
      // Check if histograms are identical
      if (areIdentical(static_cast<RooDataHist&>(*wsdata),*_dataHist)) {
 
   // Exists and is of correct type, and identical -- adjust internal pointer to WS copy
   _dataHist = static_cast<RooDataHist*>(wsdata) ;
      } else {
 
   // not identical, clone rename and import
   auto uniqueName = std::string(_dataHist->GetName()) + "_" + GetName();
   bool flag = ws.import(*_dataHist,RooFit::Rename(uniqueName.c_str()),RooFit::Embedded()) ;
   if (flag) {
     coutE(ObjectHandling) << " RooHistPdf::importWorkspaceHook(" << GetName() << ") unable to import clone of underlying RooDataHist with unique name " << uniqueName << ", abort" << std::endl ;
     return true ;
   }
   _dataHist = static_cast<RooDataHist*>(ws.embeddedData(uniqueName)) ;
      }
 
    } else {
 
      // Exists and is NOT of correct type: clone rename and import
      auto uniqueName = std::string(_dataHist->GetName()) + "_" + GetName();
      bool flag = ws.import(*_dataHist,RooFit::Rename(uniqueName.c_str()),RooFit::Embedded()) ;
      if (flag) {
   coutE(ObjectHandling) << " RooHistPdf::importWorkspaceHook(" << GetName() << ") unable to import clone of underlying RooDataHist with unique name " << uniqueName << ", abort" << std::endl ;
   return true ;
      }
      _dataHist = static_cast<RooDataHist*>(ws.embeddedData(uniqueName));
 
    }
    return false ;
  }
 
  // We need to import our datahist into the workspace
  ws.import(*_dataHist,RooFit::Embedded()) ;
 
  // Redirect our internal pointer to the copy in the workspace
  _dataHist = static_cast<RooDataHist*>(ws.embeddedData(_dataHist->GetName())) ;
  return false ;
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Stream an object of class RooHistPdf.
 
void RooHistPdf::Streamer(TBuffer &R__b)
{
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RooHistPdf::Class(),this);
      // WVE - interim solution - fix proxies here
      //_proxyList.Clear() ;
      //registerProxy(_pdfObsList) ;
   } else {
      R__b.WriteClassBuffer(RooHistPdf::Class(),this);
   }
}