include/root/RooGlobalFunc.h

0001 /*****************************************************************************
0002  * Project: RooFit                                                           *
0003  * Package: RooFitCore                                                       *
0004  *    File: $Id: RooGlobalFunc.h,v 1.14 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_GLOBAL_FUNC
0017 #define ROO_GLOBAL_FUNC
0018
0019 #include "RooCmdArg.h"
0020 #include "RooLinkedList.h"
0021 #include "RooArgSet.h"
0022
0023 #include "ROOT/RConfig.hxx"
0024 #include <TColor.h>
0025
0026 #include <map>
0027 #include <string>
0028
0029 class RooDataHist ;
0030 class RooDataSet ;
0031 class RooFitResult ;
0032 class RooAbsPdf ;
0033 class RooAbsRealLValue ;
0034 class RooRealConstant ;
0035 class RooMsgService ;
0036 class RooFormulaVar ;
0037 class RooAbsData ;
0038 class RooCategory ;
0039 class RooAbsReal ;
0040 class RooAbsBinning ;
0041 class RooAbsCollection ;
0042 class RooAbsPdf ;
0043 class RooConstVar ;
0044 class RooRealVar ;
0045 class RooAbsCategory ;
0046 class RooNumIntConfig ;
0047
0048 class TH1 ;
0049 class TTree ;
0050
0051 /*! \namespace RooFit
0052 The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs
0053 (or other types of arguments).
0054
0055 These switches are documented with the relevant functions, e.g. RooAbsPdf::fitTo().
0056 For an introduction to RooFit (not the namespace), check the [user's guides](https://root.cern/root-user-guides-and-manuals),
0057 [courses](https://root.cern/learn/courses) or [the RooFit chapter of the Manual](https://root.cern/manual/roofit/).
0058 */
0059 namespace RooFit {
0060
0061 /// Verbosity level for RooMsgService::StreamConfig in RooMsgService
0062 enum MsgLevel { DEBUG=0, INFO=1, PROGRESS=2, WARNING=3, ERROR=4, FATAL=5 } ;
0063 /// Topics for a RooMsgService::StreamConfig in RooMsgService
0064 enum MsgTopic { Generation=1, Minimization=2, Plotting=4, Fitting=8, Integration=16, LinkStateMgmt=32,
0065     Eval=64, Caching=128, Optimization=256, ObjectHandling=512, InputArguments=1024, Tracing=2048,
0066     Contents=4096, DataHandling=8192, NumIntegration=16384, FastEvaluations=1<<15, HistFactory=1<<16, IO=1<<17 };
0067 enum MPSplit { BulkPartition=0, Interleave=1, SimComponents=2, Hybrid=3 } ;
0068
0069 /// For setting the offset mode with the Offset() command argument to
0070 /// RooAbsPdf::fitTo()
0071 enum class OffsetMode { None, Initial, Bin };
0072
0073 namespace Experimental {
0074
0075 /// Configuration options for parallel minimization with multiprocessing library
0076 RooCmdArg ParallelGradientOptions(bool enable=true, int orderStrategy=0, int chainFactor=1) ;
0077 RooCmdArg ParallelDescentOptions(bool enable=false, int splitStrategy=0, int numSplits=4) ;
0078
0079 } // Experimental
0080
0081 std::string getBatchCompute();
0082 void setBatchCompute(std::string const &value);
0083
0084 /**
0085  * \defgroup CmdArgs RooFit command arguments
0086  * These arguments can be passed to functions of RooFit objects.
0087  * \ingroup Roofitmain
0088  * @{
0089  */
0090
0091 /**
0092  * \defgroup Plotting Arguments for plotOn functions
0093  * @{
0094  */
0095 RooCmdArg DrawOption(const char* opt) ;
0096 RooCmdArg Normalization(double scaleFactor) ;
0097 RooCmdArg Slice(const RooArgSet& sliceSet) ;
0098 RooCmdArg Slice(RooCategory& cat, const char* label) ;
0099 RooCmdArg Slice(std::map<RooCategory*, std::string> const&) ;
0100 RooCmdArg Project(const RooArgSet& projSet) ;
0101 RooCmdArg ProjWData(const RooAbsData& projData, bool binData=false) ;
0102 RooCmdArg ProjWData(const RooArgSet& projSet, const RooAbsData& projData, bool binData=false) ;
0103 RooCmdArg Asymmetry(const RooCategory& cat) ;
0104 RooCmdArg Precision(double prec) ;
0105 RooCmdArg ShiftToZero() ;
0106 RooCmdArg Range(const char* rangeName, bool adjustNorm=true) ;
0107 RooCmdArg Range(double lo, double hi, bool adjustNorm=true) ;
0108 RooCmdArg NormRange(const char* rangeNameList) ;
0109 RooCmdArg VLines() ;
0110 RooCmdArg LineColor(TColorNumber color) ;
0111 RooCmdArg LineStyle(Style_t style) ;
0112 RooCmdArg LineStyle(std::string const &style) ;
0113 RooCmdArg LineWidth(Width_t width) ;
0114 RooCmdArg FillColor(TColorNumber color) ;
0115 RooCmdArg FillStyle(Style_t style) ;
0116 RooCmdArg FillStyle(std::string const &style) ;
0117 RooCmdArg ProjectionRange(const char* rangeName) ;
0118 RooCmdArg Name(const char* name) ;
0119 RooCmdArg Invisible(bool inv=true) ;
0120 RooCmdArg AddTo(const char* name, double wgtSel=1.0, double wgtOther=1.0) ;
0121 RooCmdArg EvalErrorValue(double value) ;
0122 RooCmdArg MoveToBack()  ;
0123 RooCmdArg VisualizeError(const RooDataSet& paramData, double Z=1) ;
0124 RooCmdArg VisualizeError(const RooFitResult& fitres, double Z=1, bool linearMethod=true) ;
0125 RooCmdArg VisualizeError(const RooFitResult& fitres, const RooArgSet& param, double Z=1, bool linearMethod=true) ;
0126 RooCmdArg ShowProgress() ;
0127
0128 // RooAbsPdf::plotOn arguments
0129 RooCmdArg Normalization(double scaleFactor, Int_t scaleType) ;
0130 template<class... Args_t>
0131 RooCmdArg Components(Args_t &&... argsOrArgSet) {
0132   RooCmdArg out{"SelectCompSet",0};
0133   out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
0134   return out;
0135 }
0136 RooCmdArg Components(const char* compSpec) ;
0137
0138 // RooAbsData::plotOn arguments
0139 RooCmdArg Cut(const char* cutSpec) ;
0140 RooCmdArg Cut(const RooFormulaVar& cutVar) ;
0141 RooCmdArg Binning(const RooAbsBinning& binning) ;
0142 RooCmdArg Binning(const char* binningName) ;
0143 RooCmdArg Binning(int nBins, double xlo=0.0, double xhi=0.0) ;
0144 RooCmdArg MarkerStyle(Style_t style) ;
0145 RooCmdArg MarkerStyle(std::string const &style) ;
0146 RooCmdArg MarkerSize(Size_t size) ;
0147 RooCmdArg MarkerColor(TColorNumber color) ;
0148 RooCmdArg CutRange(const char* rangeName) ;
0149 RooCmdArg XErrorSize(double width) ;
0150 RooCmdArg RefreshNorm() ;
0151 RooCmdArg Efficiency(const RooCategory& cat) ;
0152 RooCmdArg Rescale(double factor) ;
0153
0154 /** @} */
0155
0156 /**
0157  * \defgroup ConstructorArgs Arguments for various constructors
0158  * @{
0159  */
0160 // RooDataHist::ctor arguments
0161 RooCmdArg Weight(double wgt) ;
0162 RooCmdArg Index(RooCategory& icat) ;
0163 RooCmdArg Import(const char* state, TH1& histo) ;
0164 RooCmdArg Import(const std::map<std::string,TH1*>&) ;
0165 RooCmdArg Import(const char* state, RooDataHist& dhist) ;
0166 RooCmdArg Import(const std::map<std::string,RooDataHist*>&) ;
0167 RooCmdArg Import(TH1& histo, bool importDensity=false) ;
0168
0169 // RooDataSet::ctor arguments
0170 RooCmdArg WeightVar(const char* name="weight", bool reinterpretAsWeight=false) ;
0171 RooCmdArg WeightVar(const RooRealVar& arg, bool reinterpretAsWeight=false) ;
0172 RooCmdArg Import(const char* state, RooAbsData& data) ;
0173 RooCmdArg Import(const std::map<std::string,RooDataSet*>& ) ;
0174 template<class DataPtr_t>
0175 RooCmdArg Import(std::map<std::string,DataPtr_t> const& map) {
0176     RooCmdArg container("ImportDataSliceMany",0,0,0,0,nullptr,nullptr,nullptr,nullptr) ;
0177     for (auto const& item : map) {
0178       container.addArg(Import(item.first.c_str(), *item.second)) ;
0179     }
0180     container.setProcessRecArgs(true,false) ;
0181     return container ;
0182 }
0183
0184 RooCmdArg Link(const char* state, RooAbsData& data) ;
0185 RooCmdArg Link(const std::map<std::string,RooAbsData*>&) ;
0186 RooCmdArg Import(RooAbsData& data) ;
0187 RooCmdArg Import(TTree& tree) ;
0188 RooCmdArg ImportFromFile(const char* fname, const char* tname) ;
0189 RooCmdArg StoreError(const RooArgSet& aset) ;
0190 RooCmdArg StoreAsymError(const RooArgSet& aset) ;
0191 RooCmdArg OwnLinked() ;
0192
0193 /** @} */
0194
0195 // RooAbsPdf::printLatex arguments
0196 RooCmdArg Columns(Int_t ncol) ;
0197 RooCmdArg OutputFile(const char* fileName) ;
0198 RooCmdArg Format(const char* what, const RooCmdArg& arg1={}, const RooCmdArg& arg2={},
0199                  const RooCmdArg& arg3={},const RooCmdArg& arg4={},
0200                  const RooCmdArg& arg5={},const RooCmdArg& arg6={},
0201                  const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
0202 RooCmdArg Sibling(const RooAbsCollection& sibling) ;
0203
0204 // RooAbsRealLValue::frame arguments
0205 RooCmdArg Title(const char* name) ;
0206 RooCmdArg Bins(Int_t nbin) ;
0207 RooCmdArg AutoSymRange(const RooAbsData& data, double marginFactor=0.1) ;
0208 RooCmdArg AutoRange(const RooAbsData& data, double marginFactor=0.1) ;
0209
0210 // RooAbsData::createHistogram arguments
0211 RooCmdArg AutoSymBinning(Int_t nbins=100, double marginFactor=0.1) ;
0212 RooCmdArg AutoBinning(Int_t nbins=100, double marginFactor=0.1) ;
0213
0214 // RooAbsReal::fillHistogram arguments
0215 RooCmdArg IntegratedObservables(const RooArgSet& intObs) ;
0216
0217 // RooAbsData::reduce arguments
0218 RooCmdArg SelectVars(const RooArgSet& vars) ;
0219 RooCmdArg EventRange(Int_t nStart, Int_t nStop) ;
0220
0221
0222 /**
0223  * \defgroup Fitting Arguments for fitting
0224  * @{
0225  */
0226 // RooChi2Var::ctor / RooNLLVar arguments
0227 RooCmdArg Extended(bool flag=true) ;
0228 RooCmdArg DataError(Int_t) ;
0229 RooCmdArg DataError(std::string const&) ;
0230 RooCmdArg NumCPU(Int_t nCPU, Int_t interleave=0) ;
0231 RooCmdArg Parallelize(int nWorkers) ;
0232 RooCmdArg ModularL(bool flag=false) ;
0233 RooCmdArg TimingAnalysis(bool timingAnalysis) ;
0234
0235 //RooCmdArg BatchMode(std::string const& batchMode="cpu");
0236 //// The const char * overload is necessary, otherwise the compiler will cast a
0237 //// C-Style string to a bool and choose the BatchMode(bool) overload if one
0238 //// calls for example BatchMode("off").
0239 //inline RooCmdArg BatchMode(const char * batchMode) { return BatchMode(std::string(batchMode)); }
0240 //inline RooCmdArg BatchMode(bool batchModeOn) { return BatchMode(batchModeOn ? "cpu" : "off"); }
0241
0242 RooCmdArg IntegrateBins(double precision);
0243
0244 // RooAbsPdf::fitTo arguments
0245 RooCmdArg PrefitDataFraction(double data_ratio = 0.0) ;
0246 RooCmdArg Optimize(Int_t flag=2) ;
0247
0248 class EvalBackend : public RooCmdArg {
0249 public:
0250    enum class Value { Legacy, Cpu, Cuda, Codegen, CodegenNoGrad };
0251
0252    EvalBackend(Value value);
0253
0254    EvalBackend(std::string const &name);
0255
0256    static EvalBackend Legacy();
0257    static EvalBackend Cpu();
0258    static EvalBackend Cuda();
0259    static EvalBackend Codegen();
0260    static EvalBackend CodegenNoGrad();
0261
0262    Value value() const { return static_cast<Value>(getInt(0)); }
0263
0264    bool operator==(EvalBackend const &other) const { return value() == other.value(); }
0265
0266    bool operator!=(EvalBackend const &other) const { return value() != other.value(); }
0267
0268    std::string name() const;
0269
0270    static Value &defaultValue();
0271 private:
0272    static Value toValue(std::string const& name);
0273    static std::string toName(Value value);
0274 };
0275
0276 ////////////////////////////////////////////////////////////////////////////////
0277 /// Create a RooCmdArg to declare conditional observables.
0278 /// \param[in] argsOrArgSet Can either be one or more RooRealVar with the
0279 //                          observables or a single RooArgSet containing them.
0280 template<class... Args_t>
0281 RooCmdArg ConditionalObservables(Args_t &&... argsOrArgSet) {
0282   RooCmdArg out{"ProjectedObservables",0};
0283   out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
0284   return out;
0285 }
0286
0287 // obsolete, for backward compatibility
0288 template<class... Args_t>
0289 RooCmdArg ProjectedObservables(Args_t &&... argsOrArgSet) {
0290   return ConditionalObservables(std::forward<Args_t>(argsOrArgSet)...);
0291 }
0292
0293 RooCmdArg Verbose(bool flag=true) ;
0294 RooCmdArg Save(bool flag=true) ;
0295 RooCmdArg Timer(bool flag=true) ;
0296 RooCmdArg PrintLevel(Int_t code) ;
0297 RooCmdArg Warnings(bool flag=true) ;
0298 RooCmdArg Strategy(Int_t code) ;
0299 RooCmdArg InitialHesse(bool flag=true) ;
0300 RooCmdArg Hesse(bool flag=true) ;
0301 RooCmdArg Minos(bool flag=true) ;
0302 RooCmdArg Minos(const RooArgSet& minosArgs) ;
0303 RooCmdArg SplitRange(bool flag=true) ;
0304 RooCmdArg SumCoefRange(const char* rangeName) ;
0305 RooCmdArg Constrain(const RooArgSet& params) ;
0306 RooCmdArg MaxCalls(int n) ;
0307
0308 template<class... Args_t>
0309 RooCmdArg GlobalObservables(Args_t &&... argsOrArgSet) {
0310   RooCmdArg out{"GlobalObservables",0};
0311   out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
0312   return out;
0313 }
0314 RooCmdArg GlobalObservablesSource(const char* sourceName);
0315 RooCmdArg GlobalObservablesTag(const char* tagName) ;
0316 RooCmdArg ExternalConstraints(const RooArgSet& constraintPdfs) ;
0317 RooCmdArg PrintEvalErrors(Int_t numErrors) ;
0318 RooCmdArg EvalErrorWall(bool flag) ;
0319 RooCmdArg SumW2Error(bool flag) ;
0320 RooCmdArg AsymptoticError(bool flag) ;
0321 RooCmdArg CloneData(bool flag) ;
0322 RooCmdArg Integrate(bool flag) ;
0323 RooCmdArg Minimizer(const char* type, const char* alg=nullptr) ;
0324 RooCmdArg Offset(std::string const& mode);
0325 // The const char * overload is necessary, otherwise the compiler will cast a
0326 // C-Style string to a bool and choose the Offset(bool) overload if one
0327 // calls for example Offset("off").
0328 inline RooCmdArg Offset(const char * mode) { return Offset(std::string(mode)); }
0329 // For backwards compatibility
0330 inline RooCmdArg Offset(bool flag=true) { return flag ? Offset("initial") : Offset("off"); }
0331 RooCmdArg RecoverFromUndefinedRegions(double strength);
0332 /** @} */
0333
0334 // RooAbsPdf::paramOn arguments
0335 RooCmdArg Label(const char* str) ;
0336 RooCmdArg Layout(double xmin, double xmax=0.99, double ymin=0.95) ;
0337 RooCmdArg Parameters(const RooArgSet& params) ;
0338 RooCmdArg ShowConstants(bool flag=true) ;
0339
0340 // RooTreeData::statOn arguments
0341 RooCmdArg What(const char* str) ;
0342
0343 // RooProdPdf::ctor arguments
0344 RooCmdArg Conditional(const RooArgSet& pdfSet, const RooArgSet& depSet, bool depsAreCond=false) ;
0345
0346 /**
0347  * \defgroup Generating Arguments for generating data
0348  * @{
0349  */
0350 // RooAbsPdf::generate arguments
0351 RooCmdArg ProtoData(const RooDataSet& protoData, bool randomizeOrder=false, bool resample=false) ;
0352 RooCmdArg NumEvents(Int_t numEvents) ;
0353 RooCmdArg NumEvents(double numEvents) ;
0354 RooCmdArg AutoBinned(bool flag=true) ;
0355 RooCmdArg GenBinned(const char* tag) ;
0356 RooCmdArg AllBinned() ;
0357 RooCmdArg ExpectedData(bool flag=true) ;
0358 RooCmdArg Asimov(bool flag=true) ;
0359
0360 /** @} */
0361
0362 // RooAbsRealLValue::createHistogram arguments
0363 RooCmdArg YVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
0364 RooCmdArg ZVar(const RooAbsRealLValue& var, const RooCmdArg& arg={}) ;
0365 RooCmdArg AxisLabel(const char* name) ;
0366 RooCmdArg Scaling(bool flag) ;
0367
0368
0369 // RooAbsReal::createHistogram arguments
0370 RooCmdArg IntrinsicBinning(bool flag=true) ;
0371
0372 // RooAbsReal::createIntegral arguments
0373 template<class... Args_t>
0374 RooCmdArg NormSet(Args_t &&... argsOrArgSet) {
0375   RooCmdArg out{"NormSet",0};
0376   out.setSet(0, RooArgSet{std::forward<Args_t>(argsOrArgSet)...});
0377   return out;
0378 }
0379 RooCmdArg NumIntConfig(const RooNumIntConfig& cfg) ;
0380
0381 // RooMCStudy::ctor arguments
0382 RooCmdArg Silence(bool flag=true) ;
0383 RooCmdArg FitModel(RooAbsPdf& pdf) ;
0384 RooCmdArg FitOptions(const RooCmdArg& arg1                ,const RooCmdArg& arg2={},
0385                      const RooCmdArg& arg3={},const RooCmdArg& arg4={},
0386                      const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
0387 RooCmdArg Binned(bool flag=true) ;
0388
0389 // RooMCStudy::plot* arguments
0390 RooCmdArg Frame(const RooCmdArg& arg1                ,const RooCmdArg& arg2={},
0391                 const RooCmdArg& arg3={},const RooCmdArg& arg4={},
0392                 const RooCmdArg& arg5={},const RooCmdArg& arg6={}) ;
0393 RooCmdArg FrameBins(Int_t nbins) ;
0394 RooCmdArg FrameRange(double xlo, double xhi) ;
0395 RooCmdArg FitGauss(bool flag=true) ;
0396
0397 // RooRealVar::format arguments
0398 RooCmdArg AutoPrecision(Int_t ndigit=2) ;
0399 RooCmdArg FixedPrecision(Int_t ndigit=2) ;
0400 RooCmdArg TLatexStyle(bool flag=true) ;
0401 RooCmdArg LatexStyle(bool flag=true) ;
0402 RooCmdArg LatexTableStyle(bool flag=true) ;
0403 RooCmdArg VerbatimName(bool flag=true) ;
0404
0405 // RooMsgService::addReportingStream arguments
0406 RooCmdArg Topic(Int_t topic) ;
0407 RooCmdArg ObjectName(const char* name) ;
0408 RooCmdArg ClassName(const char* name) ;
0409 RooCmdArg BaseClassName(const char* name) ;
0410 RooCmdArg TagName(const char* name) ;
0411 RooCmdArg OutputStream(std::ostream& os) ;
0412 RooCmdArg Prefix(bool flag) ;
0413 RooCmdArg Color(TColorNumber color) ;
0414
0415 // RooWorkspace::import() arguments
0416 RooCmdArg RenameConflictNodes(const char* suffix, bool renameOrigNodes=false) ;
0417 RooCmdArg RenameAllNodes(const char* suffix) ;
0418 RooCmdArg RenameAllVariables(const char* suffix) ;
0419 RooCmdArg RenameAllVariablesExcept(const char* suffix,const char* exceptionList) ;
0420 RooCmdArg RenameVariable(const char* inputName, const char* outputName) ;
0421 RooCmdArg Rename(const char* suffix) ;
0422 RooCmdArg RecycleConflictNodes(bool flag=true) ;
0423 RooCmdArg Embedded(bool flag=true) ;
0424 RooCmdArg NoRecursion(bool flag=true) ;
0425
0426 // RooSimCloneTool::build() arguments
0427 RooCmdArg SplitParam(const char* varname, const char* catname) ;
0428 RooCmdArg SplitParam(const RooRealVar& var, const RooAbsCategory& cat) ;
0429 RooCmdArg SplitParamConstrained(const char* varname, const char* catname, const char* rsname) ;
0430 RooCmdArg SplitParamConstrained(const RooRealVar& var, const RooAbsCategory& cat, const char* rsname) ;
0431 RooCmdArg Restrict(const char* catName, const char* stateNameList) ;
0432
0433 // RooAbsPdf::createCdf() arguments
0434 RooCmdArg SupNormSet(const RooArgSet& nset) ;
0435 RooCmdArg ScanParameters(Int_t nbins,Int_t intOrder) ;
0436 RooCmdArg ScanNumCdf() ;
0437 RooCmdArg ScanAllCdf() ;
0438 RooCmdArg ScanNoCdf() ;
0439
0440 // Generic container arguments (to be able to supply more command line arguments)
0441 RooCmdArg MultiArg(const RooCmdArg& arg1, const RooCmdArg& arg2,
0442          const RooCmdArg& arg3={},const RooCmdArg& arg4={},
0443          const RooCmdArg& arg5={},const RooCmdArg& arg6={},
0444          const RooCmdArg& arg7={},const RooCmdArg& arg8={}) ;
0445
0446 RooConstVar& RooConst(double val) ;
0447
0448 // End group CmdArgs:
0449 /**
0450  * @}
0451  */
0452
0453 namespace Detail {
0454
0455 // Function to pack an arbitrary number of RooCmdArgs into a RooLinkedList. Implementation detail of many high-level RooFit functions.
0456 template <typename... Args>
0457 inline std::unique_ptr<RooLinkedList> createCmdList(RooCmdArg const* arg1, Args &&...args)
0458 {
0459    auto cmdList = std::make_unique<RooLinkedList>();
0460    for (auto &arg : {arg1, static_cast<RooCmdArg const *>(args)...}) {
0461       cmdList->Add(const_cast<RooCmdArg *>(arg));
0462    }
0463    return cmdList;
0464 }
0465
0466 inline std::unique_ptr<RooLinkedList> createCmdList()
0467 {
0468    return std::make_unique<RooLinkedList>();
0469 }
0470
0471 inline std::unique_ptr<RooLinkedList> createCmdList(RooLinkedList const *cmdList)
0472 {
0473    auto cmdListCopy = std::make_unique<RooLinkedList>();
0474    for (auto *arg : *cmdList) {
0475       cmdListCopy->Add(arg);
0476    }
0477    return cmdListCopy;
0478 }
0479
0480 // RooFit-internal helper struct to build a map object that only uses
0481 // std::vector, which can be implicitly converted to std::map in C++. Used to
0482 // avoid std::map in pythonizations.
0483 template <class Key_t, class Val_t>
0484 struct FlatMap {
0485    std::vector<Key_t> keys;
0486    std::vector<Val_t> vals;
0487 };
0488
0489 template <class Key_t, class Val_t>
0490 auto flatMapToStdMap(FlatMap<Key_t, Val_t> const& flatMap) {
0491    std::map<Key_t, Val_t> out;
0492    for (std::size_t i = 0; i < flatMap.keys.size(); ++i) {
0493       out[flatMap.keys[i]] = flatMap.vals[i];
0494    }
0495    return out;
0496 }
0497
0498 // Internal variant of Slice(), Import(), and Link(), that take flat maps instead of std::map.
0499 RooCmdArg SliceFlatMap(FlatMap<RooCategory *, std::string> const &args);
0500 RooCmdArg ImportFlatMap(FlatMap<std::string, RooDataHist *> const &args);
0501 RooCmdArg ImportFlatMap(FlatMap<std::string, TH1 *> const &args);
0502 RooCmdArg ImportFlatMap(FlatMap<std::string, RooDataSet *> const &args);
0503 RooCmdArg LinkFlatMap(FlatMap<std::string, RooAbsData *> const &args);
0504
0505 } // namespace Detail
0506
0507 } // namespace RooFit
0508
0509 namespace RooFitShortHand {
0510
0511 RooConstVar& C(double value);
0512
0513 } // namespace RooFitShortHand
0514
0515 #endif