RooAICRegistry.cxx

Go to the documentation of this file.

/*****************************************************************************
 * 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)             *
 *****************************************************************************/
 
/**
\file RooAICRegistry.cxx
\class RooAICRegistry
\ingroup Roofitcore
 
Utility class for operator p.d.f
classes that keeps track of analytical integration codes and
associated normalization and integration sets.
**/
 
#include "RooAICRegistry.h"
#include "RooMsgService.h"
#include "RooArgSet.h"
 
#include "Riostream.h"
 
 
namespace {
 
RooArgSet * makeSnapshot(RooArgSet const* set) {
  if(!set) {
    return nullptr;
  }
  auto out = new RooArgSet;
  set->snapshot(*out, false);
  return out;
}
 
}
 
////////////////////////////////////////////////////////////////////////////////
 
RooAICRegistry::RooAICRegistry(UInt_t size)
  : _clArr(0), _asArr1(0), _asArr2(0), _asArr3(0), _asArr4(0)
{
  _clArr.reserve(size);
  _asArr1.reserve(size);
  _asArr2.reserve(size);
  _asArr3.reserve(size);
  _asArr4.reserve(size);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy constructor
 
RooAICRegistry::RooAICRegistry(const RooAICRegistry &other)
{
   copyImpl(other);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Copy assignment
 
RooAICRegistry &RooAICRegistry::operator=(const RooAICRegistry &other)
{
   // Delete code list array, if allocated
   for (unsigned int i = 0; i < _clArr.size(); ++i) {
      if (_asArr1[i]) {
         delete _asArr1[i];
         _asArr1[i] = nullptr;
      }
      if (_asArr2[i]) {
         delete _asArr2[i];
         _asArr2[i] = nullptr;
      }
      if (_asArr3[i]) {
         delete _asArr3[i];
         _asArr3[i] = nullptr;
      }
      if (_asArr4[i]) {
         delete _asArr4[i];
         _asArr4[i] = nullptr;
      }
   }
   copyImpl(other);
   return *this;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor
 
RooAICRegistry::~RooAICRegistry()
{
  // Delete code list array, if allocated
  for (unsigned int i = 0; i < _clArr.size(); ++i) {
    if (_asArr1[i]) delete   _asArr1[i];
    if (_asArr2[i]) delete   _asArr2[i];
    if (_asArr3[i]) delete   _asArr3[i];
    if (_asArr4[i]) delete   _asArr4[i];
  }
}
 
 
void RooAICRegistry::copyImpl(const RooAICRegistry &other)
{
   _clArr = other._clArr;
 
   // Copy code-list array if other PDF has one
   UInt_t size = other._clArr.size();
   if (size) {
      _asArr1.resize(size, nullptr);
      _asArr2.resize(size, nullptr);
      _asArr3.resize(size, nullptr);
      _asArr4.resize(size, nullptr);
      for (UInt_t i = 0; i < size; ++i) {
         _asArr1[i] = makeSnapshot(other._asArr1[i]);
         _asArr2[i] = makeSnapshot(other._asArr2[i]);
         _asArr3[i] = makeSnapshot(other._asArr3[i]);
         _asArr4[i] = makeSnapshot(other._asArr4[i]);
      }
   }
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Get size of _clArr vector
 
size_t RooAICRegistry::size() const
{
  return _clArr.size();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Store given arrays of integer codes, and up to four RooArgSets in
/// the registry (each setX pointer may be null). The registry
/// clones all RooArgSets internally so the RooArgSets passed as
/// arguments do not need to live beyond the store() call. The return
/// value is a unique master code for the given configuration of
/// integers and RooArgSets. If an identical combination is
/// previously stored in the registry no objects are stored and the
/// unique code of the existing entry is returned.
 
Int_t RooAICRegistry::store(const std::vector<Int_t>& codeList, RooArgSet* set1,
                            RooArgSet* set2, RooArgSet* set3, RooArgSet* set4)
{
  // Loop over code-list array
  for (UInt_t i = 0; i < _clArr.size(); ++i) {
    // Existing slot, compare with current list, if matched return index
    bool match(true) ;
 
    // Check that array contents is identical
    match &= _clArr[i] == codeList;
 
    // Check that supplied configuration of lists is identical
    if (_asArr1[i] && !set1) match=false ;
    if (!_asArr1[i] && set1) match=false ;
    if (_asArr2[i] && !set2) match=false ;
    if (!_asArr2[i] && set2) match=false ;
    if (_asArr3[i] && !set3) match=false ;
    if (!_asArr3[i] && set3) match=false ;
    if (_asArr4[i] && !set4) match=false ;
    if (!_asArr4[i] && set4) match=false ;
 
    // Check that contents of arrays is identical
    if (_asArr1[i] && set1 && !set1->equals(*_asArr1[i])) match=false ;
    if (_asArr2[i] && set2 && !set2->equals(*_asArr2[i])) match=false ;
    if (_asArr3[i] && set3 && !set3->equals(*_asArr3[i])) match=false ;
    if (_asArr4[i] && set4 && !set4->equals(*_asArr4[i])) match=false ;
 
    if (match) {
      if (set1) delete set1 ;
      if (set2) delete set2 ;
      if (set3) delete set3 ;
      if (set4) delete set4 ;
      return i ;
    }
  }
 
  // Store code list and return index
  _clArr.push_back(codeList);
  _asArr1.emplace_back(makeSnapshot(set1));
  _asArr2.emplace_back(makeSnapshot(set2));
  _asArr3.emplace_back(makeSnapshot(set3));
  _asArr4.emplace_back(makeSnapshot(set4));
 
  if (set1) delete set1 ;
  if (set2) delete set2 ;
  if (set3) delete set3 ;
  if (set4) delete set4 ;
  return _clArr.size() - 1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Retrieve the array of integer codes associated with the given master code
 
const std::vector<Int_t>& RooAICRegistry::retrieve(Int_t masterCode) const
{
  return _clArr[masterCode] ;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Retrieve the array of integer codes associated with the given master code
/// and set the passed set1 pointer to the first RooArgSet associated with this master code
 
const std::vector<Int_t>& RooAICRegistry::retrieve(Int_t masterCode, pRooArgSet& set1) const
{
  set1 = _asArr1[masterCode] ;
  return _clArr[masterCode] ;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Retrieve the array of integer codes associated with the given master code
/// and set the passed set1,set2 pointers to the first and second  RooArgSets associated with this
/// master code respectively
 
const std::vector<Int_t>& RooAICRegistry::retrieve
(Int_t masterCode, pRooArgSet& set1, pRooArgSet& set2) const
{
  set1 = _asArr1[masterCode] ;
  set2 = _asArr2[masterCode] ;
  return _clArr[masterCode] ;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Retrieve the array of integer codes associated with the given master code
/// and set the passed set1-4 pointers to the four  RooArgSets associated with this
/// master code respectively
 
const std::vector<Int_t>& RooAICRegistry::retrieve
(Int_t masterCode, pRooArgSet& set1, pRooArgSet& set2, pRooArgSet& set3, pRooArgSet& set4) const
{
  set1 = _asArr1[masterCode] ;
  set2 = _asArr2[masterCode] ;
  set3 = _asArr3[masterCode] ;
  set4 = _asArr4[masterCode] ;
  return _clArr[masterCode] ;
}