Log of /trunk/roofit/roofitcore/inc/RooSharedProperties.h
Parent Directory
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/RooSharedProperties.h
File length: 1711 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
17098 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Modified
Thu Dec 7 21:21:33 2006 UTC (8 years, 1 month ago) by
wverkerke
Original Path:
trunk/roofitcore/inc/RooSharedProperties.h
File length: 1714 byte(s)
Diff to
previous 13432
o RooRealVar
- Do not instantiate shared properties until the're actually needed
- Add method to delete shared properties (used in RooFitResult)
- Add static null property to be written for RRVs without properties
o RooRealVarSharedProperties,RooSharedProperties
- Add ctor with uuid string
o RooFitResult
- Remove all shared properties of RRVs inside object to facilitate
easy handling of large number of RFRs (e.g. in trees). Not doing
so leaves them all connected through the shared properties list
and will slow down operations
Revision
13432 -
(
view)
(
download)
(
as text)
(
annotate)
-
[select for diffs]
Added
Thu Dec 1 16:10:20 2005 UTC (9 years, 1 month ago) by
wverkerke
Original Path:
trunk/roofitcore/inc/RooSharedProperties.h
File length: 1603 byte(s)
o RooAbsAnaConvPdf
- Throw away cache of convCoef objects in serverRedirect (solves generator
problem reported by Gerhard)
- Follow interface change of getNormObj()
o RooAbsArg
- Add option pattern string argument to printCompactTree() that causes only
the components with names that match the pattern to be printed
- Add getCloningAncestors() utility function that returns list of pointers
to ancestors in the objects cloning history
o RooAbsGenContext
- Add auxiliary prototype variables to the _theEvent (solves generator problem
reported by Gerhard)
o RooAbsPdf
- Change getNormObj() to take both nset and iset argument so that it can
also cache fractional integrals. This is needed to support the use of
RooAddPdf objects in RooExtendPdf as fractional range intergrals of
RooAddPdfs cannot be represented as a ratio of two integrals in
a the restricted and full range divided by each other
o RooAbsReal
- Change const declaration in one of the createIntegral() declarations
o RooAddGenContext
- Follow interface change in RooAddPdf::updateCoefCache()
o RooAddPdf
- Pass both supplemental and regular normalization set to updateCoefCache() to
be able to deal with situations arising from using RooExtendPdf where the
former is a null pointer.
o RooConvGenContext
- Add auxiliary prototype variables in constructor to list of variables of model
and pdf.
- In initGenerator() resync observable lists _pdfVars and _modelVars to those
in the event that is passed to initGenerator(). Fixes generator problem reported
by Gerhard.
o RooExtendPdf
- Change way fractional integral factor is calculated in expectedEvents(): use
1-step createIntegral() procedure available through new getNormObj() interface.
This fixes a problem calculating the number of expected events in a range
of a RooAddPdf.
o RooGenContext
- Use createIntegral() interface to construct AcceptReject input function rather
than direct call of RooRealIntegral constructor.
o RooProdGenContext
- Small fix in handling of imported dependents in product parsing phase of generator context
o RooProdPdf
- Add forgotten handling of extended PDF term in selected constructors
o RooProduct
- Extend functionality so that product input terms can include RooAbsCategories as well
o RooRealVar
- Introduce concept of 'shared properties' among clones of RooRealVars. This simplifies
user handling of certain RooRealVar properties that are synchronous among all clones
of a RooRealVar. A simple demonstration:
RooRealVar x("x","x",-10,10) ;
RooRealVar* x2 = x->Clone() ;
x.setRange("signal",-1,1) ;
x2->getMin("signal") // returns -1 ;
x2->setMax("signal",5) ;
x.getmax("signal") // returns 5 ;
The sharing is explicitly through cloning and not by name, so two independently
created objects with identical names will not share properties. The sharing
of properties is retained throughout persistence and unpersistence of objects.
For now the definition of the named ranges has been moved into the
shared properties part of RooRealVar and simplifies certain common uses cases such as
RooRealVar x("x","x",-10,10) ;
RooRealVar y("y","y",-10,10) ;
// lots of code
RooAbsPdf* F ; // constructed somewhere
// more code
RooDataSet* D ; // constructed somewhere
y.setRange("signal",-1,1) ;
RooPlot* xframe = x.frame() ;
D->plotOn(xframe,CutRange("signal")) ; // RRV 'y' inside 'D' knows about "signal" through sharing
F->plotOn(xframe,ProjectionRange("signal")) ;
- Increment of RooRealVar schema version number from 2 to 4
- Explicit streamer of RooRealVar has been extended to be able to stream RooRealVar v3 objects
properly and automatically eliminate/reconnect multiple instances of identical shared property
objects that may have been created in ROOT persistence. The streamer is also capable of
reading in v1 and v2 RooRealVars for backward compatibility
o RooSimultaneous
- Modify behaviour of expectedEvents(): if index category is included in normalization set,
return sum of expectedEvents() of all components, otherwise return value of expectedEvents()
of currently selected p.d.f. (the 'old' behavior)
o RooSharedProperties
- Base class for implementation of shared property objects such as RooRealVarSharedProperty
used in RooRealVar. This class embeds a UUID that allows reconnection of multiple RooAbsArgs
to a single instance of a shared property in the unpersistance phase.
o RooSharedProperiesList
- Container class for RooSharedProperties objects that serves as repository for shared properties.
Concrete implementations of RooAbsArg that implement the shared properties concept, such as
RooRealVar, have a an instance of RooSharedPropertiesList as a static data member. This container
class owns all shared properties objects and performs their memory management through reference
counting and automatically eliminates duplicate copies of unique shared properties that many
occur on unpersisting objects
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.
