include/root/RooProdPdf.h

0001 /*****************************************************************************
0002  * Project: RooFit                                                           *
0003  * Package: RooFitCore                                                       *
0004  *    File: $Id: RooProdPdf.h,v 1.44 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_PROD_PDF
0017 #define ROO_PROD_PDF
0018
0019 #include "RooAbsPdf.h"
0020 #include "RooListProxy.h"
0021 #include "RooLinkedList.h"
0022 #include "RooAICRegistry.h"
0023 #include "RooObjCacheManager.h"
0024 #include "RooCmdArg.h"
0025
0026 #include <vector>
0027 #include <list>
0028 #include <string>
0029
0030 namespace RooFit {
0031 namespace Detail {
0032 class RooFixedProdPdf;
0033 }
0034 }
0035
0036 class RooProdPdf : public RooAbsPdf {
0037 public:
0038
0039   RooProdPdf() ;
0040   RooProdPdf(const char *name, const char *title,
0041        RooAbsPdf& pdf1, RooAbsPdf& pdf2, double cutOff=0.0) ;
0042   RooProdPdf(const char* name, const char* title, const RooArgList& pdfList, double cutOff=0.0) ;
0043   RooProdPdf(const char* name, const char* title, const RooArgSet& fullPdfSet, const RooLinkedList& cmdArgList) ;
0044
0045   RooProdPdf(const char* name, const char* title, const RooArgSet& fullPdfSet,
0046            const RooCmdArg& arg1            , const RooCmdArg& arg2={},
0047              const RooCmdArg& arg3={}, const RooCmdArg& arg4={},
0048              const RooCmdArg& arg5={}, const RooCmdArg& arg6={},
0049              const RooCmdArg& arg7={}, const RooCmdArg& arg8={}) ;
0050
0051   RooProdPdf(const char* name, const char* title,
0052              const RooCmdArg& arg1,             const RooCmdArg& arg2={},
0053              const RooCmdArg& arg3={}, const RooCmdArg& arg4={},
0054              const RooCmdArg& arg5={}, const RooCmdArg& arg6={},
0055              const RooCmdArg& arg7={}, const RooCmdArg& arg8={}) ;
0056
0057   RooProdPdf(const RooProdPdf& other, const char* name=nullptr) ;
0058   TObject* clone(const char* newname=nullptr) const override { return new RooProdPdf(*this,newname) ; }
0059   ~RooProdPdf() override ;
0060
0061   bool forceAnalyticalInt(const RooAbsArg& dep) const override ;
0062   Int_t getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& numVars, const RooArgSet* normSet, const char* rangeName=nullptr) const override ;
0063   double analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName=nullptr) const override ;
0064   bool selfNormalized() const override { return _selfNorm ; }
0065
0066   ExtendMode extendMode() const override ;
0067   double expectedEvents(const RooArgSet* nset) const override ;
0068   std::unique_ptr<RooAbsReal> createExpectedEventsFunc(const RooArgSet* nset) const override;
0069
0070   const RooArgList& pdfList() const { return _pdfList ; }
0071
0072   void addPdfs(RooAbsCollection const& pdfs);
0073   void removePdfs(RooAbsCollection const& pdfs);
0074
0075   Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, bool staticInitOK=true) const override;
0076   void initGenerator(Int_t code) override ;
0077   void generateEvent(Int_t code) override;
0078   bool isDirectGenSafe(const RooAbsArg& arg) const override ;
0079
0080   // Constraint management
0081   std::unique_ptr<RooArgSet> getConstraints(const RooArgSet &observables, RooArgSet const &constrainedParams,
0082                                             RooArgSet &pdfParams) const override;
0083
0084   std::list<double>* plotSamplingHint(RooAbsRealLValue& obs, double xlo, double xhi) const override ;
0085   std::list<double>* binBoundaries(RooAbsRealLValue& /*obs*/, double /*xlo*/, double /*xhi*/) const override ;
0086   bool isBinnedDistribution(const RooArgSet& obs) const override  ;
0087
0088   void printMetaArgs(std::ostream& os) const override ;
0089
0090   void selectNormalizationRange(const char* rangeName=nullptr, bool force=false) override ;
0091   void fixRefRange(const char* rangeName) ;
0092
0093   void setSelfNormalized(bool flag) { _selfNorm = flag ; }
0094   void setDefNormSet(const RooArgSet& nset) { _defNormSet.removeAll() ; _defNormSet.addClone(nset) ; }
0095
0096
0097   bool redirectServersHook(const RooAbsCollection& /*newServerList*/, bool /*mustReplaceAll*/, bool /*nameChange*/, bool /*isRecursive*/) override ;
0098
0099   RooArgSet* getConnectedParameters(const RooArgSet& observables) const ;
0100
0101   RooArgSet* findPdfNSet(RooAbsPdf const& pdf) const ;
0102
0103   std::unique_ptr<RooAbsArg> compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext & ctx) const override;
0104
0105   // The cache object. Internal, do not use.
0106   class CacheElem final : public RooAbsCacheElement {
0107   public:
0108     CacheElem() : _isRearranged(false) { }
0109     // Payload
0110     RooArgList _partList ;
0111     RooArgList _numList ;
0112     RooArgList _denList ;
0113     RooArgList _ownedList ;
0114     std::vector<std::unique_ptr<RooArgSet>> _normList;
0115     bool _isRearranged ;
0116     std::unique_ptr<RooAbsReal> _rearrangedNum{};
0117     std::unique_ptr<RooAbsReal> _rearrangedDen{};
0118     // Cache management functions
0119     RooArgList containedArgs(Action) override ;
0120     void printCompactTreeHook(std::ostream&, const char *, Int_t, Int_t) override ;
0121     void writeToStream(std::ostream& os) const ;
0122   } ;
0123
0124 private:
0125
0126   std::unique_ptr<RooArgSet> fillNormSetForServer(RooArgSet const& normSet, RooAbsArg const& server) const;
0127
0128   double evaluate() const override ;
0129
0130   std::unique_ptr<RooAbsReal> makeCondPdfRatioCorr(RooAbsReal& term, const RooArgSet& termNset, const RooArgSet& termImpSet, const char* normRange, const char* refRange) const ;
0131
0132   void initializeFromCmdArgList(const RooArgSet& fullPdfSet, const RooLinkedList& l) ;
0133
0134   struct Factorized {
0135      ~Factorized();
0136
0137      RooArgSet *termNormDeps(int i) const { return static_cast<RooArgSet*>(norms.At(i)); }
0138      RooArgSet *termIntDeps(int i) const { return static_cast<RooArgSet*>(ints.At(i)); }
0139      RooArgSet *termImpDeps(int i) const { return static_cast<RooArgSet*>(imps.At(i)); }
0140      RooArgSet *termCrossDeps(int i) const { return static_cast<RooArgSet*>(cross.At(i)); }
0141
0142      RooLinkedList terms;
0143      RooLinkedList norms;
0144      RooLinkedList imps;
0145      RooLinkedList ints;
0146      RooLinkedList cross;
0147   };
0148
0149   void factorizeProduct(const RooArgSet& normSet, const RooArgSet& intSet, Factorized &factorized) const;
0150   std::string makeRGPPName(const char* pfx, const RooArgSet& term, const RooArgSet& iset, const RooArgSet& nset, const char* isetRangeName) const ;
0151   void groupProductTerms(std::list<std::vector<RooArgSet*>>& groupedTerms, RooArgSet& outerIntDeps, Factorized const &factorized) const;
0152
0153
0154
0155   Int_t getPartIntList(const RooArgSet* nset, const RooArgSet* iset, const char* isetRangeName=nullptr) const ;
0156
0157   struct ProcessProductTermOutput {
0158     bool isOwned = false;
0159     RooAbsReal* x0 = nullptr;
0160     std::unique_ptr<RooAbsReal> x1;
0161     std::unique_ptr<RooAbsReal> x2;
0162   };
0163
0164   ProcessProductTermOutput processProductTerm(const RooArgSet* nset, const RooArgSet* iset, const char* isetRangeName,
0165                      const RooArgSet* term,const RooArgSet& termNSet, const RooArgSet& termISet,
0166                      bool forceWrap=false) const ;
0167
0168
0169   CacheMode canNodeBeCached() const override { return RooAbsArg::NotAdvised ; } ;
0170   void setCacheAndTrackHints(RooArgSet&) override ;
0171
0172   std::unique_ptr<CacheElem> createCacheElem(const RooArgSet* nset, const RooArgSet* iset, const char* isetRangeName=nullptr) const;
0173
0174   mutable RooObjCacheManager _cacheMgr ; //! The cache manager
0175
0176   CacheElem* getCacheElem(RooArgSet const* nset) const ;
0177   void rearrangeProduct(CacheElem&) const;
0178   std::unique_ptr<RooAbsReal> specializeIntegral(RooAbsReal& orig, const char* targetRangeName) const ;
0179   std::unique_ptr<RooAbsReal> specializeRatio(RooFormulaVar& input, const char* targetRangeName) const ;
0180   double calculate(const RooProdPdf::CacheElem &cache, bool verbose = false) const;
0181
0182   friend class RooProdGenContext ;
0183   friend class RooFit::Detail::RooFixedProdPdf ;
0184   RooAbsGenContext* genContext(const RooArgSet &vars, const RooDataSet *prototype=nullptr,
0185                                   const RooArgSet *auxProto=nullptr, bool verbose= false) const override ;
0186
0187
0188   mutable RooAICRegistry _genCode ; ///<! Registry of composite direct generator codes
0189
0190   double _cutOff = 0.0;       ///<  Cutoff parameter for running product
0191   RooListProxy _pdfList ;  ///<  List of PDF components
0192   std::vector<std::unique_ptr<RooArgSet>> _pdfNSetList ; ///< List of PDF component normalization sets
0193   Int_t _extendedIndex = -1; ///<  Index of extended PDF (if any)
0194
0195   void useDefaultGen(bool flag=true) { _useDefaultGen = flag ; }
0196   bool _useDefaultGen = false; ///< Use default or distributed event generator
0197
0198   mutable TNamed* _refRangeName = nullptr; ///< Reference range name for interpretation of conditional products
0199
0200   bool _selfNorm = true; ///< Is self-normalized
0201   RooArgSet _defNormSet ; ///< Default normalization set
0202
0203   ClassDefOverride(RooProdPdf,6) // PDF representing a product of PDFs
0204 };
0205
0206 namespace RooFit::Detail {
0207
0208 /// A RooProdPdf with a fixed normalization set can be replaced by this class.
0209 /// Its purpose is to provide the right client-server interface for the
0210 /// evaluation of RooProdPdf cache elements that were created for a given
0211 /// normalization set.
0212 class RooFixedProdPdf : public RooAbsPdf {
0213 public:
0214    RooFixedProdPdf(std::unique_ptr<RooProdPdf> &&prodPdf, RooArgSet const &normSet);
0215    RooFixedProdPdf(const RooFixedProdPdf &other, const char *name = nullptr);
0216
0217    inline TObject *clone(const char *newname) const override { return new RooFixedProdPdf(*this, newname); }
0218
0219    inline bool selfNormalized() const override { return true; }
0220
0221    inline bool canComputeBatchWithCuda() const override { return true; }
0222
0223    void doEval(RooFit::EvalContext &ctx) const override;
0224
0225    inline ExtendMode extendMode() const override { return _prodPdf->extendMode(); }
0226    inline double expectedEvents(const RooArgSet * /*nset*/) const override
0227    {
0228       return _prodPdf->expectedEvents(&_normSet);
0229    }
0230    inline std::unique_ptr<RooAbsReal> createExpectedEventsFunc(const RooArgSet * /*nset*/) const override
0231    {
0232       return _prodPdf->createExpectedEventsFunc(&_normSet);
0233    }
0234
0235    // Analytical Integration handling
0236    inline bool forceAnalyticalInt(const RooAbsArg &dep) const override { return _prodPdf->forceAnalyticalInt(dep); }
0237    inline Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &analVars, const RooArgSet *normSet,
0238                                         const char *rangeName = nullptr) const override
0239    {
0240       return _prodPdf->getAnalyticalIntegralWN(allVars, analVars, normSet, rangeName);
0241    }
0242    inline Int_t
0243    getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &numVars, const char *rangeName = nullptr) const override
0244    {
0245       return _prodPdf->getAnalyticalIntegral(allVars, numVars, rangeName);
0246    }
0247    inline double analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName) const override
0248    {
0249       return _prodPdf->analyticalIntegralWN(code, normSet, rangeName);
0250    }
0251    inline double analyticalIntegral(Int_t code, const char *rangeName = nullptr) const override
0252    {
0253       return _prodPdf->analyticalIntegral(code, rangeName);
0254    }
0255
0256    bool isRearranged() const { return _isRearranged; }
0257
0258    RooAbsReal const *rearrangedNum() const
0259    {
0260       return _isRearranged ? static_cast<RooAbsReal const *>(_servers[0]) : nullptr;
0261    }
0262    RooAbsReal const *rearrangedDen() const
0263    {
0264       return _isRearranged ? static_cast<RooAbsReal const *>(_servers[1]) : nullptr;
0265    }
0266
0267    RooArgSet const *partList() const { return !_isRearranged ? static_cast<RooArgSet const *>(&_servers) : nullptr; }
0268
0269 private:
0270    double evaluate() const override;
0271
0272    RooArgSet _normSet;
0273    RooSetProxy _servers;
0274    std::unique_ptr<RooProdPdf> _prodPdf;
0275    bool _isRearranged = false;
0276
0277    ClassDefOverride(RooFit::Detail::RooFixedProdPdf, 0);
0278 };
0279
0280 } // namespace RooFit::Detail
0281
0282 #endif