include/root/RooAbsData.h

0001 /*****************************************************************************
0002  * Project: RooFit                                                           *
0003  * Package: RooFitCore                                                       *
0004  *    File: $Id: RooAbsData.h,v 1.33 2007/07/16 21:04:28 wouter Exp $
0005  * Authors:                                                                  *
0006  *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
0007  *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
0008  *                                                                           *
0009  * Copyright (c) 2000-2005, Regents of the University of California          *
0010  *                          and Stanford University. All rights reserved.    *
0011  *                                                                           *
0012  * Redistribution and use in source and binary forms,                        *
0013  * with or without modification, are permitted according to the terms        *
0014  * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
0015  *****************************************************************************/
0016 #ifndef ROO_ABS_DATA
0017 #define ROO_ABS_DATA
0018
0019 #include "RooPrintable.h"
0020 #include "RooAbsCategory.h"
0021 #include "RooArgSet.h"
0022 #include "RooArgList.h"
0023 #include "RooNameReg.h"
0024 #include "RooFit/UniqueId.h"
0025 #include "RooFit/EvalContext.h"
0026
0027 #include <ROOT/RSpan.hxx>
0028
0029 #include <TMatrixDSym.h>
0030 #include <TNamed.h>
0031
0032 #include <map>
0033 #include <string>
0034
0035 class RooAbsReal ;
0036 class RooRealVar;
0037 class RooAbsRealLValue;
0038 class RooAbsCategoryLValue;
0039 class Roo1DTable ;
0040 class RooPlot;
0041 class RooArgList;
0042 class RooSimultaneous;
0043 class TH1;
0044 class TH2F;
0045 class RooAbsBinning ;
0046 class Roo1DTable ;
0047 class RooAbsDataStore ;
0048 class RooFormulaVar;
0049 namespace RooFit {
0050 namespace TestStatistics {
0051 class RooAbsL;
0052 struct ConstantTermsOptimizer;
0053 }
0054 }
0055
0056
0057 class RooAbsData : public TNamed, public RooPrintable {
0058 public:
0059
0060   // Constructors, factory methods etc.
0061   RooAbsData() ;
0062   RooAbsData(RooStringView name, RooStringView title, const RooArgSet& vars, RooAbsDataStore* store=nullptr) ;
0063   RooAbsData(const RooAbsData& other, const char* newname = nullptr) ;
0064
0065   RooAbsData& operator=(const RooAbsData& other);
0066   ~RooAbsData() override ;
0067   virtual RooFit::OwningPtr<RooAbsData> emptyClone(const char* newName=nullptr, const char* newTitle=nullptr, const RooArgSet* vars=nullptr, const char* wgtVarName=nullptr) const = 0 ;
0068
0069   // Reduction methods
0070   RooFit::OwningPtr<RooAbsData> reduce(const RooCmdArg& arg1,const RooCmdArg& arg2={},const RooCmdArg& arg3={},const RooCmdArg& arg4={},
0071                      const RooCmdArg& arg5={},const RooCmdArg& arg6={},const RooCmdArg& arg7={},const RooCmdArg& arg8={}) const;
0072   RooFit::OwningPtr<RooAbsData> reduce(const char* cut) const;
0073   RooFit::OwningPtr<RooAbsData> reduce(const RooFormulaVar& cutVar) const;
0074   RooFit::OwningPtr<RooAbsData> reduce(const RooArgSet& varSubset, const char* cut=nullptr) const;
0075   RooFit::OwningPtr<RooAbsData> reduce(const RooArgSet& varSubset, const RooFormulaVar& cutVar) const;
0076
0077   RooAbsDataStore* store() { return _dstore.get(); }
0078   const RooAbsDataStore* store() const { return _dstore.get(); }
0079   const TTree* tree() const ;
0080   TTree *GetClonedTree() const;
0081
0082   void convertToVectorStore() ;
0083   virtual void convertToTreeStore();
0084
0085   void attachBuffers(const RooArgSet& extObs) ;
0086   void resetBuffers() ;
0087
0088
0089   void Draw(Option_t* option = "") override ;
0090
0091   void checkInit() const ;
0092
0093   // Change name of observable
0094   virtual bool changeObservableName(const char* from, const char* to) ;
0095
0096   // Add one ore more rows of data
0097   virtual void add(const RooArgSet& row, double weight=1) = 0 ; // DERIVED
0098   virtual void fill() ;
0099
0100   // Load a given row of data
0101   virtual inline const RooArgSet* get() const {
0102     // Return current row of dataset
0103     return &_vars ;
0104   }
0105   virtual double weight() const = 0 ; // DERIVED
0106   virtual double weightSquared() const = 0 ; // DERIVED
0107
0108   enum ErrorType { Poisson, SumW2, None, Auto, Expected } ;
0109   static ErrorType errorTypeFromString(std::string const &name);
0110
0111   /// Return the symmetric error on the current weight.
0112   /// See also weightError(double&,double&,ErrorType) const for asymmetric errors.
0113   // \param[in] etype Type of error to compute. May throw if not supported.
0114   virtual double weightError(ErrorType /*etype*/=Poisson) const {
0115     // Dummy implementation returning zero, because not all deriving classes
0116     // need to implement a non-zero weight error.
0117     return 0.0;
0118   }
0119   /// Return the asymmetric errors on the current weight.
0120   /// See also weightError(ErrorType) const for symmetric error.
0121   /// \param[out] lo Low error.
0122   /// \param[out] hi High error.
0123   // \param[in] etype Type of error to compute. May throw if not supported.
0124   virtual void weightError(double& lo, double& hi, ErrorType /*etype*/=Poisson) const {
0125     // Dummy implementation returning zero, because not all deriving classes
0126     // need to implement a non-zero weight error.
0127     lo=0;
0128     hi=0;
0129   }
0130
0131   virtual const RooArgSet* get(Int_t index) const ;
0132
0133   using RealSpans = std::map<RooFit::Detail::DataKey, std::span<const double>>;
0134   using CategorySpans = std::map<RooFit::Detail::DataKey, std::span<const RooAbsCategory::value_type>>;
0135
0136   RealSpans getBatches(std::size_t first = 0, std::size_t len = std::numeric_limits<std::size_t>::max()) const;
0137   CategorySpans getCategoryBatches(std::size_t first = 0, std::size_t len = std::numeric_limits<std::size_t>::max()) const;
0138
0139   ////////////////////////////////////////////////////////////////////////////////
0140   /// Return event weights of all events in range [first, first+len).
0141   /// If no contiguous structure of weights is stored, an empty batch can be returned.
0142   /// This indicates that the weight is constant. Use weight() to retrieve it.
0143   virtual std::span<const double> getWeightBatch(std::size_t first, std::size_t len, bool sumW2=false) const = 0;
0144
0145   /// Return number of entries in dataset, i.e., count unweighted entries.
0146   virtual Int_t numEntries() const ;
0147   /// Return effective number of entries in dataset, i.e., sum all weights.
0148   virtual double sumEntries() const = 0 ;
0149   /// Return effective number of entries in dataset inside range or after cuts, i.e., sum certain weights.
0150   /// \param[in] cutSpec Apply given cut when counting (e.g. `0 < x && x < 5`). Passing `"1"` selects all events.
0151   /// \param[in] cutRange If the observables have a range with this name, only count events inside this range.
0152   virtual double sumEntries(const char* cutSpec, const char* cutRange=nullptr) const = 0 ; // DERIVED
0153   double sumEntriesW2() const;
0154   virtual bool isWeighted() const {
0155     // Do events in dataset have weights?
0156     return false ;
0157   }
0158   virtual bool isNonPoissonWeighted() const {
0159     // Do events in dataset have non-integer weights?
0160     return false ;
0161   }
0162   virtual void reset() ;
0163
0164
0165   bool getRange(const RooAbsRealLValue& var, double& lowest, double& highest, double marginFrac=0.0, bool symMode=false) const ;
0166
0167   // Plot the distribution of a real valued arg
0168   virtual Roo1DTable* table(const RooArgSet& catSet, const char* cuts="", const char* opts="") const ;
0169   virtual Roo1DTable* table(const RooAbsCategory& cat, const char* cuts="", const char* opts="") const ;
0170   /// \see RooPlot* plotOn(RooPlot* frame, const RooLinkedList& cmdList) const
0171   virtual RooPlot* plotOn(RooPlot* frame,
0172            const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
0173            const RooCmdArg& arg3={}, const RooCmdArg& arg4={},
0174            const RooCmdArg& arg5={}, const RooCmdArg& arg6={},
0175            const RooCmdArg& arg7={}, const RooCmdArg& arg8={}) const ;
0176
0177   virtual RooPlot* plotOn(RooPlot* frame, const RooLinkedList& cmdList) const ;
0178
0179   // WVE --- This needs to be public to avoid CINT problems
0180   struct PlotOpt {
0181    const char* cuts = "";
0182    Option_t* drawOptions = "P";
0183    RooAbsBinning* bins = nullptr;
0184    RooAbsData::ErrorType etype = RooAbsData::Poisson;
0185    const char* cutRange = nullptr;
0186    const char* histName = nullptr;
0187    bool histInvisible = false;
0188    const char* addToHistName = nullptr;
0189    double addToWgtSelf = 1.0;
0190    double addToWgtOther = 1.0;
0191    double xErrorSize = 1.0;
0192    bool refreshFrameNorm = false;
0193    bool correctForBinWidth = true;
0194    double scaleFactor = 1.0;
0195   } ;
0196
0197   // Split a dataset by a category
0198   std::vector<std::unique_ptr<RooAbsData>> split(const RooAbsCategory& splitCat, bool createEmptyDataSets=false) const;
0199
0200   // Split a dataset by categories of a RooSimultaneous
0201   std::vector<std::unique_ptr<RooAbsData>> split(const RooSimultaneous& simpdf, bool createEmptyDataSets=false) const;
0202
0203   // Fast splitting for SimMaster setData
0204   bool canSplitFast() const ;
0205   RooAbsData* getSimData(const char* idxstate) ;
0206
0207   /// Calls createHistogram(const char *name, const RooAbsRealLValue& xvar, const RooLinkedList& argList) const
0208   TH1 *createHistogram(const char *name, const RooAbsRealLValue& xvar,
0209                        const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
0210                        const RooCmdArg& arg3={}, const RooCmdArg& arg4={},
0211                        const RooCmdArg& arg5={}, const RooCmdArg& arg6={},
0212                        const RooCmdArg& arg7={}, const RooCmdArg& arg8={}) const ;
0213   TH1 *createHistogram(const char* varNameList,
0214                        const RooCmdArg& binArgX={}, const RooCmdArg& binArgY={},
0215                        const RooCmdArg& binArgZ={}) const;
0216   /// Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this dataset.
0217   TH1 *createHistogram(const char *name, const RooAbsRealLValue& xvar, const RooLinkedList& argList) const ;
0218   TH2F* createHistogram(const RooAbsRealLValue& var1, const RooAbsRealLValue& var2, const char* cuts="",
0219          const char *name= "hist") const;
0220   TH2F* createHistogram(const RooAbsRealLValue& var1, const RooAbsRealLValue& var2, int nx, int ny,
0221                         const char* cuts="", const char *name="hist") const;
0222
0223   // Fill an existing histogram
0224   virtual TH1 *fillHistogram(TH1 *hist, const RooArgList &plotVars, const char *cuts= "", const char* cutRange=nullptr) const;
0225
0226   // Printing interface (human readable)
0227   inline void Print(Option_t *options= nullptr) const override {
0228     // Print contents on stdout
0229     printStream(defaultPrintStream(),defaultPrintContents(options),defaultPrintStyle(options));
0230   }
0231
0232   void printName(std::ostream& os) const override ;
0233   void printTitle(std::ostream& os) const override ;
0234   void printClassName(std::ostream& os) const override ;
0235   void printMultiline(std::ostream& os, Int_t contents, bool verbose=false, TString indent="") const override ;
0236
0237   Int_t defaultPrintContents(Option_t* opt) const override ;
0238
0239   /// Print the contents of the dataset to the specified output stream.
0240   virtual void printContents(std::ostream& os = std::cout) const = 0;
0241
0242   void setDirtyProp(bool flag) ;
0243
0244   double moment(const RooRealVar& var, double order, const char* cutSpec=nullptr, const char* cutRange=nullptr) const ;
0245   double moment(const RooRealVar& var, double order, double offset, const char* cutSpec=nullptr, const char* cutRange=nullptr) const ;
0246   double standMoment(const RooRealVar& var, double order, const char* cutSpec=nullptr, const char* cutRange=nullptr) const ;
0247
0248   double mean(const RooRealVar& var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return moment(var,1,0,cutSpec,cutRange) ; }
0249   double sigma(const RooRealVar& var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return sqrt(moment(var,2,cutSpec,cutRange)) ; }
0250   double skewness(const RooRealVar& var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return standMoment(var,3,cutSpec,cutRange) ; }
0251   double kurtosis(const RooRealVar& var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return standMoment(var,4,cutSpec,cutRange) ; }
0252
0253   double covariance(RooRealVar &x,RooRealVar &y, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return corrcov(x,y,cutSpec,cutRange,false) ; }
0254   double correlation(RooRealVar &x,RooRealVar &y, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return corrcov(x,y,cutSpec,cutRange,true) ; }
0255
0256   RooFit::OwningPtr<TMatrixDSym> covarianceMatrix(const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return covarianceMatrix(*get(),cutSpec,cutRange) ; }
0257   RooFit::OwningPtr<TMatrixDSym> correlationMatrix(const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return correlationMatrix(*get(),cutSpec,cutRange) ; }
0258   RooFit::OwningPtr<TMatrixDSym> covarianceMatrix(const RooArgList& vars, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return corrcovMatrix(vars,cutSpec,cutRange,false) ; }
0259   RooFit::OwningPtr<TMatrixDSym> correlationMatrix(const RooArgList& vars, const char* cutSpec=nullptr, const char* cutRange=nullptr) const { return corrcovMatrix(vars,cutSpec,cutRange,true) ; }
0260
0261   RooRealVar* meanVar(const RooRealVar &var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const ;
0262   RooRealVar* rmsVar(const RooRealVar &var, const char* cutSpec=nullptr, const char* cutRange=nullptr) const ;
0263
0264   virtual RooPlot* statOn(RooPlot* frame,
0265                           const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
0266                           const RooCmdArg& arg3={}, const RooCmdArg& arg4={},
0267                           const RooCmdArg& arg5={}, const RooCmdArg& arg6={},
0268                           const RooCmdArg& arg7={}, const RooCmdArg& arg8={}) ;
0269
0270   virtual RooPlot* statOn(RooPlot* frame, const char *what,
0271            const char *label= "", Int_t sigDigits= 2,
0272            Option_t *options= "NELU", double xmin=0.15,
0273            double xmax= 0.65,double ymax=0.85,
0274                           const char* cutSpec=nullptr, const char* cutRange=nullptr,
0275                           const RooCmdArg* formatCmd=nullptr);
0276
0277   void RecursiveRemove(TObject *obj) override;
0278
0279   bool hasFilledCache() const ;
0280
0281   void addOwnedComponent(const char* idxlabel, RooAbsData& data) ;
0282
0283   enum StorageType { Tree, Vector, Composite };
0284
0285   static void setDefaultStorageType(StorageType s) ;
0286
0287   static StorageType getDefaultStorageType();
0288
0289   /// Returns snapshot of global observables stored in this data.
0290   /// \return Pointer to a RooArgSet with the snapshot of global observables
0291   ///         stored in the data. Can be `nullptr` if no global observables are
0292   ///         stored.
0293   RooArgSet const* getGlobalObservables() const { return _globalObservables.get(); }
0294   void setGlobalObservables(RooArgSet const& globalObservables);
0295
0296   /// De-duplicated pointer to this object's name.
0297   /// This can be used for fast name comparisons.
0298   /// like `if (namePtr() == other.namePtr())`.
0299   /// \note TNamed::GetName() will return a pointer that's
0300   /// different for each object, but namePtr() always points
0301   /// to a unique instance.
0302   inline const TNamed* namePtr() const {
0303     return _namePtr ;
0304   }
0305
0306   void SetName(const char* name) override ;
0307   void SetNameTitle(const char *name, const char *title) override ;
0308
0309   /// Returns a unique ID that is different for every instantiated RooAbsData object.
0310   /// This ID can be used whether two RooAbsData are the same object, which is safer
0311   /// than memory address comparisons that might result in false positives when
0312   /// memory is reused.
0313   RooFit::UniqueId<RooAbsData> const& uniqueId() const { return _uniqueId; }
0314
0315 protected:
0316
0317   static StorageType defaultStorageType ;
0318
0319   StorageType storageType;
0320
0321   void initializeVars(RooArgSet const& vars);
0322
0323   double corrcov(const RooRealVar& x, const RooRealVar& y, const char* cutSpec, const char* cutRange, bool corr) const  ;
0324   RooFit::OwningPtr<TMatrixDSym> corrcovMatrix(const RooArgList& vars, const char* cutSpec, const char* cutRange, bool corr) const  ;
0325
0326   virtual void optimizeReadingWithCaching(RooAbsArg& arg, const RooArgSet& cacheList, const RooArgSet& keepObsList) ;
0327   bool allClientsCached(RooAbsArg*, const RooArgSet&) ;
0328
0329
0330  // PlotOn implementation
0331   virtual RooPlot *plotOn(RooPlot *frame, PlotOpt o) const ;
0332   virtual RooPlot *plotAsymOn(RooPlot* frame, const RooAbsCategoryLValue& asymCat, PlotOpt o) const ;
0333   virtual RooPlot *plotEffOn(RooPlot* frame, const RooAbsCategoryLValue& effCat, PlotOpt o) const ;
0334
0335
0336   // Constant term optimizer interface
0337   friend class RooAbsOptTestStatistic ;
0338   friend struct RooFit::TestStatistics::ConstantTermsOptimizer;
0339   // for access into copied dataset:
0340   friend class RooFit::TestStatistics::RooAbsL;
0341
0342   virtual void cacheArgs(const RooAbsArg* owner, RooArgSet& varSet, const RooArgSet* nset=nullptr, bool skipZeroWeights=false) ;
0343   virtual void resetCache() ;
0344   virtual void setArgStatus(const RooArgSet& set, bool active) ;
0345   virtual void attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) ;
0346
0347   virtual std::unique_ptr<RooAbsData> reduceEng(const RooArgSet& varSubset, const RooFormulaVar* cutVar, const char* cutRange=nullptr,
0348                            std::size_t nStart = 0, std::size_t = std::numeric_limits<std::size_t>::max()) const = 0 ;
0349
0350   RooRealVar* dataRealVar(const char* methodname, const RooRealVar& extVar) const ;
0351
0352   // Column structure definition
0353   RooArgSet _vars;         ///< Dimensions of this data set
0354   RooArgSet _cachedVars ;  ///<! External variables cached with this data set
0355
0356   std::unique_ptr<RooAbsDataStore> _dstore; ///< Data storage implementation
0357
0358   std::map<std::string,RooAbsData*> _ownedComponents ; ///< Owned external components
0359
0360   std::unique_ptr<RooArgSet> _globalObservables; ///< Snapshot of global observables
0361
0362   mutable const TNamed * _namePtr = nullptr; ///<! De-duplicated name pointer. This will be equal for all objects with the same name.
0363
0364 private:
0365   void copyImpl(const RooAbsData& other, const char* newname);
0366
0367   void copyGlobalObservables(const RooAbsData& other);
0368
0369   const RooFit::UniqueId<RooAbsData> _uniqueId; ///<!
0370
0371    ClassDefOverride(RooAbsData, 7) // Abstract data collection
0372 };
0373
0374 #endif