diff --git a/roofit/roofitcore/inc/RooHistPdf.h b/roofit/roofitcore/inc/RooHistPdf.h index 2ca27da4e22cf..fca7be4daa530 100644 --- a/roofit/roofitcore/inc/RooHistPdf.h +++ b/roofit/roofitcore/inc/RooHistPdf.h @@ -22,6 +22,7 @@ #include "RooDataHist.h" #include +#include class RooRealVar; class RooAbsReal; @@ -145,6 +146,10 @@ class RooHistPdf : public RooAbsPdf { double xlo, double xhi); + static std::vector histogramBoundariesInPlotObs(RooDataHist const &dataHist, RooArgSet const &pdfObsList, + RooArgSet const &histObsList, RooAbsRealLValue &obs, + double xlo, double xhi); + inline void initializeOwnedDataHist(std::unique_ptr &&dataHist) { // The constructor may already have taken ownership of a sanitized clone diff --git a/roofit/roofitcore/src/RooBinIntegrator.cxx b/roofit/roofitcore/src/RooBinIntegrator.cxx index 1a86b2899389c..a94d647ce8249 100644 --- a/roofit/roofitcore/src/RooBinIntegrator.cxx +++ b/roofit/roofitcore/src/RooBinIntegrator.cxx @@ -83,18 +83,35 @@ RooBinIntegrator::RooBinIntegrator(const RooAbsFunc &function, int numBins) for (UInt_t i=0 ; i<_function->getDimension() ; i++) { _xmin[i]= _function->getMinLimit(i); _xmax[i]= _function->getMaxLimit(i); + } + updateBinBoundaries(/*warnIfNoBinning=*/true); + checkLimits(); + +} + + +//////////////////////////////////////////////////////////////////////////////// +/// Retrieve the bin boundaries from the integrand. They can depend on the +/// parameters, e.g. for a RooHistPdf whose observable is a shifted variable, +/// so this is done for each integral. - // Retrieve bin configuration from integrand +void RooBinIntegrator::updateBinBoundaries(bool warnIfNoBinning) +{ + _binb.resize(_function->getDimension()); + for (UInt_t i=0 ; i<_function->getDimension() ; i++) { std::unique_ptr> tmp{ _function->binBoundaries(i) }; if (!tmp) { - oocoutW(nullptr,Integration) << "RooBinIntegrator::RooBinIntegrator WARNING: integrand provide no binning definition observable #" - << i << " substituting default binning of " << _numBins << " bins" << std::endl ; + if (warnIfNoBinning) { + oocoutW(nullptr,Integration) << "RooBinIntegrator::RooBinIntegrator WARNING: integrand provide no binning definition observable #" + << i << " substituting default binning of " << _numBins << " bins" << std::endl ; + } tmp = std::make_unique>( ); for (Int_t j=0 ; j<=_numBins ; j++) { tmp->push_back(_xmin[i]+j*(_xmax[i]-_xmin[i])/_numBins) ; } } - std::vector binb{tmp->begin(), tmp->end()}; + std::vector &binb = _binb[i]; + binb.assign(tmp->begin(), tmp->end()); // The bin boundaries provided by the integrand only include the boundaries // that lie strictly inside the integration range. To integrate correctly @@ -106,11 +123,7 @@ RooBinIntegrator::RooBinIntegrator(const RooAbsFunc &function, int numBins) if (binb.back() < _xmax[i]) { binb.push_back(_xmax[i]); } - _binb.emplace_back(std::move(binb)); - } - checkLimits(); - } @@ -177,6 +190,8 @@ double RooBinIntegrator::integral(const double *) assert(isValid()); if (_function->getDimension() < 1) return 0.; + updateBinBoundaries(/*warnIfNoBinning=*/false); + ROOT::Math::KahanSum sum; recursive_integration(0,1.,sum); diff --git a/roofit/roofitcore/src/RooBinIntegrator.h b/roofit/roofitcore/src/RooBinIntegrator.h index 83687f66a8422..a639dabd4cb00 100644 --- a/roofit/roofitcore/src/RooBinIntegrator.h +++ b/roofit/roofitcore/src/RooBinIntegrator.h @@ -54,6 +54,7 @@ class RooBinIntegrator : public RooAbsIntegrator { bool _useIntegrandLimits = false; ///< If true limits of function binding are used + void updateBinBoundaries(bool warnIfNoBinning); void recursive_integration(const UInt_t d, const double delta, ROOT::Math::KahanSum& sum); std::vector _x; ///* RooHistFunc::plotSamplingHint(RooAbsRealLValue& obs, double x return RooHistPdf::plotSamplingHint(*_dataHist, _depList, _histObsList, _intOrder, obs, xlo, xhi); } - //////////////////////////////////////////////////////////////////////////////// -/// Return sampling hint for making curves of (projections) of this function -/// as the recursive division strategy of RooCurve cannot deal efficiently -/// with the vertical lines that occur in a non-interpolated histogram +/// Return the histogram bin boundaries mapped into the plot-observable +/// coordinate. Handles the case where the function observable is a +/// transformation (shift, scale, ...) of the plot observable so that the +/// returned boundaries are placed at the correct positions in the plot. std::list* RooHistFunc::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const { @@ -331,79 +331,21 @@ std::list* RooHistFunc::binBoundaries(RooAbsRealLValue& obs, double xlo, return nullptr ; } - // Find histogram observable corresponding to pdf observable - RooAbsArg* hobs(nullptr) ; - for (auto i = 0u; i < _histObsList.size(); ++i) { - const auto harg = _histObsList[i]; - const auto parg = _depList[i]; - if (std::string(parg->GetName())==obs.GetName()) { - hobs=harg ; - } + const std::vector boundaries = + RooHistPdf::histogramBoundariesInPlotObs(*_dataHist, _depList, _histObsList, obs, xlo, xhi); + if (boundaries.empty()) { + return nullptr; } - RooAbsRealLValue* transform = nullptr; - if (!hobs) { - - // Considering alternate: input observable is histogram observable and pdf observable is transformation in terms of it - RooAbsArg* pobs = nullptr; - for (auto i = 0u; i < _histObsList.size(); ++i) { - const auto harg = _histObsList[i]; - const auto parg = _depList[i]; - if (std::string(harg->GetName())==obs.GetName()) { - pobs=parg ; - hobs=harg ; - } - } - - // Not found, or check that matching pdf observable is an l-value dependent on histogram observable fails - if (!hobs || !(pobs->dependsOn(obs) && dynamic_cast(pobs))) { - std::cout << "RooHistFunc::binBoundaries(" << GetName() << ") obs = " << obs.GetName() << " hobs is not found, returning null" << std::endl ; - return nullptr ; - } - - // Now we are in business - we are in a situation where the pdf observable LV(x), mapping to a histogram observable x - // We can return bin boundaries by mapping the histogram boundaties through the inverse of the LV(x) transformation - transform = dynamic_cast(pobs) ; - } - - - // Check that observable is in dataset, if not no hint is generated - RooAbsArg* xtmp = _dataHist->get()->find(hobs->GetName()) ; - if (!xtmp) { - std::cout << "RooHistFunc::binBoundaries(" << GetName() << ") hobs = " << hobs->GetName() << " is not found in dataset?" << std::endl ; - _dataHist->get()->Print("v") ; - return nullptr ; - } - RooAbsLValue* lvarg = dynamic_cast(_dataHist->get()->find(hobs->GetName())) ; - if (!lvarg) { - std::cout << "RooHistFunc::binBoundaries(" << GetName() << ") hobs = " << hobs->GetName() << " but is not an LV, returning null" << std::endl ; - return nullptr ; - } - - // Retrieve position of all bin boundaries - const RooAbsBinning* binning = lvarg->getBinningPtr(nullptr); - double* boundaries = binning->array() ; - - auto hint = new std::list ; - - double delta = (xhi-xlo)*1e-8 ; - - // Construct array with pairs of points positioned epsilon to the left and - // right of the bin boundaries - for (Int_t i=0 ; inumBoundaries() ; i++) { - if (boundaries[i]>xlo-delta && boundaries[i]setVal(boundary) ; - hint->push_back(obs.getVal()) ; - } else { - hint->push_back(boundary) ; - } - } + auto hint = new std::list; + const double delta = (xhi - xlo) * 1e-8; + for (double b : boundaries) { + if (b > xlo - delta && b < xhi + delta) { + hint->push_back(b); + } } - return hint ; + return hint; } diff --git a/roofit/roofitcore/src/RooHistPdf.cxx b/roofit/roofitcore/src/RooHistPdf.cxx index 1802cb426ad01..2f8438e4848eb 100644 --- a/roofit/roofitcore/src/RooHistPdf.cxx +++ b/roofit/roofitcore/src/RooHistPdf.cxx @@ -471,6 +471,112 @@ bool RooHistPdf::forceAnalyticalInt(const RooAbsArg& dep) const return forceAnalyticalInt(_pdfObsList, dep); } +//////////////////////////////////////////////////////////////////////////////// +/// Return the histogram bin boundaries mapped to the coordinates of the plot +/// observable `obs`. This handles the case where the p.d.f. observable is a +/// transformation of the plot observable (for example a shift like +/// `x_shifted = x - shift`), so that the returned boundaries are the positions +/// of the histogram bin edges as they appear when the p.d.f. is plotted as a +/// function of `obs`. +/// +/// Returns an empty vector if no corresponding histogram observable can be +/// located, or if a non-invertible transformation is detected. + +std::vector RooHistPdf::histogramBoundariesInPlotObs(RooDataHist const &dataHist, RooArgSet const &pdfObsList, + RooArgSet const &histObsList, RooAbsRealLValue &obs, + double xlo, double xhi) +{ + std::vector result; + + // The histogram observable for `obs` belongs to the p.d.f. observable with + // the same name, or else to the first one that is a function of `obs`. + RooAbsArg *histObs = nullptr; + RooAbsArg *pdfObs = nullptr; + bool useTransform = false; + for (unsigned int i = 0; i < pdfObsList.size(); ++i) { + if (std::string(obs.GetName()) == pdfObsList[i]->GetName()) { + histObs = histObsList[i]; + break; + } + } + if (!histObs) { + for (unsigned int i = 0; i < pdfObsList.size(); ++i) { + auto *po = dynamic_cast(pdfObsList[i]); + if (po && po->dependsOn(obs)) { + histObs = histObsList[i]; + pdfObs = pdfObsList[i]; + useTransform = true; + break; + } + } + } + if (!histObs) { + return result; + } + + auto *lval = dynamic_cast(dataHist.get()->find(histObs->GetName())); + if (!lval) { + return result; + } + + const RooAbsBinning *binning = lval->getBinningPtr(nullptr); + const int nBoundaries = binning->numBoundaries(); + const double *rawBoundaries = binning->array(); + + if (!useTransform) { + result.assign(rawBoundaries, rawBoundaries + nBoundaries); + return result; + } + + // Invert `pdfObs = T(obs)` with a linear approximation of `T` on the plot + // range, which is exact for linear transformations. Inverting with the + // setVal() of an l-value like RooLinearVar would throw for boundaries that + // map outside the range of `obs`. + auto *pdfObsReal = static_cast(pdfObs); + const double probeLo = std::max(xlo, obs.getMin()); + const double probeHi = std::min(xhi, obs.getMax()); + if (probeHi > probeLo) { + // Restore `obs` with assign(), because setVal() throws if an outer + // integral has set it outside of its default range. + RooArgSet obsLeaves; + obs.leafNodeServerList(&obsLeaves); + RooArgSet obsSaved; + obsLeaves.snapshot(obsSaved, false); + auto evalAt = [&](double val) { + obs.setVal(val); + return pdfObsReal->getVal(); + }; + const double probeMid = 0.5 * (probeLo + probeHi); + const double plo = evalAt(probeLo); + const double phi = evalAt(probeHi); + const double pmid = evalAt(probeMid); + obsLeaves.assign(obsSaved); + const double slope = (phi - plo) / (probeHi - probeLo); + + // The midpoint reveals non-linear transformations. + const double pmidLinear = plo + slope * (probeMid - probeLo); + const double scale = std::max(std::abs(plo), std::abs(phi)); + if (std::abs(pmid - pmidLinear) > 1e-7 * (scale > 0.0 ? scale : 1.0)) { + oocoutW(nullptr, Plotting) + << "RooHistPdf::histogramBoundariesInPlotObs: the histogram observable '" << pdfObsReal->GetName() + << "' appears to be a non-linear transformation of the plot observable '" << obs.GetName() + << "'. The bin boundaries used for plotting and integration are approximated assuming a linear " + "relation and may be placed incorrectly." + << std::endl; + } + + if (slope != 0.0) { + result.reserve(nBoundaries); + for (int i = 0; i < nBoundaries; ++i) { + result.push_back(probeLo + (rawBoundaries[i] - plo) / slope); + } + } + } + + // The transformation may reverse the order (negative slope). + std::sort(result.begin(), result.end()); + return result; +} //////////////////////////////////////////////////////////////////////////////// /// Return sampling hint for making curves of (projections) of this function @@ -496,40 +602,19 @@ std::list* RooHistPdf::plotSamplingHint(RooDataHist const& dataHist, return nullptr; } - // Check that observable is in dataset, if not no hint is generated - RooAbsArg* dhObs = nullptr; - for (unsigned int i=0; i < pdfObsList.size(); ++i) { - RooAbsArg* histObs = histObsList[i]; - RooAbsArg* pdfObs = pdfObsList[i]; - if (std::string(obs.GetName())==pdfObs->GetName()) { - dhObs = dataHist.get()->find(histObs->GetName()) ; - break; - } + const std::vector boundaries = histogramBoundariesInPlotObs(dataHist, pdfObsList, histObsList, obs, xlo, xhi); + if (boundaries.empty()) { + return nullptr; } - if (!dhObs) { - return nullptr; - } - RooAbsLValue* lval = dynamic_cast(dhObs) ; - if (!lval) { - return nullptr; - } - - // Retrieve position of all bin boundaries - - const RooAbsBinning* binning = lval->getBinningPtr(nullptr); - std::span boundaries{binning->array(), static_cast(binning->numBoundaries())}; - // Use the helper function from RooCurve to make sure to get sampling hints // that work with the RooFitPlotting. return RooCurve::plotSamplingHintForBinBoundaries(boundaries, xlo, xhi); } - //////////////////////////////////////////////////////////////////////////////// -/// Return sampling hint for making curves of (projections) of this function -/// as the recursive division strategy of RooCurve cannot deal efficiently -/// with the vertical lines that occur in a non-interpolated histogram +/// Return the histogram bin boundaries in the plot-observable coordinate, +/// used for example by the RooBinIntegrator and the binned likelihood. std::list* RooHistPdf::binBoundaries(RooAbsRealLValue& obs, double xlo, double xhi) const { @@ -538,35 +623,20 @@ std::list* RooHistPdf::binBoundaries(RooAbsRealLValue& obs, double xlo, return nullptr; } - // Check that observable is in dataset, if not no hint is generated. The pdf - // observable can be named differently, e.g. when it was prefixed for a - // RooSimultaneous channel in the likelihood. - RooAbsArg *dhObs = _dataHist->get()->find(obs.GetName()); - for (unsigned int i = 0; !dhObs && i < _pdfObsList.size(); ++i) { - if (std::string(obs.GetName()) == _pdfObsList[i]->GetName()) { - dhObs = _dataHist->get()->find(_histObsList[i]->GetName()); - } - } - RooAbsLValue *lvarg = dynamic_cast(dhObs); - if (!lvarg) { - return nullptr ; + const std::vector boundaries = + histogramBoundariesInPlotObs(*_dataHist, _pdfObsList, _histObsList, obs, xlo, xhi); + if (boundaries.empty()) { + return nullptr; } - // Retrieve position of all bin boundaries - const RooAbsBinning* binning = lvarg->getBinningPtr(nullptr); - double* boundaries = binning->array() ; - - auto hint = new std::list ; - - // Construct array with pairs of points positioned epsilon to the left and - // right of the bin boundaries - for (Int_t i=0 ; inumBoundaries() ; i++) { - if (boundaries[i]>=xlo && boundaries[i]<=xhi) { - hint->push_back(boundaries[i]) ; - } + auto hint = new std::list; + for (double b : boundaries) { + if (b >= xlo && b <= xhi) { + hint->push_back(b); + } } - return hint ; + return hint; } diff --git a/roofit/roofitcore/test/testRooHistPdf.cxx b/roofit/roofitcore/test/testRooHistPdf.cxx index 7a25829fb0888..92245da6b006e 100644 --- a/roofit/roofitcore/test/testRooHistPdf.cxx +++ b/roofit/roofitcore/test/testRooHistPdf.cxx @@ -4,19 +4,25 @@ #include #include #include +#include #include +#include #include #include #include #include #include +#include + #include #include #include +#include #include #include +#include // Verify that RooFit correctly uses analytic integration when having a // RooLinearVar as the observable of a RooHistPdf. @@ -277,3 +283,166 @@ TEST(RooHistPdf, BinnedLikelihoodInSimultaneous) EXPECT_DOUBLE_EQ(nllSim->getVal(), nllA->getVal()); } + +namespace { + +// Takes ownership of a list returned by binBoundaries() or plotSamplingHint(). +std::vector toVector(std::list *list) +{ + std::unique_ptr> owned{list}; + if (!owned) { + return {}; + } + return {owned->begin(), owned->end()}; +} + +} // namespace + +// GitHub issue #13030: plotting a RooHistPdf whose observable is a +// transformation of the plot variable (e.g. a shift `x_shifted = x - shift`) +// produced visually broken curves because `binBoundaries` and +// `plotSamplingHint` returned the raw histogram boundaries in the histogram +// observable coordinate instead of the plot observable coordinate. +TEST(RooHistPdf, ShiftedBinBoundaries) +{ + using Vec = std::vector; + + RooRealVar x{"x", "x", 1000, 1500}; + x.setBins(5); // bin edges in x: 1000, 1100, 1200, 1300, 1400, 1500 + + RooRealVar shift{"shift", "shift", 25.0, -100, 100}; + + TH1D h{"h", "", x.numBins(), x.getMin(), x.getMax()}; + for (int i = 1; i <= h.GetNbinsX(); ++i) { + h.SetBinContent(i, 1.0); + } + RooDataHist dh{"dh", "", x, &h}; + + // pdfObs = x - shift as a RooFormulaVar (no l-value inverse). Hist bin + // boundary `b` satisfies `x - shift = b`, so plot_x = b + shift. + RooFormulaVar xShifted{"x_shifted", "x - shift", {x, shift}}; + RooHistPdf pdfF{"pdf_f", "", xShifted, x, dh, 0}; + EXPECT_EQ(toVector(pdfF.binBoundaries(x, 1000.0, 1600.0)), (Vec{1025, 1125, 1225, 1325, 1425, 1525})); + + // pdfObs = RooLinearVar x + shift -> plot_x = b - 25; only values inside [1000, 1500] kept. + RooRealVar slope{"slope", "slope", 1.0}; + RooLinearVar xShiftedLV{"x_shifted_lv", "", x, slope, shift}; + RooHistPdf pdfLV{"pdf_lv", "", RooArgList{xShiftedLV}, RooArgList{x}, dh, 0}; + EXPECT_EQ(toVector(pdfLV.binBoundaries(x, 1000.0, 1500.0)), (Vec{1075, 1175, 1275, 1375, 1475})); + + // Negative slope: plot_x = 2525 - b, still returned in increasing order. + RooFormulaVar xMirrored{"x_mirrored", "2525 - x", {x}}; + RooHistPdf pdfM{"pdf_m", "", xMirrored, x, dh, 0}; + EXPECT_EQ(toVector(pdfM.binBoundaries(x, 1000.0, 1500.0)), (Vec{1025, 1125, 1225, 1325, 1425})); + + // Identity (no transformation) keeps the raw boundaries. + RooHistPdf pdfId{"pdf_id", "", x, dh, 0}; + EXPECT_EQ(toVector(pdfId.binBoundaries(x, 1000.0, 1500.0)), (Vec{1000, 1100, 1200, 1300, 1400, 1500})); + + // RooHistFunc uses the same mapping. + RooHistFunc funcF{"func_f", "", RooArgList{xShifted}, RooArgList{x}, dh, 0}; + RooHistFunc funcLV{"func_lv", "", RooArgList{xShiftedLV}, RooArgList{x}, dh, 0}; + EXPECT_EQ(toVector(funcF.binBoundaries(x, 1000.0, 1500.0)), (Vec{1025, 1125, 1225, 1325, 1425})); + EXPECT_EQ(toVector(funcLV.binBoundaries(x, 1000.0, 1500.0)), (Vec{1075, 1175, 1275, 1375, 1475})); + + // The sampling hint has a point next to each plot limit and a pair of + // points around each boundary inside the plot range. + const Vec hint = toVector(pdfF.plotSamplingHint(x, 1000.0, 1500.0)); + ASSERT_EQ(hint.size(), 12u); + for (std::size_t i = 0; i < 5; ++i) { + EXPECT_NEAR(0.5 * (hint[2 * i + 1] + hint[2 * i + 2]), 1025.0 + 100.0 * i, 1e-9); + } +} + +// The plot observable can hold a value outside of its default range, e.g. set +// by an outer integral over a wider range. Mapping the bin boundaries must +// restore that value without throwing. +TEST(RooHistPdf, ShiftedBinBoundariesKeepOutOfRangeValue) +{ + RooRealVar x{"x", "x", 1000, 1500}; + x.setBins(5); + x.setRange("wide", 0, 2000); + RooRealVar shift{"shift", "shift", 25.0, -100, 100}; + + RooDataHist dh{"dh", "", x}; + RooFormulaVar xShifted{"x_shifted", "x - shift", {x, shift}}; + RooHistPdf pdf{"pdf", "", xShifted, x, dh, 0}; + + x.setVal(500, "wide"); + ASSERT_EQ(x.getVal(), 500.0); + EXPECT_EQ(toVector(pdf.binBoundaries(x, 1000.0, 1500.0)), (std::vector{1025, 1125, 1225, 1325, 1425})); + EXPECT_EQ(x.getVal(), 500.0); +} + +// The numeric integral over a shifted RooHistPdf has to follow the shift. The +// RooBinIntegrator used to keep the bin boundaries of its first evaluation. +TEST(RooHistPdf, ShiftedIntegralFollowsShift) +{ + RooHelpers::LocalChangeMsgLevel changeMsgLvl(RooFit::WARNING); + + RooRealVar x{"x", "x", 1000, 1500}; + x.setBins(5); + RooRealVar shift{"shift", "shift", 25.0, -100, 100}; + + const double contents[]{1., 2., 4., 8., 16.}; + TH1D h{"h", "", x.numBins(), x.getMin(), x.getMax()}; + for (int i = 0; i < 5; ++i) { + h.SetBinContent(i + 1, contents[i]); + } + RooDataHist dh{"dh", "", x, &h}; + + RooFormulaVar xShifted{"x_shifted", "x - shift", {x, shift}}; + RooHistPdf pdf{"pdf", "", xShifted, x, dh, 0}; + + // Overlap of each shifted bin with [1000, 1500], times the bin density. + auto expected = [&](double s) { + double sum = 0.; + for (int i = 0; i < 5; ++i) { + const double lo = std::max(1000. + 100. * i + s, 1000.); + const double hi = std::min(1100. + 100. * i + s, 1500.); + sum += std::max(hi - lo, 0.) * contents[i] / 100.; + } + return sum; + }; + + std::unique_ptr integral{pdf.createIntegral(x)}; + for (double s : {25., -30., 0., 60.}) { + shift.setVal(s); + EXPECT_NEAR(integral->getVal(), expected(s), 1e-10) << "shift = " << s; + } +} + +// GitHub issue #13030: a non-linear transformation of the plot observable +// cannot be inverted exactly by the (linear) boundary-finding algorithm. In +// that case the boundaries are still returned, but only approximately, and the +// user must be warned that the plotted curve may be placed incorrectly. +TEST(RooHistPdf, NonLinearBinBoundariesWarn) +{ + RooRealVar x{"x", "x", 1.0, 5.0}; + x.setBins(4); + + TH1D h{"h", "", x.numBins(), x.getMin(), x.getMax()}; + for (int i = 1; i <= h.GetNbinsX(); ++i) { + h.SetBinContent(i, 1.0); + } + RooDataHist dh{"dh", "", x, &h}; + + // A genuinely non-linear transformation (not an l-value, so it goes through + // the linear-approximation path). + RooFormulaVar xSquared{"x_squared", "x * x", x}; + RooHistPdf pdf{"pdf_nl", "", xSquared, x, dh, 0}; + + std::unique_ptr> boundaries; + std::string msg; + { + RooHelpers::HijackMessageStream hijack{RooFit::WARNING, RooFit::Plotting}; + boundaries.reset(pdf.binBoundaries(x, x.getMin(), x.getMax())); + msg = hijack.str(); + } + + // Boundaries are still produced (approximately), and a warning was emitted. + ASSERT_TRUE(boundaries); + EXPECT_FALSE(boundaries->empty()); + EXPECT_TRUE(msg.find("non-linear") != std::string::npos) + << "Expected a non-linearity warning, but got: '" << msg << "'"; +}