class RooAbsOptTestStatistic: public RooAbsTestStatistic

 Constructor taking function (real), a dataset (data), a set of projected observables (projSet). If
 rangeName is not null, only events in the dataset inside the range will be used in the test
 statistic calculation. If addCoefRangeName is not null, all RooAddPdf component of 'real' will be
 instructed to fix their fraction definitions to the given named range. If nCPU is greater than
 1 the test statistic calculation will be paralellized over multiple processes. By default the data
 is split with 'bulk' partitioning (each process calculates a contigious block of fraction 1/nCPU
 of the data). For binned data this approach may be suboptimal as the number of bins with >0 entries
 in each processing block many vary greatly thereby distributing the workload rather unevenly.
 If interleave is set to true, the interleave partitioning strategy is used where each partition
 i takes all bins for which (ibin % ncpu == i) which is more likely to result in an even workload.
 If splitCutRange is true, a different rangeName constructed as rangeName_{catName} will be used
 as range definition for each index state of a RooSimultaneous

 Copy constructor

 Destructor

 Method to combined test statistic results calculated into partitions into
 the global result. This default implementation adds the partition return
 values

 Catch server redirect calls and forward to internal clone of function

 Catch print hook function and forward to function clone

 Driver function to propagate constant term optimizations in test statistic.
 If code Activate is sent, constant term optimization will be executed.
 If code Deacivate is sent, any existing constant term optimizations will
 be abanoned. If codes ConfigChange or ValueChange are sent, any existing
 constant term optimizations will be redone.

 This method changes the value caching logic for all nodes that depends on any of the observables
 as defined by the given dataset. When evaluating a test statistic constructed from the RooAbsReal
 with a dataset the observables are guaranteed to change with every call, thus there is no point
 in tracking these changes which result in a net overhead. Thus for observable-dependent nodes,
 the evaluation mechanism is changed from being dependent on a 'valueDirty' flag to guaranteed evaluation.
 On the dataset side, the observables objects are modified to no longer send valueDirty messages
 to their client

 Driver function to activate global constant term optimization.
 If activated constant terms are found and cached with the dataset
 The operation mode of cached nodes is set to AClean meaning that
 their getVal() call will never result in an evaluate call.
 Finally the branches in the dataset that correspond to observables
 that are exclusively used in constant terms are disabled as
 they serve no more purpose

   cout << "RAOTS::setDataSlave(" << this << ") START" << endl ;
 Change dataset that is used to given one. If cloneData is kTRUE, a clone of
 in the input dataset is made.  If the test statistic was constructed with
 a range specification on the data, the cloneData argument is ignore and
 the data is always cloned.

 Constructors, assignment etc

 Override this to be always true to force calculation of likelihood without parameters