113 _pdfList(
"!pdfs",
"List of PDFs",this)
116 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(
"nset")) ;
122 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(
"nset")) ;
127 coutW(InputArguments) <<
"RooProdPdf::RooProdPdf(" <<
GetName()
128 <<
") multiple components with extended terms detected,"
129 <<
" product will not be extendible." << endl ;
161 _pdfList(
"!pdfs",
"List of PDFs",this)
209 _pdfList(
"!pdfs",
"List of PDFs",this)
233 _pdfList(
"!pdfList",
"List of PDFs",this)
253 _pdfList(
"!pdfs",
"List of PDFs",this)
266 _cacheMgr(other._cacheMgr,this),
267 _genCode(other._genCode),
268 _cutOff(other._cutOff),
269 _pdfList(
"!pdfs",this,other._pdfList),
270 _extendedIndex(other._extendedIndex),
271 _useDefaultGen(other._useDefaultGen),
272 _refRangeName(other._refRangeName),
273 _selfNorm(other._selfNorm),
274 _defNormSet(other._defNormSet)
278 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(nset->GetName()));
292 Int_t numExtended(0) ;
295 for(
auto const* pdf : static_range_cast<RooAbsPdf*>(fullPdfSet)) {
297 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(
"nset")) ;
299 if (pdf->canBeExtended()) {
307 for(
auto * carg : static_range_cast<RooCmdArg*>(
l)) {
309 if (0 == strcmp(carg->GetName(),
"Conditional")) {
311 Int_t argType = carg->getInt(0) ;
312 auto pdfSet =
static_cast<RooArgSet const*
>(carg->getSet(0));
313 auto normSet =
static_cast<RooArgSet const*
>(carg->getSet(1));
315 for(
auto * thePdf : static_range_cast<RooAbsPdf*>(*pdfSet)) {
318 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(0 == argType ?
"nset" :
"cset"));
321 if (thePdf->canBeExtended()) {
328 }
else if (0 != strlen(carg->GetName())) {
329 coutW(InputArguments) <<
"Unknown arg: " << carg->GetName() << endl ;
335 coutW(InputArguments) <<
"RooProdPdf::RooProdPdf(" <<
GetName()
336 <<
") WARNING: multiple components with extended terms detected,"
337 <<
" product will not be extendible." << endl ;
386 cxcoutD(Eval) <<
"RooProdPdf::calculate(" <<
GetName() <<
") rearranged product calculation"
400 const auto normSet = cache.
_normList[i].get();
402 const double piVal = partInt.getVal(normSet->getSize() > 0 ? normSet :
nullptr);
425 auto span = dataMap.
at(i);
426 factors.push_back(span);
436void eraseNullptrs(std::vector<T*>&
v) {
437 v.erase(std::remove_if(
v.begin(),
v.end(), [](T*
x){ return x == nullptr; } ),
v.end());
440void removeCommon(std::vector<RooAbsArg*> &
v, std::span<RooAbsArg * const> other) {
442 for (
auto const& arg : other) {
443 auto namePtrMatch = [&arg](
const RooAbsArg* elm) {
444 return elm !=
nullptr && elm->namePtr() == arg->namePtr();
447 auto found = std::find_if(
v.begin(),
v.end(), namePtrMatch);
448 if(found !=
v.end()) {
455void addCommon(std::vector<RooAbsArg*> &
v, std::vector<RooAbsArg*>
const& o1, std::vector<RooAbsArg*>
const& o2) {
457 for (
auto const& arg : o1) {
458 auto namePtrMatch = [&arg](
const RooAbsArg* elm) {
459 return elm->namePtr() == arg->namePtr();
462 if(std::find_if(o2.begin(), o2.end(), namePtrMatch) != o2.end()) {
480 std::vector<RooArgSet> depAllList;
481 std::vector<RooArgSet> depIntNoNormList;
489 std::vector<RooAbsArg*> pdfIntNoNormDeps;
490 std::vector<RooAbsArg*> pdfIntSet;
491 std::vector<RooAbsArg*> pdfNSet;
492 std::vector<RooAbsArg*> pdfCSet;
493 std::vector<RooAbsArg*> pdfNormDeps;
494 std::vector<RooAbsArg*> pdfAllDeps;
497 for(std::size_t iPdf = 0; iPdf <
_pdfList.
size(); ++iPdf) {
508 RooArgSet pdfLeafList(
"leafNodeServerList") ;
510 auto getObservablesOfCurrentPdf = [&pdfLeafList](
511 std::vector<RooAbsArg*> & out,
513 for (
const auto arg : pdfLeafList) {
514 if (arg->dependsOnValue(dataList) && arg->isLValue()) {
521 if (0 == strcmp(
"cset", pdfNSetOrig.
GetName())) {
522 getObservablesOfCurrentPdf(pdfNSet, normSet);
523 removeCommon(pdfNSet, pdfNSetOrig.
get());
524 pdfCSet = pdfNSetOrig.
get();
527 getObservablesOfCurrentPdf(pdfNSet, pdfNSetOrig);
535 getObservablesOfCurrentPdf(pdfAllDeps, normSet);
541 if (!pdfNSet.empty()) {
543 addCommon(pdfNormDeps, pdfAllDeps, pdfNSet);
546 pdfNormDeps = pdfAllDeps;
552 getObservablesOfCurrentPdf(pdfIntSet, intSet) ;
555 if (pdfNormDeps.empty() && !pdfCSet.empty()) {
556 removeCommon(pdfIntSet, pdfCSet);
560 pdfIntNoNormDeps.clear();
561 pdfIntNoNormDeps = pdfIntSet;
562 removeCommon(pdfIntNoNormDeps, pdfNormDeps);
569 auto lIter = termList.
begin();
570 auto ldIter = normList.
begin();
571 for(;lIter != termList.
end(); (++lIter, ++ldIter, ++j)) {
572 termNormDeps =
static_cast<RooArgSet*
>(*ldIter);
580 bool normOverlap = termNormDeps->
overlaps(pdfNormDeps.begin(), pdfNormDeps.end());
587 termNormDeps->
add(pdfNormDeps.begin(), pdfNormDeps.end(),
false);
588 depAllList[j].add(pdfAllDeps.begin(), pdfAllDeps.end(),
false);
590 termIntDeps->
add(pdfIntSet.begin(), pdfIntSet.end(),
false);
592 if (termIntNoNormDeps) {
593 termIntNoNormDeps->
add(pdfIntNoNormDeps.begin(), pdfIntNoNormDeps.end(),
false);
595 termIntNoNormDeps->
add(pdfIntNoNormDeps.begin(), pdfIntNoNormDeps.end(),
false);
602 if (!(pdfNormDeps.empty() && pdfAllDeps.empty() &&
603 pdfIntSet.empty()) || normSet.
empty()) {
605 termNormDeps =
new RooArgSet(
"termNormDeps");
606 depAllList.emplace_back(pdfAllDeps.begin(), pdfAllDeps.end(),
"termAllDeps");
607 termIntDeps =
new RooArgSet(pdfIntSet.begin(), pdfIntSet.end(),
"termIntDeps");
608 depIntNoNormList.emplace_back(pdfIntNoNormDeps.begin(), pdfIntNoNormDeps.end(),
"termIntNoNormDeps");
609 termIntNoNormDeps = &depIntNoNormList.back();
612 termNormDeps->
add(pdfNormDeps.begin(), pdfNormDeps.end(),
false);
615 normList.
Add(termNormDeps);
616 intList.
Add(termIntDeps);
625 auto lIter = termList.
begin();
626 auto ldIter = normList.
begin();
627 for(;lIter != termList.
end(); (++lIter, ++ldIter, ++i)) {
628 normDeps =
static_cast<RooArgSet*
>(*ldIter);
632 impDeps.
remove(*normDeps,
true,
true);
635 impDepList.
Add(snap);
640 auto crossDeps = std::unique_ptr<RooAbsCollection>{depIntNoNormList[i].selectCommon(*normDeps)};
643 crossDepList.
Add(snap);
662 Int_t sterileIdx(-1);
668 std::unique_ptr<CacheElem> cache =
createCacheElem(nset, iset, isetRangeName);
678 const char* isetRangeName)
const
686 auto cache = std::make_unique<CacheElem>();
702 std::list<std::vector<RooArgSet*>> groupedList;
710 std::map<std::string, RooArgSet> ratioTerms;
711 for (
auto const&
group : groupedList) {
712 if (1 ==
group.size()) {
720 RooArgSet termNSet(*norm), termImpSet(*imps);
730 bool rangeIdentical(
true);
732 for (
auto const* normObs : static_range_cast<RooRealVar*>(termNSet)) {
746 if (!rangeIdentical ) {
749 std::ostringstream str; termImpSet.
printValue(str);
751 ratioTerms[str.str()].addOwned(std::move(ratio));
758 for (
auto const& term :
group) {
763 RooArgSet termNSet(*norm), termImpSet(*imps);
768 bool rangeIdentical(
true);
771 for (
auto const* normObs : static_range_cast<RooRealVar*>(termNSet)) {
776 for (
auto const* normObs : static_range_cast<RooRealVar*>(termNSet)) {
782 if (!rangeIdentical ) {
785 std::ostringstream str; termImpSet.
printValue(str);
786 ratioTerms[str.str()].addOwned(std::move(ratio));
796 for (
auto const&
group : groupedList) {
797 for (
auto const& term :
group) {
801 RooArgSet termNSet(*norm), termImpSet(*imps);
804 ostringstream str; termNSet.printValue(str);
805 if (!ratioTerms[str.str()].empty()) {
807 term->add(ratioTerms[str.str()]);
808 cache->_ownedList.addOwned(std::move(ratioTerms[str.str()]));
813 for (
auto const&
group : groupedList) {
817 if (1 ==
group.size()) {
827 RooArgSet termNSet, termISet, termXSet, termImpSet;
830 termISet.
add(*integ);
834 termXSet.
add(*xdeps);
835 termImpSet.
add(*imps);
839 vector<RooAbsReal*> func =
processProductTerm(nset, iset, isetRangeName, term, termNSet, termISet, isOwned);
841 cache->_partList.add(*func[0]);
842 if (isOwned) cache->_ownedList.addOwned(std::unique_ptr<RooAbsArg>{func[0]});
844 cache->_normList.emplace_back(std::make_unique<RooArgSet>());
845 norm->snapshot(*cache->_normList.back(),
false);
847 cache->_numList.addOwned(std::unique_ptr<RooAbsArg>{func[1]});
848 cache->_denList.addOwned(std::unique_ptr<RooAbsArg>{func[2]});
852 RooArgSet compTermSet, compTermNorm, compTermNum, compTermDen;
853 for (
auto const& term :
group) {
861 RooArgSet termNSet, termISet, termXSet, termImpSet;
862 termISet.
add(*integ);
864 termXSet.
add(*xdeps);
865 termImpSet.
add(*imps);
868 termISet.
remove(outerIntDeps,
true,
true);
870 bool isOwned =
false;
871 vector<RooAbsReal*> func =
processProductTerm(nset, iset, isetRangeName, term, termNSet, termISet, isOwned,
true);
874 compTermSet.
add(*func[0]);
875 if (isOwned) cache->_ownedList.addOwned(std::unique_ptr<RooAbsArg>{func[0]});
876 compTermNorm.
add(*norm,
false);
878 compTermNum.
add(*func[1]);
879 compTermDen.
add(*func[2]);
895 const std::string prodname =
makeRGPPName(
"SPECPROD", compTermSet, outerIntDeps,
RooArgSet(), isetRangeName);
896 auto prodtmp = std::make_unique<RooProduct>(prodname.c_str(), prodname.c_str(), compTermSet);
898 const std::string intname =
makeRGPPName(
"SPECINT", compTermSet, outerIntDeps,
RooArgSet(), isetRangeName);
899 auto inttmp = std::make_unique<RooRealIntegral>(intname.c_str(), intname.c_str(), *prodtmp, outerIntDeps,
nullptr,
nullptr, isetRangeName);
900 inttmp->setStringAttribute(
"PROD_TERM_TYPE",
"SPECINT");
902 cache->_partList.add(*inttmp);
906 auto prodtmp_num = std::make_unique<RooProduct>(prodname_num.c_str(), prodname_num.c_str(), compTermNum);
907 prodtmp_num->addOwnedComponents(compTermNum);
911 auto prodtmp_den = std::make_unique<RooProduct>(prodname_den.c_str(), prodname_den.c_str(), compTermDen);
912 prodtmp_den->addOwnedComponents(compTermDen);
915 std::string
name =
Form(
"SPEC_RATIO(%s,%s)", prodname_num.c_str(), prodname_den.c_str());
916 auto ndr = std::make_unique<RooFormulaVar>(
name.c_str(),
"@0/@1",
RooArgList(*prodtmp_num, *prodtmp_den));
919 std::unique_ptr<RooAbsReal> numtmp{ndr->createIntegral(outerIntDeps,isetRangeName)};
920 numtmp->addOwnedComponents(std::move(ndr));
922 cache->_ownedList.addOwned(std::move(prodtmp));
923 cache->_ownedList.addOwned(std::move(inttmp));
924 cache->_ownedList.addOwned(std::move(prodtmp_num));
925 cache->_ownedList.addOwned(std::move(prodtmp_den));
926 cache->_numList.addOwned(std::move(numtmp));
928 cache->_normList.emplace_back(std::make_unique<RooArgSet>());
929 compTermNorm.
snapshot(*cache->_normList.back(),
false);
955 std::unique_ptr<RooAbsReal> ratio_num{pdf.
createIntegral(termNset,normRangeTmp)};
956 std::unique_ptr<RooAbsReal> ratio_den{pdf.
createIntegral(termNset,refRange)};
957 auto ratio = std::make_unique<RooFormulaVar>(
Form(
"ratio(%s,%s)",ratio_num->GetName(),ratio_den->GetName()),
"@0/@1",
960 ratio->addOwnedComponents(std::move(ratio_num));
961 ratio->addOwnedComponents(std::move(ratio_den));
962 ratio->setAttribute(
"RATIO_TERM") ;
976 list<string> rangeComps ;
981 char* token = R__STRTOK_R(buf.data(),
",",&save) ;
983 rangeComps.push_back(token) ;
984 token = R__STRTOK_R(0,
",",&save) ;
989 std::map<std::string,RooArgSet> denListList ;
991 string specIntRange ;
1016 std::unique_ptr<RooArgSet> components{orig->
getComponents()};
1018 if (carg->getAttribute(
"RATIO_TERM")) {
1030 nomList.
add(*funcCust) ;
1032 nomList.
add(*func) ;
1047 if (arg->getAttribute(
"RATIO_TERM")) {
1050 origNumTerm.
add(*arg) ;
1058 nomList.
add(origNumTerm) ;
1065 for (list<string>::iterator iter = rangeComps.begin() ; iter != rangeComps.end() ; ++iter) {
1086 for (
auto* parg : static_range_cast<RooAbsReal*>(dentmp->
components())) {
1108 partCust = cust.
build() ;
1113 partCust = cust.
build() ;
1123 string name =
Form(
"%s_divided_by_ratio",specializedPartCust->GetName()) ;
1124 auto specIntFinal = std::make_unique<RooFormulaVar>(
name.c_str(),
"@0/@1",
RooArgList(*specializedPartCust,*specializedRatio)) ;
1125 specIntFinal->addOwnedComponents(std::move(specializedPartCust));
1126 specIntFinal->addOwnedComponents(std::move(specializedRatio));
1128 denListList[*iter].addOwned(std::move(specIntFinal));
1149 tmp.
add(*specRatio) ;
1151 auto specDenProd = std::make_unique<RooProduct>(pname.c_str(),pname.c_str(),tmp) ;
1152 std::unique_ptr<RooAbsReal> specInt;
1155 specInt = std::unique_ptr<RooAbsReal>{specDenProd->createIntegral(((
RooRealIntegral*)den)->intVars(),iter->c_str())};
1156 specInt->addOwnedComponents(std::move(specDenProd));
1160 specInt = std::unique_ptr<RooAbsReal>{specDenProd->createIntegral(origInt->
intVars(),iter->c_str())};
1163 throw string(
"this should not happen") ;
1167 string name =
Form(
"%s_divided_by_ratio",specInt->GetName()) ;
1168 auto specIntFinal = std::make_unique<RooFormulaVar>(
name.c_str(),
"@0/@1",
RooArgList(*specInt,*specRatio)) ;
1169 specIntFinal->addOwnedComponents(std::move(specInt));
1170 specIntFinal->addOwnedComponents(std::move(specRatio));
1171 denListList[*iter].addOwned(std::move(specIntFinal));
1182 if (nomList.
empty()) {
1189 std::unique_ptr<RooAbsReal> numerator = std::make_unique<RooProduct>(
name.c_str(),
name.c_str(),nomList) ;
1193 for (map<string,RooArgSet>::iterator iter = denListList.begin() ; iter != denListList.end() ; ++iter) {
1199 products.
add(*prod_comp) ;
1205 if (!specIntDeps.
empty()) {
1208 string namesr =
Form(
"SPEC_RATIO(%s,%s)",numerator->GetName(),norm->
GetName()) ;
1213 numerator = std::unique_ptr<RooAbsReal>{ndr->
createIntegral(specIntDeps,specIntRange.c_str())};
1242 std::unique_ptr<RooAbsReal> numint_spec{
specializeIntegral(*numint,targetRangeName)};
1244 std::unique_ptr<RooAbsReal> ret = std::make_unique<RooFormulaVar>(
Form(
"ratio(%s,%s)",numint_spec->GetName(),denint->
GetName()),
"@0/@1",
RooArgList(*numint_spec,*denint)) ;
1245 ret->addOwnedComponents(std::move(numint_spec));
1272 std::stringstream errMsg;
1273 errMsg <<
"specializeIntegral: unknown input type " <<
input.ClassName() <<
"::" <<
input.GetName();
1274 throw std::runtime_error(errMsg.str());
1286 for(
auto * term : static_range_cast<RooArgSet*>(terms)) {
1287 groupedTerms.emplace_back();
1288 groupedTerms.back().emplace_back(term) ;
1293 for(
auto * impDeps : static_range_cast<RooArgSet*>(imps)) {
1294 allImpDeps.
add(*impDeps,
false) ;
1299 for(
auto * intDeps : static_range_cast<RooArgSet*>(ints)) {
1300 allIntDeps.
add(*intDeps,
false) ;
1307 for(
RooAbsArg * outerIntDep : outerIntDeps) {
1310 std::vector<RooArgSet*>* newGroup = nullptr ;
1313 bool needMerge = false ;
1314 auto group = groupedTerms.begin();
1315 auto nGroups = groupedTerms.size();
1316 for (
size_t iGroup = 0; iGroup < nGroups; ++iGroup) {
1319 for (
auto const& term2 : *
group) {
1326 if (termNormDeps->
contains(*outerIntDep) ||
1327 termIntDeps->
contains(*outerIntDep) ||
1328 termImpDeps->
contains(*outerIntDep)) {
1336 if (newGroup==
nullptr) {
1337 groupedTerms.emplace_back() ;
1338 newGroup = &groupedTerms.back() ;
1342 for (
auto& term2 : *
group) {
1343 newGroup->emplace_back(term2) ;
1364 bool& isOwned,
bool forceWrap)
const
1366 vector<RooAbsReal*> ret(3) ; ret[0] = 0 ; ret[1] = 0 ; ret[2] = 0 ;
1382 if (nset && termNSet.
empty()) {
1390 if (iset && termISet.
getSize()>0) {
1409 ret[1] = std::unique_ptr<RooAbsReal>{pdf->
createIntegral(termISet,isetRangeName)}.release();
1421 const std::string
name =
makeRGPPName(
"GENPROJ_",*term,termISet,termNSet,isetRangeName) ;
1436 ret[1] = std::unique_ptr<RooAbsReal>{tmp_prod->
createIntegral(termISet,isetRangeName)}.release();
1448 const std::string
name =
makeRGPPName(
"GENPROJ_",*term,termISet,termNSet,isetRangeName) ;
1465 ret[1] = std::unique_ptr<RooAbsReal>{tmp_prod->
createIntegral(termISet,isetRangeName)}.release();
1473 for (
auto* pdf : static_range_cast<RooAbsPdf*>(*term)) {
1479 name.Append(
"_NORM[") ;
1481 for (
auto const* arg : termNSet) {
1487 name.Append(arg->GetName()) ;
1504 ret[2] = std::unique_ptr<RooAbsReal>{pdf->createIntegral(termNSet,
normRange())}.release();
1515 pdf->setStringAttribute(
"PROD_TERM_TYPE",
"IVb") ;
1518 ret[1] = std::unique_ptr<RooAbsReal>{pdf->createIntegral(
RooArgSet())}.release();
1519 ret[2] = !termNSet.
empty() ? std::unique_ptr<RooAbsReal>{pdf->createIntegral(termNSet,
normRange())}.release()
1525 coutE(Eval) <<
"RooProdPdf::processProductTerm(" <<
GetName() <<
") unidentified term!!!" << endl ;
1536 const RooArgSet& nset,
const char* isetRangeName)
const
1540 std::ostringstream os(pfx);
1545 for (
auto const* pdf : static_range_cast<RooAbsPdf*>(term)) {
1546 if (!
first) os <<
"_X_";
1548 os << pdf->GetName();
1583 const RooArgSet* normSet,
const char* rangeName)
const
1588 analVars.
add(allVars) ;
1654 coutF(Generation) <<
"Requesting expected number of events from a RooProdPdf that does not contain an extended p.d.f" << endl ;
1655 throw std::logic_error(std::string(
"RooProdPdf ") +
GetName() +
" could not be extended.");
1667 const RooArgSet* auxProto,
bool verbose)
const
1685 for (
auto const* arg : directVars) {
1691 std::vector<Int_t> code;
1693 for (
auto const* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
1695 Int_t pdfCode = pdf->getGenerator(directSafe,pdfDirect,staticInitOK);
1696 code.push_back(pdfCode);
1698 generateVars.
add(pdfDirect) ;
1703 if (generateVars.
getSize()>0) {
1705 return masterCode+1 ;
1723 for (
auto* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
1724 if (codeList[i]!=0) {
1725 pdf->initGenerator(codeList[i]) ;
1744 for (
auto* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
1745 if (codeList[i]!=0) {
1746 pdf->generateEvent(codeList[i]) ;
1777 os <<
indent <<
"RooProdPdf begin partial integral cache" << endl ;
1780 auto indent2 = std::string(
indent) +
"[" + std::to_string(curElem) +
"]";
1781 for(
auto const& arg : _partList) {
1782 arg->printCompactTree(os,indent2.c_str()) ;
1785 if (curElem==maxElem) {
1786 os <<
indent <<
"RooProdPdf end partial integral cache" << endl ;
1803 for (
auto* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
1805 if (pdf->dependsOn(arg)) {
1809 if (thePdf)
return false ;
1826 if (idx<0)
return nullptr;
1837 for(
auto arg : pdfs) {
1840 coutW(InputArguments) <<
"RooProdPdf::addPdfs(" <<
GetName() <<
") list arg "
1841 << arg->GetName() <<
" is not a PDF, ignored" << endl ;
1852 _pdfNSetList.emplace_back(std::make_unique<RooArgSet>(
"nset"));
1856 if (numExtended>1) {
1857 coutW(InputArguments) <<
"RooProdPdf::addPdfs(" <<
GetName()
1858 <<
") WARNING: multiple components with extended terms detected,"
1859 <<
" product will not be extendible." << endl ;
1899 std::vector<TNamed const*> ptrs;
1900 ptrs.reserve(col.
size());
1902 ptrs.push_back(arg->namePtr());
1904 std::sort(ptrs.begin(), ptrs.end());
1908bool sortedNamePtrsOverlap(std::vector<TNamed const*>
const& ptrsA, std::vector<TNamed const*>
const& ptrsB)
1910 auto pA = ptrsA.begin();
1911 auto pB = ptrsB.begin();
1912 while (pA != ptrsA.end() && pB != ptrsB.end()) {
1915 }
else if (*pB < *pA) {
1934 bool stripDisconnected,
bool removeConstraintsFromPdf)
const
1940 auto observablesNamePtrs = sortedNamePtrs(observables);
1941 auto constrainedParamsNamePtrs = sortedNamePtrs(constrainedParams);
1944 for(
auto * pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
1948 pdf->getParameters(
nullptr, tmp);
1949 auto tmpNamePtrs = sortedNamePtrs(tmp);
1961 if (!sortedNamePtrsOverlap(tmpNamePtrs, observablesNamePtrs) &&
1962 sortedNamePtrsOverlap(tmpNamePtrs, constrainedParamsNamePtrs)) {
1963 constraints.
add(*pdf) ;
1964 conParams.
add(tmp,
true) ;
1971 tmp.
remove(observables,
false,
true);
1972 pdfParams.
add(tmp,
true) ;
1977 if(removeConstraintsFromPdf) {
1983 for(
auto * pdf : static_range_cast<RooAbsPdf*>(constraints)) {
1984 if (pdf->dependsOnValue(pdfParams) || !stripDisconnected) {
1985 finalConstraints->
add(*pdf) ;
1987 coutI(Minimization) <<
"RooProdPdf::getConstraints(" <<
GetName() <<
") omitting term " << pdf->GetName()
1988 <<
" as constraint term as it does not share any parameters with the other pdfs in product. "
1989 <<
"To force inclusion in likelihood, add an explicit Constrain() argument for the target parameter" << endl ;
1997 cexl.
remove(pdfParams,
true,
true) ;
1998 constrainedParams.
remove(cexl,
true,
true) ;
2000 return finalConstraints ;
2017 if (arg->dependsOn(observables)) {
2019 arg->getParameters(&observables, tmp);
2020 connectedPars->
add(tmp) ;
2023 return connectedPars ;
2033 if (!stripDisconnected) return ;
2034 if (!nset || nset->
empty()) return ;
2042 for (
auto param : *params) {
2043 bool anyDep(
false) ;
2044 for (
auto term : plist) {
2045 if (term->dependsOnValue(*param)) {
2050 tostrip.
add(*param) ;
2054 if (!tostrip.
empty()) {
2055 params->
remove(tostrip,
true,
true);
2092 for (
auto const* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
2093 if (std::list<double>* hint = pdf->plotSamplingHint(obs,xlo,xhi)) {
2108 for (
auto const* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
2109 if (pdf->dependsOn(obs) && !pdf->isBinnedDistribution(obs)) {
2127 for (
auto const* pdf : static_range_cast<RooAbsPdf*>(
_pdfList)) {
2128 if (std::list<double>* hint = pdf->binBoundaries(obs,xlo,xhi)) {
2146 if (parg->canNodeBeCached()==
Always) {
2147 trackNodes.
add(*parg) ;
2154 if (
string(
"nset")==pdf_nset->GetName() && !pdf_nset->empty()) {
2155 parg->setStringAttribute(
"CATNormSet",getColonSeparatedNameString(*pdf_nset).c_str()) ;
2157 if (
string(
"cset")==pdf_nset->GetName()) {
2158 parg->setStringAttribute(
"CATCondSet",getColonSeparatedNameString(*pdf_nset).c_str()) ;
2161 coutW(Optimization) <<
"RooProdPdf::setCacheAndTrackHints(" <<
GetName() <<
") WARNING product pdf does not specify a normalization set for component " << parg->GetName() << endl ;
2176 if (i>0) os <<
" * " ;
2180 if (
string(
"nset")==ncset->
GetName()) {
2185 for (
auto const* arg : *ncset) {
2191 os << arg->GetName() ;
2208 cxcoutD(LinkStateMgmt) <<
"RooProdPdf::redirectServersHook(" <<
GetName() <<
"): removing REMOVAL_DUMMY" << endl ;
2223 for(std::unique_ptr<RooArgSet>
const& normSet :
_pdfNSetList) {
2228 normSet->releaseOwnership();
2229 normSet->replace(*std::unique_ptr<RooAbsArg>{arg}, *newArg->cloneTree());
2230 normSet->takeOwnership();
2240 os <<
"_partList\n";
2241 os << getColonSeparatedNameString(_partList) <<
"\n";
2243 os << getColonSeparatedNameString(_numList) <<
"\n";
2245 os << getColonSeparatedNameString(_denList) <<
"\n";
2246 os <<
"_ownedList\n";
2247 os << getColonSeparatedNameString(_ownedList) <<
"\n";
2248 os <<
"_normList\n";
2249 for(
auto const& set : _normList) {
2250 os << getColonSeparatedNameString(*set) <<
"\n";
2252 os <<
"_isRearranged" <<
"\n";
2253 os << _isRearranged <<
"\n";
2254 os <<
"_rearrangedNum" <<
"\n";
2255 if(_rearrangedNum) {
2256 os << getColonSeparatedNameString(*_rearrangedNum) <<
"\n";
2258 os <<
"nullptr" <<
"\n";
2260 os <<
"_rearrangedDen" <<
"\n";
2261 if(_rearrangedDen) {
2262 os << getColonSeparatedNameString(*_rearrangedDen) <<
"\n";
2264 os <<
"nullptr" <<
"\n";
2270 if (normSet.
empty())
2273 if (pdfNset && !pdfNset->empty()) {
2274 std::unique_ptr<RooArgSet> out;
2275 if (0 == strcmp(
"cset", pdfNset->GetName())) {
2279 out = std::make_unique<RooArgSet>(normSet);
2282 out->remove(common);
2284 out = std::make_unique<RooArgSet>(*pdfNset);
2289 if (!arg->getStringAttribute(
"__prefix__")) {
2290 arg->SetName((std::string(prefix) + arg->GetName()).c_str());
2291 arg->setStringAttribute(
"__prefix__", prefix);
2309 _servers(
"!servers",
"List of servers", this), _prodPdf{std::move(prodPdf)}
2315 _servers(
"!servers",
"List of servers", this), _prodPdf{static_cast<
RooProdPdf *>(other._prodPdf->
Clone())}
2328 _prodPdf->calculateBatch(*_cache, stream,
output, nEvents, dataMap);
2337 const char *rangeName =
nullptr)
const override
2339 return _prodPdf->getAnalyticalIntegralWN(allVars, analVars, normSet, rangeName);
2343 return _prodPdf->getAnalyticalIntegral(allVars, numVars, rangeName);
2347 return _prodPdf->analyticalIntegralWN(code, normSet, rangeName);
2351 return _prodPdf->analyticalIntegral(code, rangeName);
2357 _cache = _prodPdf->createCacheElem(&
_normSet,
nullptr);
2358 auto &cache = *_cache;
2363 if (cache._isRearranged) {
2364 _servers.add(*cache._rearrangedNum);
2365 _servers.add(*cache._rearrangedDen);
2367 for (std::size_t i = 0; i < cache._partList.size(); ++i) {
2368 _servers.add(cache._partList[i]);
2373 double evaluate()
const override {
return _prodPdf->calculate(*_cache); }
2376 std::unique_ptr<RooProdPdf::CacheElem>
_cache;
2381std::unique_ptr<RooAbsArg>
2384 std::unique_ptr<RooProdPdf> prodPdfClone{
static_cast<RooProdPdf *
>(this->
Clone())};
2388 for (
const auto server : prodPdfClone->servers()) {
2390 RooArgSet const &nset = nsetForServer ? *nsetForServer : normSet;
2393 server->getObservables(&nset, *depList);
2395 if (
auto serverClone = ctx.
compile(*server, *prodPdfClone, *depList)) {
2396 serverClones.
add(*serverClone);
2399 prodPdfClone->redirectServers(serverClones,
false,
true);
2401 auto fixedProdPdf = std::make_unique<RooFixedProdPdf>(std::move(prodPdfClone), normSet);
2402 fixedProdPdf->setAttribute(
"_COMPILED");
2404 return fixedProdPdf;
static void indent(ostringstream &buf, int indent_level)
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
const std::vector< Int_t > & retrieve(Int_t masterCode) const
Retrieve the array of integer codes associated with the given master code.
Int_t store(const std::vector< Int_t > &codeList, RooArgSet *set1=nullptr, RooArgSet *set2=nullptr, RooArgSet *set3=nullptr, RooArgSet *set4=nullptr)
Store given arrays of integer codes, and up to four RooArgSets in the registry (each setX pointer may...
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
RooExpensiveObjectCache & expensiveObjectCache() const
bool dependsOn(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=nullptr, bool valueOnly=false) const
Test whether we depend on (ie, are served by) any object in the specified collection.
void setOperMode(OperMode mode, bool recurseADirty=true)
Set the operation mode of this node.
void setStringAttribute(const Text_t *key, const Text_t *value)
Associate string 'value' to this object under key 'key'.
RooFit::OwningPtr< RooArgSet > getParameters(const RooAbsData *data, bool stripDisconnected=true) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
virtual void setExpensiveObjectCache(RooExpensiveObjectCache &cache)
bool addOwnedComponents(const RooAbsCollection &comps)
Take ownership of the contents of 'comps'.
const Text_t * getStringAttribute(const Text_t *key) const
Get string attribute mapped under key 'key'.
friend class RooRealIntegral
RooFit::OwningPtr< RooArgSet > getComponents() const
Create a RooArgSet with all components (branch nodes) of the expression tree headed by this object.
void setAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
TObject * Clone(const char *newname=nullptr) const override
Make a clone of an object using the Streamer facility.
void treeNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool doBranch=true, bool doLeaf=true, bool valueOnly=false, bool recurseNonDerived=false) const
Fill supplied list with nodes of the arg tree, following all server links, starting with ourself as t...
RooAbsArg * findNewServer(const RooAbsCollection &newSet, bool nameChange) const
Find the new server in the specified set that matches the old server.
OperMode operMode() const
Query the operation mode of this node.
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
Storage_t const & get() const
Const access to the underlying stl container.
bool contains(const RooAbsArg &var) const
Check if collection contains an argument with the same name as var.
void printValue(std::ostream &os) const override
Print value of collection, i.e.
Int_t getSize() const
Return the number of elements in the collection.
const char * GetName() const override
Returns name of object.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
Int_t index(const RooAbsArg *arg) const
Returns index of given arg, or -1 if arg is not in the collection.
bool overlaps(Iterator_t otherCollBegin, Iterator_t otherCollEnd) const
Storage_t::size_type size() const
RooAbsArg * first() const
bool selectCommon(const RooAbsCollection &refColl, RooAbsCollection &outColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
RooAbsArg * find(const char *name) const
Find object with given name in list.
RooAbsGenContext is the abstract base class for generator contexts of RooAbsPdf objects.
TString _normRange
Normalization range.
virtual bool isDirectGenSafe(const RooAbsArg &arg) const
Check if given observable can be safely generated using the pdfs internal generator mechanism (if tha...
RooArgSet const * _normSet
Normalization integral (owned by _normMgr)
bool canBeExtended() const
If true, PDF can provide extended likelihood term.
const char * normRange() const
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursiveStep) override
The cache manager.
virtual RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=nullptr, const RooArgSet *auxProto=nullptr, bool verbose=false) const
Interface function to create a generator context from a p.d.f.
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
RooFit::OwningPtr< RooAbsReal > createIntegral(const RooArgSet &iset, const RooCmdArg &arg1, const RooCmdArg &arg2=RooCmdArg::none(), const RooCmdArg &arg3=RooCmdArg::none(), const RooCmdArg &arg4=RooCmdArg::none(), const RooCmdArg &arg5=RooCmdArg::none(), const RooCmdArg &arg6=RooCmdArg::none(), const RooCmdArg &arg7=RooCmdArg::none(), const RooCmdArg &arg8=RooCmdArg::none()) const
Create an object that represents the integral of the function over one or more observables std::liste...
bool _forceNumInt
Force numerical integration if flag set.
TString integralNameSuffix(const RooArgSet &iset, const RooArgSet *nset=nullptr, const char *rangeName=nullptr, bool omitEmpty=false) const
Construct std::string with unique suffix name to give to integral object that encodes integrated obse...
RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
const RooArgList & list1() const
RooArgList is a container object that can hold multiple RooAbsArg objects.
RooAbsArg * at(Int_t idx) const
Return object at given index, or nullptr if index is out of range.
RooArgSet is a container object that can hold multiple RooAbsArg objects.
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Int_t setObj(const RooArgSet *nset, T *obj, const TNamed *isetRangeName=nullptr)
Setter function without integration set.
RooArgSet selectFromSet1(RooArgSet const &argSet, int index) const
Create RooArgSet contatining the objects that are both in the cached set 1.
T * getObjByIndex(Int_t index) const
Retrieve payload object by slot index.
RooArgSet selectFromSet2(RooArgSet const &argSet, int index) const
Create RooArgSet contatining the objects that are both in the cached set 2.
void reset()
Clear the cache.
Int_t lastIndex() const
Return index of slot used in last get or set operation.
T * getObj(const RooArgSet *nset, Int_t *sterileIndex=nullptr, const TNamed *isetRangeName=nullptr)
Getter function without integration set.
RooCmdArg is a named container for two doubles, two integers two object points and three string point...
bool add(const RooAbsArg &var, bool valueServer, bool shapeServer, bool silent)
Overloaded RooCollection_t::add() method insert object into set and registers object as server to own...
bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false) override
Remove object 'var' from set and deregister 'var' as server to owner.
TObject * clone(const char *newname) const override
RooCustomizer is a factory class to produce clones of a prototype composite PDF object with the same ...
void replaceArg(const RooAbsArg &orig, const RooAbsArg &subst)
Replace any occurence of arg 'orig' with arg 'subst'.
RooAbsArg * build(const char *masterCatState, bool verbose=false)
Build a clone of the prototype executing all registered 'replace' rules and 'split' rules for the mas...
RooDataSet is a container class to hold unbinned data.
T * compile(T &arg, RooAbsArg &owner, RooArgSet const &normSet)
auto & at(RooAbsArg const *arg, RooAbsArg const *=nullptr)
A RooProdPdf with a fixed normalization set can be replaced by this class.
std::unique_ptr< RooProdPdf::CacheElem > _cache
void computeBatch(cudaStream_t *stream, double *output, size_t nEvents, RooFit::Detail::DataMap const &dataMap) const override
Base function for computing multiple values of a RooAbsReal.
RooFixedProdPdf(const RooFixedProdPdf &other, const char *name=nullptr)
RooFixedProdPdf(std::unique_ptr< RooProdPdf > &&prodPdf, RooArgSet const &normSet)
double analyticalIntegral(Int_t code, const char *rangeName=nullptr) const override
Implements the actual analytical integral(s) advertised by getAnalyticalIntegral.
bool selfNormalized() const override
Shows if a PDF is self-normalized, which means that no attempt is made to add a normalization term.
Int_t getAnalyticalIntegral(RooArgSet &allVars, RooArgSet &numVars, const char *rangeName=nullptr) const override
Interface function getAnalyticalIntergral advertises the analytical integrals that are supported.
Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &analVars, const RooArgSet *normSet, const char *rangeName=nullptr) const override
Variant of getAnalyticalIntegral that is also passed the normalization set that should be applied to ...
TObject * clone(const char *newname) const override
double evaluate() const override
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
std::unique_ptr< RooProdPdf > _prodPdf
double expectedEvents(const RooArgSet *) const override
Return expected number of events to be used in calculation of extended likelihood.
bool canComputeBatchWithCuda() const override
bool forceAnalyticalInt(const RooAbsArg &dep) const override
double analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName) const override
Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further informatio...
ExtendMode extendMode() const override
Returns ability of PDF to provide extended likelihood terms.
General form of projected integral of product of PDFs, utility class for RooProdPdf.
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
TObject * At(int index) const
Return object stored in sequential position given by index.
RooLinkedListIterImpl end() const
void Delete(Option_t *o=nullptr) override
Remove all elements in collection and delete all elements NB: Collection does not own elements,...
virtual void Add(TObject *arg)
RooLinkedListIterImpl begin() const
Int_t IndexOf(const char *name) const
Return position of given object in list.
static const char * str(const TNamed *ptr)
Return C++ string corresponding to given TNamed pointer.
static const TNamed * ptr(const char *stringPtr)
Return a unique TNamed pointer for given C++ string.
RooArgList containedArgs(Action) override
Return RooAbsArg components contained in the cache.
std::unique_ptr< RooAbsReal > _rearrangedNum
void printCompactTreeHook(std::ostream &, const char *, Int_t, Int_t) override
Hook function to print cache contents in tree printing of RooProdPdf.
std::vector< std::unique_ptr< RooArgSet > > _normList
std::unique_ptr< RooAbsReal > _rearrangedDen
void writeToStream(std::ostream &os) const
RooProdPdf is an efficient implementation of a product of PDFs of the form.
void setCacheAndTrackHints(RooArgSet &) override
Label OK'ed components of a RooProdPdf with cache-and-track, and label all RooProdPdf descendants wit...
Int_t getGenerator(const RooArgSet &directVars, RooArgSet &generateVars, bool staticInitOK=true) const override
Query internal generation capabilities of component p.d.f.s and aggregate capabilities into master co...
void rearrangeProduct(CacheElem &) const
void factorizeProduct(const RooArgSet &normSet, const RooArgSet &intSet, RooLinkedList &termList, RooLinkedList &normList, RooLinkedList &impDepList, RooLinkedList &crossDepList, RooLinkedList &intList) const
Factorize product in irreducible terms for given choice of integration/normalization.
double analyticalIntegralWN(Int_t code, const RooArgSet *normSet, const char *rangeName=nullptr) const override
Return analytical integral defined by given scenario code.
RooArgSet * getConstraints(const RooArgSet &observables, RooArgSet &constrainedParams, bool stripDisconnected, bool removeConstraintsFromPdf=false) const override
Return all parameter constraint p.d.f.s on parameters listed in constrainedParams.
~RooProdPdf() override
Destructor.
Int_t _extendedIndex
Index of extended PDF (if any)
std::unique_ptr< RooAbsReal > specializeRatio(RooFormulaVar &input, const char *targetRangeName) const
RooProdPdf()
Default constructor.
void removePdfs(RooAbsCollection const &pdfs)
Remove some PDFs from the factors of this RooProdPdf.
bool _useDefaultGen
Use default or distributed event generator.
std::vector< std::unique_ptr< RooArgSet > > _pdfNSetList
List of PDF component normalization sets.
std::unique_ptr< RooArgSet > fillNormSetForServer(RooArgSet const &normSet, RooAbsArg const &server) const
std::unique_ptr< RooAbsReal > specializeIntegral(RooAbsReal &orig, const char *targetRangeName) const
bool forceAnalyticalInt(const RooAbsArg &dep) const override
Force RooRealIntegral to offer all observables for internal integration.
void calculateBatch(const RooProdPdf::CacheElem &cache, cudaStream_t *, double *output, size_t nEvents, RooFit::Detail::DataMap const &) const
Evaluate product of PDFs in batch mode.
std::unique_ptr< RooAbsArg > compileForNormSet(RooArgSet const &normSet, RooFit::Detail::CompileContext &ctx) const override
void getParametersHook(const RooArgSet *, RooArgSet *, bool stripDisconnected) const override
RooAbsGenContext * genContext(const RooArgSet &vars, const RooDataSet *prototype=nullptr, const RooArgSet *auxProto=nullptr, bool verbose=false) const override
Return generator context optimized for generating events from product p.d.f.s.
TNamed * _refRangeName
Reference range name for interpretation of conditional products.
RooAICRegistry _genCode
! Registry of composite direct generator codes
void addPdfs(RooAbsCollection const &pdfs)
Add some full PDFs to the factors of this RooProdPdf.
RooListProxy _pdfList
List of PDF components.
Int_t getPartIntList(const RooArgSet *nset, const RooArgSet *iset, const char *isetRangeName=nullptr) const
Return list of (partial) integrals of product terms for integration of p.d.f over observables iset wh...
void printMetaArgs(std::ostream &os) const override
Customized printing of arguments of a RooProdPdf to more intuitively reflect the contents of the prod...
std::list< double > * binBoundaries(RooAbsRealLValue &, double, double) const override
Forward the plot sampling hint from the p.d.f. that defines the observable obs.
RooObjCacheManager _cacheMgr
std::string makeRGPPName(const char *pfx, const RooArgSet &term, const RooArgSet &iset, const RooArgSet &nset, const char *isetRangeName) const
Make an appropriate automatic name for a RooGenProdProj object in getPartIntList()
bool isDirectGenSafe(const RooAbsArg &arg) const override
Forward determination of safety of internal generator code to component p.d.f that would generate the...
std::unique_ptr< RooAbsReal > makeCondPdfRatioCorr(RooAbsReal &term, const RooArgSet &termNset, const RooArgSet &termImpSet, const char *normRange, const char *refRange) const
For single normalization ranges.
RooArgSet * findPdfNSet(RooAbsPdf const &pdf) const
Look up user specified normalization set for given input PDF component.
ExtendMode extendMode() const override
If this product contains exactly one extendable p.d.f return the extension abilities of that p....
std::list< double > * plotSamplingHint(RooAbsRealLValue &obs, double xlo, double xhi) const override
Forward the plot sampling hint from the p.d.f. that defines the observable obs.
double expectedEvents(const RooArgSet *nset) const override
Return the expected number of events associated with the extendable input PDF in the product.
std::vector< RooAbsReal * > processProductTerm(const RooArgSet *nset, const RooArgSet *iset, const char *isetRangeName, const RooArgSet *term, const RooArgSet &termNSet, const RooArgSet &termISet, bool &isOwned, bool forceWrap=false) const
Calculate integrals of factorized product terms over observables iset while normalized to observables...
Int_t getAnalyticalIntegralWN(RooArgSet &allVars, RooArgSet &numVars, const RooArgSet *normSet, const char *rangeName=nullptr) const override
Determine which part (if any) of given integral can be performed analytically.
friend class RooFixedProdPdf
bool isBinnedDistribution(const RooArgSet &obs) const override
If all components that depend on obs are binned that so is the product.
friend class RooProdGenContext
RooArgSet * getConnectedParameters(const RooArgSet &observables) const
Return all parameter constraint p.d.f.s on parameters listed in constrainedParams.
double calculate(const RooProdPdf::CacheElem &cache, bool verbose=false) const
Calculate running product of pdfs terms, using the supplied normalization set in 'normSetList' for ea...
RooArgSet _defNormSet
Default normalization set.
CacheElem * getCacheElem(RooArgSet const *nset) const
The cache manager.
bool redirectServersHook(const RooAbsCollection &, bool, bool, bool) override
Implement support for node removal.
void initGenerator(Int_t code) override
Forward one-time initialization call to component generation initialization methods.
void generateEvent(Int_t code) override
Generate a single event with configuration specified by 'code' Defer internal generation to component...
void groupProductTerms(std::list< std::vector< RooArgSet * > > &groupedTerms, RooArgSet &outerIntDeps, const RooLinkedList &terms, const RooLinkedList &norms, const RooLinkedList &imps, const RooLinkedList &ints, const RooLinkedList &cross) const
Group product into terms that can be calculated independently.
void fixRefRange(const char *rangeName)
std::unique_ptr< CacheElem > createCacheElem(const RooArgSet *nset, const RooArgSet *iset, const char *isetRangeName=nullptr) const
double evaluate() const override
Calculate current value of object.
void initializeFromCmdArgList(const RooArgSet &fullPdfSet, const RooLinkedList &l)
Initialize RooProdPdf configuration from given list of RooCmdArg configuration arguments and set of '...
void selectNormalizationRange(const char *rangeName=nullptr, bool force=false) override
Interface function used by test statistics to freeze choice of range for interpretation of conditiona...
double _cutOff
Cutoff parameter for running product.
A RooProduct represents the product of a given set of RooAbsReal objects.
RooRealIntegral performs hybrid numerical/analytical integrals of RooAbsReal objects.
RooArgSet intVars() const
const RooAbsReal & integrand() const
const char * intRange() const
The TNamed class is the base class for all named ROOT classes.
const char * GetName() const override
Returns name of object.
const char * GetTitle() const override
Returns title of object.
Mother of all ROOT objects.
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
const char * Data() const
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
RooConstVar & RooConst(double val)
std::vector< RooSpan< const double > > VarVector
R__EXTERN RooBatchComputeInterface * dispatchCUDA
R__EXTERN RooBatchComputeInterface * dispatchCPU
This dispatch pointer points to an implementation of the compute library, provided one has been loade...
std::vector< double > ArgVector
std::string getColonSeparatedNameString(RooArgSet const &argSet)
Create a string with all sorted names of RooArgSet elements separated by colons.