[root] Log of /trunk/roofit/roofitcore/inc/RooComplex.h

Revision 20161 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Oct 1 16:28:25 2007 UTC (7 years, 3 months ago) by wouter
Original Path: trunk/roofitcore/inc/RooComplex.h
File length: 3839 byte(s)
Diff to previous 18735

   o RooAbsCache

    - New abstract base class for cache objects associated with RooAbsArgs.
      Caches register themselves with the owning RooAbsArg and propagate
      all necessary state changes and meta information to objects in the cache


   o RooCacheManager

    - Concrete template implementation of RooAbsCache with an interface
      and functionality styled after RooNormListManager. The template class
      provide no special handling for cache contents that includes RooAbsArg
      objects and does not forward hook calls. It is thus mostly intended
      to cache basic types indexed on a normalization/integration configuration


   o RooObjCacheManager

    - Class derived from RooCacheManager<RooAbsCacheElement> that implements
      all proper call forwarding and handling of state and other meta information
      to RooAbsArg objects embedded in the cache elements. To facilitate this
      functionality the RooAbsCacheElement defines a pure virtual method
      containedArgs() that must be implemented to expose its contents to
      the cache manager. The default behavior on a serverRedirect hook is
      to sterilize the cache. OperMode changes are not forwarded by default
      to the cache contents as cached objects do not necessarily have the
      same operation mode (e.g. if the cache contains an integral of its owner).
      Any calls to optimizeCacheMode(), printCompactTreeHook(), and findConstantNodes()
      are forwarded. Moreover, optimizeCacheMode() calls are remembered and
      any objects inserted in the cache after such a call was received will be
      optimized upon insertion in the cache

   o RooAbsCacheElement

    - Abstract base class for objects to be managed by RooObjCacheManager. Each
      object must in addition to its payload implement the containedArgs()
      member function that exposes the RooAbsArg object content to the manager
      for processing. The argument passed to containedArgs() indicates the use
      case for the returned list of objects, allowing the cache payload to
      return different lists depending upon use. This is for most applications
      not required.


   o RooAbsCachedPdf

    - Abstract base class derived from RooAbsPdf for p.d.f.s that implement 
      value caching in a grid over the entire domain of the observables. 
      The base class implements the overall caching logistics and manages
      the RooDataHists and RooHistPdfs that respresent the cached contents.
      Derived classes must inputBaseName() defined a unique name prefix for
      all cache objects, actualObservales() and actualParameters() to
      determined the actual observables and parameters given a set of 
      available observables and fillCacheObject() which should fill the
      RooDataHist cache for a given obs/params configuration with the
      p.d.fs values.


   o RooAbsSelfCachedPdf

    - Abstract base class derived from RooAbsCachedPdf that implements
      all of the required logistics in RooCachedPdf and only require
      derived classes from RooAbsSelfCachedPdf to implement evaluate().
      Any class derived from RooAbsPdf can thus be trivially switched
      to derived from RooAbsSelfCachedPdf and gain the caching functionality.
      

   o RooCachedPdf

    - Concrete class derived from RooAbsCachedPdf that implements
      the caching of an externally provided p.d.f in the constructor.


   o RooFFTConvPdf

    - Concrete class derived from RooAbsCachedPdf that implement generic
      numeric convolution of two input p.d.f.s using FFT technique
      and convolution theorem. Actual FFTs are calculated by FFTW
      through TVirtualFFT interface in ROOT. Present implementation only supports 
      convolution in one dimension, but this will be extended later
      as there are no fundamental limitations in RooAbsCachedPdf nor FFTW.
 

   o RooHistPdf

    - Moved from RooFit to RooFitCore because it is used by caching classes


   o RooProdPdf

     - Use new RooObjCacheManager to store partial objects

     - Fix memory leak (already patched in 15.0.14h)


   o RooDataHist

     - Use new RooCacheManager template to cache partial bin volumes

     - Add new set(),setAllWeights() method to update current weight and all weights
       respectively, for use in cached p.d.f.s

     - Add sliceIterator() that iterates over all bins in a lower dimensional 
       slice of the dataset


   o RooDataHistSliceIter

    - Class derived from TIterator that implements the iteration
      over a slice in a reduced number of dimensions in a RooDataHist


   o RooMsgService

     - Speed up processing of debug streams in cases where no debug streams are active

     - add macros series oocoutX and oocxcoutX that allow to associate message with
       a different object than *this

   o RooRealBinding

     - Interface new setValue method that allows value to be set outside default
       domain, but inside given alternate named range. For use in numeric integrator
       bindings


   o RooAbsRealLValue

     - Add new inRange() method with range name specifier to check against chosen
       range instead of default range


   o RooCmdConfig

     - Fix dangling return pointer problem in decodeStringOnTheFly() method


   o RooNameSet

     - Fix bug in refoll()


   o RooChi2Var, RooNLLVar

     - Add processing of AddCoefRange() named argument


   o RooConvCoefVar

     - Hold p.d.f in proxy without value/shape state propagation to obtain
       correct dependency of RooConvCoefVar through separate set proxy
       with parameters that do have state propagation

     - In getAnalyticalIntegral() ask for integration coefficient specific
       to coefficient (following interface change in RooAbsAnaConv)


   o RooEfficiency

     - Follow interface change in RooCategoryProxy


   o RooAbsAnaConvPdf

    - Use new RooObjCacheManager to hold normalization and coefficient representations

    - Extend getCoefAnalyticalIntegral() interface so that each coefficient
      can have a separate integration configuration

    - Modify makeCoefVars() such that it constructs the RooConvCoefVars with
      actual dependents for each coefficients, rather than inserting dependencies
      of any of the coefficients in each coefficient. This logic requires support
      from the implementation class that is interface through a new member function
      coefVars()


   o RooAbsReal 

    - Add Boolean data member treeVar that indicates is value buffer is also
      branch buffer of a tree. This information is already present in the RooAbsReal
      but is relatively expensive to retrieve and is always needed in the inner
      loop of data set operations. This extra member significantly speeds up operations

    - Remove superfluous _norm[] token in name returned by integralNameSuffix() if 
      no normalization set is supplied.

    - Add a fillDataHist() method that fills a given RooDataHist with a sampling
      of the given function. Added for support of caching p.d.f.s


    - Downgrading warning on non-dependent projection variables in plotOn() to
      a debug level message

    - Remove function optimizeDirty(),doConstOpt(),undoConstOpt(),findCacheableBranches()
      findUnusedDatasetVariables() and findRedundantCacheServers() as part of reorganization
      of optimization functionality.


   o RooAbsCollection

    - Use iterator semantics instead of vector semantics to process RooLinkedList
      contents in assignment operator

    - Add utility function contentsString() returning stl string with names
      of contents


   o RooAddPdf

    - Rewrite cache management using new RooObjCacheManager that holds projection
      integrals, range integrals and supplemental normalization lists


   o RooAbsOptGoodnessOfFit

    - Improve handling of normalization ranges and reference ranges for test statistics
      containing RooAddPdfs. New named argument in fitTo() and RooNllVar::ctor() pass
      reference range for fractions in RooAddPdf components that do not have an explicit
      fixed definition already. Name all normalization ranges explicitly after the
      subrange to which the're applied to avoid name clashes and conflicts if multiple
      normalization ranges are involved.

    - Rewrite informational messages through RooMsgService

    - Implement new constOptimizeTestStatistic() function that signals all test statistic
      components of a RooAbsArg expression tree to perform their constant term optimization

    - Implement new optimizeCaching() driver function that changes default lazy-evaluation-with-caching
      scheme to test statistic scheme where only parameters objects propagate state changes and
      where all components that depend directly or indirectly on observables have lazy evaluation
      disabled. Changes to p.d.f objects are delegated to RooAbsPdf::optimizeCacheMode(). Changes
      to dataset are delegated to RooAbsData::optimizeReadingWithCaching()

    - Implement new optimizeConstantTerms() function that is back end for constOptimizeTestStatistic
      implementation. 


  o RooAICRegistry, RooNormSetCache

    - Remove tracking of allocation cycles of RooArgSets as this scheme is superseded by
      memory pool mechanism for RooArgSet allocation


  o RooMappedCategory

    - Follow interface change in RooCategoryProxy.


  o RooRealMPFE

    - Follow reorganization of optimization functionality: implement new constOptimizeTestStatistic
      function for forwarding to slave processes.


  o RooRealVar

    - Add new setVal() function with range name to facilite setting of values that are outside
      default range, but inside specified alternate range. Needed for numeric integration and
      certain RooAddPdf coefficient projection.


  o RooAbsArg

    - Make state management functions public [is/set][Value/ShapeDirty](), setOperMode90
  
    - Add static _flipAClean boolean to support setACleanAdirty() static method.

    - Implement mechanism for registration of cache objects with base class RooAbsCache.
      Forward all calls to operModeHook(), redirectServersHook(), optimizeCacheMode()
      and printCompactTreeHook() to all caches for further processing
   
    - Define constOptimize() function and provide default implementation that forwards
      to all servers 

    - Implement optimizeCacheMode() function that puts expression tree in optimized
      caching for test-statistics operations (only cache/lazy evaluate nodes that
      do not (indirectly) depend on observables

    - Implement findConstantNodes() function that identifies all nodes that depend
      exclusively on constant observables and >0 observables that are eligible
      for precalculation and caching in test statistics operations by 
      RooAbsOptTestStatistic::optimizeConstantTerms()

    - Define constOptimizeTestStatistics that signal an expression tree that any
      embedded test statistic objects should perform their constant term optimization.
      Default implementation in RooAbsArg forwards call to all servers.


  o RooAbsPdf

    - Use new RooObjCacheManager to manage normalization integrals cache.

    - Process new SumCoefRange() option in fitTo() that sets the coeffient
      interpretation range for all embedded RooAddPdf objects of which
      the interpretation range was not explicitly set

    - Extend interface of fixAddCoefNormalizationSet(): add extra argument
      that controls if AddCoef normalization set are forcibly overruled
      for objects that already have an explicit range setting.

  
   o RooRealIntegral 

    - Add some informational messaging through RooMsgService, rewrite existing ones

    - Speed up numeric summations by precreating the involved RooSuperCategory
      in the ctor rather than in evaluate().

    - Fix bug in dependency insertion: explicitly require servers to be value
      server to avoid pulling in fake dependents.
    
    - Remove obsolete data members

    - Implement new setACleanADirty() function that atomically flips state of
      all AClean objects to ADirty for the duration of the integration step.
      Replaces the much more expensive prepareACleanFunc() that did this
      only for the objects involved.

    - Process factorizing terms in integral only if the list is not empty

    - Process Jacobian terms in integral only if the list is not empty


  o RooAddGenContext

   - Adapt to cache management chanches in RooAddPdf


  o RooNumIntFactory

   - Use STL classes for internal memory management


  o RooSetProxyy

   - Implement operator new() and operator() delete as required because
     RooArgSet implements them 


  o RooAbsGoodnessOfFit

   - Store and forward AddCoefRange information for embedded RooAddPdf objects

   - Implement constOptimizeTestStatistic() and forward to components


  o RooErrorVar

   - Follow inRange() interface change in RooAbsRealLValue


  o RooConvGenContext

    - Adapt code to make it work with both RooAbsAnaConv objects and
      the newly introduced RooFFTConvPdf


  o RooMinuit

    - Follow reorganization of optimization functionality


  o RooProjectedPdf

    - Store projection using new RooObjCacheManager


  o RooGlobalFunc

    - Add RooFit::SumCoefRange() named argument for RooAbsPdf::fitTo() 
      and RooNLLVar::ctor() and RooChi2Var::ctor()


  o RooClassFactory

    - Extend existing makePdf(),makeFunction and makeClass() functions
      to also accept RooAbsCategory arguments, to accept an optional string
      inserted as the return value expression inserted in the 
      evaluate() method of the class created, as well as as option string
      specifying one or more analytical integrations of the given function
      expression that will be advertised in the generated getAnalyticalIntegral()
      code and implemented in the generated analyticalIntegral() code

    - Add makeAndCompileFunction() and makeAndCompilePdf methods that
      generate the code and immediate compile it through ROOTs ACliC interface.
      These functions have a simpler interface because the list of arguments
      of the function to be created can be specified as a const RooArgSet&
      rather than a string with a list of names, thus making it easier
      for on-the-fly definition of compiled objects.

    - Add defineFunction() and definePdf() methods define and compile
      a function/pdf using the above functions and immediately instantiate
      an object of the given type passing the specified RooArgSet arguments
      to the constructor of the object. These functions make a compiled
      equivalent of RooFormulaVar based on the TFormula interpreter, i.e.

           RooAbsReal* f = new RooFormulaVar("f","D(1-2w)",RooArgSet(D,w)) ;

      becomes
       
           RooAbsReal* f = RooClassFactory::defineFunction("f","D(1-2w)",RooArgSet(D,w)) ;

   
  o RooAbsCategory

   - Add Boolean data member treeVar that indicates is value buffer is also
     branch buffer of a tree. This information is already present in the RooAbsReal
     but is relatively expensive to retrieve and is always needed in the inner
     loop of data set operations. This extra member significantly speeds up operations

   - Construct explit clean name for TBranch name if node is cached, equivalent
     to what is done in RooAbsReal. Needed because new constOptimizer can also
     cache RooAbsCategory objects


  o RooArgSet

   - Implement operator new() and operator delete() to implement memory pool scheme
     for RooArgSets. The goal of this implementation is to insure that two RooArgSet
     pointers are _never_ the same. This allows to RooNormSet cache manager to safely
     and quickly index integration and normalization configurations by evaluating
     the contents of a RooArgSet only the first time it sees it.


  o RooSimultaneous

   - Implement caching of partial integrals using new RooObjCacheManager

   - Following interface change in RooCategoryProxy ;


  o RooAbsData

   - Defined pure virtual methods optimizeReadingWithCache() and allClientsCached()


  o RooTreeData

   - Implement optimizeReadingWithCache() which determines given a p.d.f to be
     evaluated and a list of the nodes that are cached for it, which observables
     in the dataset are no longer required because they are either not an observable
     of the p.d.f, or they exclusively feed nodes that are cached. Reading of these
     observables is disabled through SetBranchStatus().
  
   - Move allClientsCached() utility function here from RooAbsReal.


  o RooCategoryProxy

   - Remove const char*() conversion operator in favor of a const char* label() method
     to remove possibly ambiguities in C++ math expressions involving category proxies.


  o LinkDef3.h

   - Add newly defined classes

Revision 12082 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Mon Jun 20 15:45:21 2005 UTC (9 years, 7 months ago) by wverkerke
Original Path: trunk/roofitcore/inc/RooComplex.h
File length: 3813 byte(s)
Diff to previous 11181

   o RooBanner

     - Update version number and copyright


   o Many files

     - Change <iostream> to "Riostream" to support compilation on platforms
       that do not have iostream classes in namespace std


   o RooAbsAnaConvPdf

     - Fix bug in range integration in getAnalyticalIntegralWN()

     - Change getCoefAnalyticalIntegral() signature to include rangeName in argument list


   o RooAbsArg

     - Add methods getObservables()/getParameters with const RooAbsData& argument


   o RooAbsPdf

     - Add support for Range(Double_t, Double_t) to specify fit range in fitTo()

     - Migrate getMaxVal()/maxVal() to RooAbsReal [Gerhard]

     - Fix bug in normalization of PDF projections over limited range: account for both
       fraction of data in range and fraction of projection in range (calculation of latter
       deferred to RooAbsReal::plotOn)


   o RooAbsReal

     - Migrate getMaxVal()/maxVal() from RooAbsReal [Gerhard]

     - Add code in plotOn() to support normalization of PDF projections plotted in limited range


   o RooAbsRealLValue, RooRealVar, RooErrorVar, RooLinearVar

     - Change getBinning() so that it only creates a new binning on the fly if a newly added boolean argument
       is true. Otherwise, return default binning


   o RooAdaptiveGaussKronrodIntegrator1D, RooGaussKronrodIntegrator1D

     - Declare prototypes for glue functions


   o RooArgSet

     - Fix readFromStream() and writeToStream() so that they are consistent with each other again for
       both regular and scientific notation mode.

     - Fix processing of include directives inside files in readFromFile()

     - Suppress warning messages about ignored lines in files unless verbose flag is set. Add verbosity control
       flag to readFromFile().


   o RooCategory

     - Support concept of ranges for categories as well through new member functions setRange(),addToRange(),
       clearRange(),hasRange(),isInRange() and isStateInRange(). Ranges are named TLists containing a non-owned
       subset of the possible RooCatTypes.


   o RooCategoryProxy

     - Make lvptr() const since it is.


   o RooConvCoefVar

     - Pass rangeName in getAnalyticalIntegral() to getCoefAnalyticalIntegral()


   o RooPlotable, RooCurve, RooHist, RooEllipse

     - Implement getFitRangeNEvt(Double_t, Double_t) that returns the number of events in the given sub-range.


   o RooDataHist

     - Fix bug using RooAbsData::plotOn --> using RooTreeData::plotOn


   o RooGlobalFunc

     - Add adjustNorm boolean argument to named argumentss Range()


   o RooMultiCatIter

     - Require that input is RooAbsCategoryLValue rather than RooAbsCategory.


   o RooPlot

     - Keep track of object that generated normalization event count in addition to event count itself.
       This allows to later on calculate an event count in a limited range through getFitRangeNEvt(Double_t, Double_t)


   o RooRealIntegral

     - Support ranges in category summation in integration code.


   o RooSimPdfBuilder

     - Fix bug in unitarity constraint split of parameter in partial build: adjust formula for remainder fraction
       so that it only uses the states that are actually built.

     - Improve error handling


   o RooSuperCategory

     -  Implement hasRange() and isInRange() functionality inherited from RooAbsRealLValue


   o RooClassFactory

     - New class that automatically generates code for PDFs and functions given a name and a list of argument names


   o RooEffProd

     - New class that implement product of PDF and efficiency function. Main feature is efficient implementation
       of event generator in case input PDF has 'smart' event generator

   o RooEffGenContext

     - Generator context associated with RooEffProd


   o Module.mk

     - ROOT make file module needed to compile RooFit as part of ROOT


   o make_roofit_installkit

     - Script to package RooFit source as ROOT module for compilation with ROOT system

Revision 2612 - (view) (download) (as text) (annotate) - [select for diffs]
Modified Tue Jul 31 05:54:23 2001 UTC (13 years, 5 months ago) by verkerke
Original Path: trunk/roofitcore/inc/RooComplex.h
File length: 2901 byte(s)
Diff to previous 2487

  o All RooAbsArg derived classes

    - Change clone() to clone(const char* newname=0) to facilitate cloning with alternate names.

  o RooAbsArg

    - Add another layer to link management: operMode. If operMode=auto, all behaves
      as before. If operMode=AClean, the arg assumes the cache is always clean and
      getValueDirty() will always return false. If operMode=ADirty, the arg assumes
      the cache is always dirty and isValueDirty will always return true.

      The ADirty and AClean modes are used by the optimizer in the fit context
      to shut down link management (and save time) for cases where the arg is
      always dirty after a dirty state propagation from one of the dependents.
      The AClean mode is used similarly for args that are cached in the dataset

      The setOperMode() member is protected as care should be taken in switching modes.
      It is the callers responsability to ensure that the claimed state (especially
      in case of AClean) is indeed correct.

    - Split setValueDirty(Bool_t flag) in setValueDirty() and clearValueDirty().
      The latter is trivial and can be inlined to save time.

    - redirectServers() now has an optional nameChange flag that allows to reconnect
      to servers with different names. If the option is enabled, a link will be reconnected
      to the server with a 'ORIGNAME:<servername>' attribute instead of a server with <servername>
      This feature is used by RooPdfCustomizer.

    - Added recursive printDirty() member that listed dirty state of arg and all its servers.

    - Add sorting capability by implementing IsSortable() and CompareTo() members.
      Sorting will result in alphabetical ordering by object name.

 o RooAbsCategory

    - Change tree attachement: store both label and index fields in tree instead of
      just the index field. Looking up the corresponding label turns out to be rather
      expensive, especially if many state are defined.

    - The postTreeLoadHook() mechanism that formerly implemented the index lookup
      has been abandoned completely (save 1 virtual function call per data set load).

 o RooAbsPdf

    - Change function call structure of eval tracing a bit to reduce the number
      of calls per trace from virtual calls to 1 concrete call.

    - In syncNormalization, if the data sets are different, first check if they
      also have a different contents before processing the change. (Save multiple
      identical normalization calculations for cases were a resolution model is
      shared by >1 RooConvolutedPdf. (WVE Caveat: this has some problems: code will
      die if cached data set is deleted before pdf. Will fix this soon)

      Install pre- and postSyncNormalizationHook functions that can be used to customize
      the call. Used by RooConvolutedPdf to create/update dummy data sets used to
      push down partial integrations to the convolution integrals.

    - Move nLogLikelihood to RooFitContext

 o RooAbsReal

    - in attachToTree(), mangle name of object in tree to exclude math symbols that
      are interpreted by root in certain circumstances

 o RooAddModel

    - Store coef and proxy iterators in class instead of creating them on the fly each
      time in evaluate()

    - Release ownership of proxied resolution models in the copy constructor. If the
      AddModel is copied, the proxied components will be owned by the list created
      by RooArgSet::snapshot().

    - Include name of AddModel owner in component resolution model to avoid multiple
      identically named object in certain PDF configurations

    - Export 'master list' of combined normalization leaf node servers of all components.
      The convolutedPdf needs this for it's own dependency calculation

 o RooArgSet

    - Add silent option to remove()

 o RooCatType

    - Store name in char[] instead of in TNamed::fName (a TString) so that
      the name can be attached to a Tree. (A TString is not a TObject)

 o RooConvolutedPdf

    - Push integration of all dependents that do not overlap with the coefficients
      to the convolution integrals, instead of just the convolution variable

 o RooDataSet

    - Add new constructor that allows to specify the cut as a RooFormulaVar object
      instead of a string. This allows to cut on function arguments that are not
      part of the data set

    - Allow to switch off dirty state propagation after a row-load operation
      (can be used in certain optimization scenarios)

 o RooFitContext

    - Add option to not clone either dataset or pdf on construction

    - Remove non-RooRealVar parameters from master parameter list to prevent that
      MINUIT chokes on them

    - Sort minuit parameter list alphabetically

    - Add cache optimization option, which shuts down all link management for the
      all pdf value components (not normalization). This can save a significant amount
      of time, especially for very complex PDFs as the number dirty propagations scales
      with the square of the number of nodes. Use newly introduces AClean and ADirty
      modes to ensure proper evaluation of PDF nodes

    - Add option to execute migrad with 'strategy 0', which skips the evaluation of
      the error matrix. (Saves time if you do that later with HESSE anyway)

    - Move nLoglikelihood() function from RooAbsPdf to here.

    - Improve readability of messages in fitting in log-mode: print on screen only value
      and name of parameters that change instead of dumping all their values all the time.
      The old format has been retained in the log file, to allow automated processing of such files.

 o RooFormulaVar

    - Also update _origList on a serverRedirect

    - Export ok() function of RooFormula (indicates if expression compiled ok)

 o RooMath

   - Add fast, interpolated, complex error function. Upon first use separate lookup tables
     are filled for the im and re part of the complex error function. New functions will
     do a 2nd or 3rd order 2D interpolation (depending on z) of the lookup table for either
     the re part, the im part or both. Precision is better that 1e-6 in ~99% of covered
     phase space. Imprecise regions are in problematic part of cErf where giant fluctuations
     occur. Typical likelihood calculated with interpolated cErf agrees in the first 10
     significant digits. Interpolation function is ~3.5 times faster than original CWERF
     implementation, when only 1 component (im/re) of cErf is needed (most cases).

     Interpolation function taken from Numerical Recipes and further optimized for
     fixed grid assumption

 o RooMappedCategory

    - Clone also MapCatEntries in RooMappedCategory copy ctor

 o RooProdPdf

    - Store coef and proxy iterators in class, instead of instantiating them on the fly
      in evaluate()

    - Add optional cutoff parameter. If running PDF product goes below cutoff, product
      calculation is terminated (default value=0, very small values like 1e-15 can be
      benificial in case of wide window calculations a Gaussian + something flattish)

 o RooRealIntegral

    - Allow and perform integration over variables that input function doesn't depend
      on (multiply integral by product of ranges of such variables)

 o RooResolutionModel

    - In convolution(): append name of owner to convolution, to avoid non-identical
      convolutions with the same name in certain PDF configurations

    - Forward redirectServers to basis function

 o RooSimultaneous

    - Overload fitTo() to create a RooSimFitContext instead of a RooFitContext
      which allows certain additional optimizations specific to RooSimultaneous

    - Normalize by the number of registered PDFs instead of the number of types
      defined by the index category (allows to to partial fits)

 o RooStreamParser

    - Take '}' and ';' out of the default punctuation list so that RooSuperCategory
      state names do not get broken up into multiple tokens

 o RooThresholdCategory

    - New category class that applies a series of thresholds on a RooRealVar to
      define its state.

 o RooThreshEntry

    - Support class for RooThresholdCategory

 o RooPdfCustomizer

    - Utility class that serves a factory to build multiple PDFs from a single prototype
      that have slightly different leaf nodes.

      The class takes a proto type and a master index category in the constructor.
      A series of splitting rules determines how given leaf nodes are to be 'split'
      over the master index category or a subset of the master index (in case the master
      index is a RooSuperCategory)

      The instiated 'split' leaf nodes are put in an argset referenced in the constructor.
      and the owner of the argset is responsible for deleting them (or passing them on
      to another RooPdfCustomizer). The instantiated branch nodes are owned by the customizer.

 o RooSimFitContext

    - Specialized fit context, derived from RooFitContext, that optimizes the likelihood
      calculation in case the top level pdf is a RooSimultaneous. The original data
      set is broken into pieces, corresponding to a single state of the RooSimultaneous
      index category and those data subsets are combined with the corresponding PDF branches
      of the RooSimultaneous to form an array of regular RooFitContexts. The total likelihood
      is calculated as the sum of the likelihoods from the array of fit contexts.

      The NLL output from each subcontext is cached and only recalculated if a parameter
      that the PDF of that subcontexts depends on, is changed.

      This form of calculation is very efficient for fits where the correlation matrix has
      a block diagonal form. The CPU time in RooSimFitContext scales (approximately) with
      the number of elements in the block diagonal elements instead of with the total number
      of elements.

 o Nearly all classes

    - A large number of minor bugs has been fixed and many functions
     that are called very frequently have been inlined, made non-virtual or
     have been eliminated, following the result of repeated profiler studies.

This form allows you to request diffs between any two revisions of this file. For each of the two "sides" of the diff, enter a numeric revision.

Links to HEAD:	(view) (download) (as text) (annotate)
Sticky Revision: