Logo
Fully annotated reference manual - version 1.8.12
Loading...
Searching...
No Matches
reportwriter.cpp
Go to the documentation of this file.
1/*
2 Copyright (C) 2017 Quaternion Risk Management Ltd
3 Copyright (C) 2017 Aareal Bank AG
4
5 All rights reserved.
6
7 This file is part of ORE, a free-software/open-source library
8 for transparent pricing and risk analysis - http://opensourcerisk.org
9
10 ORE is free software: you can redistribute it and/or modify it
11 under the terms of the Modified BSD License. You should have received a
12 copy of the license along with this program.
13 The license is also available online at <http://opensourcerisk.org>
14
15 This program is distributed on the basis that it will form a useful
16 contribution to risk analytics and model standardisation, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
19*/
20
21#include <orea/app/reportwriter.hpp>
22#include <orea/app/structuredanalyticserror.hpp>
23#include <orea/simm/utilities.hpp>
24#include <orea/scenario/scenariowriter.hpp>
25
26#include <ored/utilities/marketdata.hpp>
27#include <ored/portfolio/structuredtradeerror.hpp>
28#include <ored/utilities/indexnametranslator.hpp>
29#include <ored/utilities/to_string.hpp>
30
31#include <qle/cashflows/cappedflooredaveragebmacoupon.hpp>
32#include <qle/cashflows/commodityindexedcashflow.hpp>
33#include <qle/cashflows/commodityindexedaveragecashflow.hpp>
34#include <qle/cashflows/averageonindexedcoupon.hpp>
35#include <qle/cashflows/fxlinkedcashflow.hpp>
36#include <qle/cashflows/overnightindexedcoupon.hpp>
37#include <qle/cashflows/indexedcoupon.hpp>
38#include <qle/cashflows/equitycoupon.hpp>
39#include <qle/currencies/currencycomparator.hpp>
40#include <qle/instruments/cashflowresults.hpp>
41#include <qle/cashflows/durationadjustedcmscoupon.hpp>
42
43#include <ql/cashflows/averagebmacoupon.hpp>
44#include <ql/cashflows/indexedcashflow.hpp>
45#include <ql/cashflows/inflationcoupon.hpp>
46#include <ql/errors.hpp>
47#include <ql/experimental/coupons/strippedcapflooredcoupon.hpp>
48
49#include <boost/accumulators/accumulators.hpp>
50#include <boost/accumulators/framework/accumulator_set.hpp>
51#include <boost/accumulators/statistics.hpp>
52#include <boost/accumulators/statistics/count.hpp>
53#include <boost/accumulators/statistics/covariance.hpp>
54#include <boost/accumulators/statistics/kurtosis.hpp>
55#include <boost/accumulators/statistics/max.hpp>
56#include <boost/accumulators/statistics/mean.hpp>
57#include <boost/accumulators/statistics/min.hpp>
58#include <boost/accumulators/statistics/skewness.hpp>
59#include <boost/accumulators/statistics/stats.hpp>
60#include <boost/accumulators/statistics/tail_quantile.hpp>
61#include <boost/accumulators/statistics/variates/covariate.hpp>
62#include <boost/lexical_cast.hpp>
63#include <boost/range/adaptor/indexed.hpp>
64
65#include <ostream>
66#include <stdio.h>
67
68using ore::data::to_string;
69using QuantLib::Date;
70using std::string;
71using std::vector;
72
73namespace ore {
74namespace analytics {
75
76typedef std::map<Currency, Matrix, CurrencyComparator> result_type_matrix;
77typedef std::map<Currency, std::vector<Real>, CurrencyComparator> result_type_vector;
78typedef std::map<Currency, Real, CurrencyComparator> result_type_scalar;
79
80void ReportWriter::writeNpv(ore::data::Report& report, const std::string& baseCurrency,
81 QuantLib::ext::shared_ptr<Market> market, const std::string& configuration,
82 QuantLib::ext::shared_ptr<Portfolio> portfolio) {
83 LOG("portfolio valuation");
84 DayCounter dc = ActualActual(ActualActual::ISDA);
85 Date today = Settings::instance().evaluationDate();
86 report.addColumn("TradeId", string())
87 .addColumn("TradeType", string())
88 .addColumn("Maturity", Date())
89 .addColumn("MaturityTime", double(), 6)
90 .addColumn("NPV", double(), 6)
91 .addColumn("NpvCurrency", string())
92 .addColumn("NPV(Base)", double(), 6)
93 .addColumn("BaseCurrency", string())
94 .addColumn("Notional", double(), 2)
95 .addColumn("NotionalCurrency", string())
96 .addColumn("Notional(Base)", double(), 2)
97 .addColumn("NettingSet", string())
98 .addColumn("CounterParty", string());
99 for (auto & [tradeId, trade] : portfolio->trades()) {
100 try {
101 string npvCcy = trade->npvCurrency();
102 Real fx = 1.0, fxNotional = 1.0;
103 if (npvCcy != baseCurrency)
104 fx = market->fxRate(npvCcy + baseCurrency, configuration)->value();
105 if (trade->notionalCurrency() != "" && trade->notionalCurrency() != baseCurrency)
106 fxNotional = market->fxRate(trade->notionalCurrency() + baseCurrency, configuration)->value();
107 Real npv = trade->instrument()->NPV();
108 QL_REQUIRE(std::isfinite(npv), "npv is not finite (" << npv << ")");
109 Date maturity = trade->maturity();
110 report.next()
111 .add(trade->id())
112 .add(trade->tradeType())
113 .add(maturity)
114 .add(maturity == QuantLib::Null<Date>() ? Null<Real>() : dc.yearFraction(today, maturity))
115 .add(npv)
116 .add(npvCcy)
117 .add(npv * fx)
118 .add(baseCurrency)
119 .add(trade->notional())
120 .add(trade->notionalCurrency() == "" ? nullString_ : trade->notionalCurrency())
121 .add(trade->notional() == Null<Real>() || trade->notionalCurrency() == ""
122 ? Null<Real>()
123 : trade->notional() * fxNotional)
124 .add(trade->envelope().nettingSetId())
125 .add(trade->envelope().counterparty());
126 } catch (std::exception& e) {
127 StructuredTradeErrorMessage(trade->id(), trade->tradeType(), "Error during trade pricing", e.what()).log();
128 Date maturity = trade->maturity();
129 report.next()
130 .add(trade->id())
131 .add(trade->tradeType())
132 .add(maturity)
133 .add(maturity == QuantLib::Null<Date>() ? Null<Real>() : dc.yearFraction(today, maturity))
134 .add(Null<Real>())
135 .add(nullString_)
136 .add(Null<Real>())
137 .add(nullString_)
138 .add(Null<Real>())
139 .add(nullString_)
140 .add(Null<Real>())
141 .add(nullString_)
142 .add(nullString_);
143 }
144 }
145 report.end();
146 LOG("NPV file written");
147}
148
149void ReportWriter::writeCashflow(ore::data::Report& report, const std::string& baseCurrency,
150 QuantLib::ext::shared_ptr<ore::data::Portfolio> portfolio,
151 QuantLib::ext::shared_ptr<ore::data::Market> market, const std::string& configuration,
152 const bool includePastCashflows) {
153
154 Date asof = Settings::instance().evaluationDate();
155
156 LOG("Writing cashflow report for " << asof);
157 report.addColumn("TradeId", string())
158 .addColumn("Type", string())
159 .addColumn("CashflowNo", Size())
160 .addColumn("LegNo", Size())
161 .addColumn("PayDate", Date())
162 .addColumn("FlowType", string())
163 .addColumn("Amount", double(), 4)
164 .addColumn("Currency", string())
165 .addColumn("Coupon", double(), 10)
166 .addColumn("Accrual", double(), 10)
167 .addColumn("AccrualStartDate", Date(), 4)
168 .addColumn("AccrualEndDate", Date(), 4)
169 .addColumn("AccruedAmount", double(), 4)
170 .addColumn("fixingDate", Date())
171 .addColumn("fixingValue", double(), 10)
172 .addColumn("Notional", double(), 4)
173 .addColumn("DiscountFactor", double(), 10)
174 .addColumn("PresentValue", double(), 10)
175 .addColumn("FXRate(Local-Base)", double(), 10)
176 .addColumn("PresentValue(Base)", double(), 10)
177 .addColumn("BaseCurrency", string())
178 .addColumn("FloorStrike", double(), 6)
179 .addColumn("CapStrike", double(), 6)
180 .addColumn("FloorVolatility", double(), 6)
181 .addColumn("CapVolatility", double(), 6)
182 .addColumn("EffectiveFloorVolatility", double(), 6)
183 .addColumn("EffectiveCapVolatility", double(), 6);
184
185 std::map<std::string, QuantLib::ext::shared_ptr<Trade>> trades = portfolio->trades();
186
187 for (auto [tradeId, trade]: trades) {
188
189 try {
190
191 // if trade is marked as not having cashflows, we skip it
192
193 if (!trade->hasCashflows()) {
194 WLOG("cashflow for " << trade->tradeType() << " " << trade->id() << " skipped");
195 continue;
196 }
197
198 // if trade provides cashflows as additional results, we use that information instead of the legs
199
200 auto addResults = trade->instrument()->additionalResults();
201
202 auto cashFlowResults = addResults.find("cashFlowResults");
203
204 // ensures all cashFlowResults from composite trades are being accounted for
205 auto lower = addResults.lower_bound("cashFlowResults");
206 auto upper = addResults.lower_bound("cashFlowResults_a");
207
208 std::map<Size, Size> cashflowNumber;
209
210 const Real multiplier = trade->instrument()->multiplier() * trade->instrument()->multiplier2();
211
212 if (lower != addResults.end()) {
213
214 for (auto cashFlowResults = lower; cashFlowResults != upper; ++cashFlowResults) {
215
216 // additional result based cashflow reporting
217
218 QL_REQUIRE(cashFlowResults->second.type() == typeid(std::vector<CashFlowResults>),
219 "internal error: cashflowResults type does not match CashFlowResults: '"
220 << cashFlowResults->second.type().name() << "'");
221 std::vector<CashFlowResults> cfResults =
222 boost::any_cast<std::vector<CashFlowResults>>(cashFlowResults->second);
223 //std::map<Size, Size> cashflowNumber;
224 for (auto const& cf : cfResults) {
225 string ccy = "";
226 if (!cf.currency.empty()) {
227 ccy = cf.currency;
228 } else if (trade->legCurrencies().size() > cf.legNumber) {
229 ccy = trade->legCurrencies()[cf.legNumber];
230 } else {
231 ccy = trade->npvCurrency();
232 }
233
234 Real effectiveAmount = Null<Real>();
235 Real discountFactor = Null<Real>();
236 Real presentValue = Null<Real>();
237 Real presentValueBase = Null<Real>();
238 Real fxRateLocalBase = Null<Real>();
239 Real floorStrike = Null<Real>();
240 Real capStrike = Null<Real>();
241 Real floorVolatility = Null<Real>();
242 Real capVolatility = Null<Real>();
243 Real effectiveFloorVolatility = Null<Real>();
244 Real effectiveCapVolatility = Null<Real>();
245
246 if (cf.amount != Null<Real>())
247 effectiveAmount = cf.amount * multiplier;
248 if (cf.discountFactor != Null<Real>())
249 discountFactor = cf.discountFactor;
250 else if (!cf.currency.empty() && cf.payDate != Null<Date>() && market) {
251 discountFactor = cf.payDate < asof
252 ? 0.0
253 : market->discountCurve(cf.currency, configuration)->discount(cf.payDate);
254 }
255 if (cf.presentValue != Null<Real>()) {
256 presentValue = cf.presentValue * multiplier;
257 } else if (effectiveAmount != Null<Real>() && discountFactor != Null<Real>()) {
258 presentValue = effectiveAmount * discountFactor;
259 }
260 if (cf.fxRateLocalBase != Null<Real>()) {
261 fxRateLocalBase = cf.fxRateLocalBase;
262 } else if (market) {
263 try {
264 fxRateLocalBase = market->fxRate(ccy + baseCurrency)->value();
265 } catch (...) {
266 }
267 }
268 if (cf.presentValueBase != Null<Real>()) {
269 presentValueBase = cf.presentValueBase;
270 } else if (presentValue != Null<Real>() && fxRateLocalBase != Null<Real>()) {
271 presentValueBase = presentValue * fxRateLocalBase;
272 }
273 if (cf.floorStrike != Null<Real>())
274 floorStrike = cf.floorStrike;
275 if (cf.capStrike != Null<Real>())
276 capStrike = cf.capStrike;
277 if (cf.floorVolatility != Null<Real>())
278 floorVolatility = cf.floorVolatility;
279 if (cf.capVolatility != Null<Real>())
280 capVolatility = cf.capVolatility;
281 if (cf.effectiveFloorVolatility != Null<Real>())
282 floorVolatility = cf.effectiveFloorVolatility;
283 if (cf.effectiveCapVolatility != Null<Real>())
284 capVolatility = cf.effectiveCapVolatility;
285
286 // to be consistent with the leg-based cf report we should do this:
287 // if (!includePastCashflows && cf.payDate <= asof)
288 // continue;
289 // however, this changes a lot of results, so we output all cfs for the time being
290
291 report.next()
292 .add(trade->id())
293 .add(trade->tradeType())
294 .add(++cashflowNumber[cf.legNumber])
295 .add(cf.legNumber)
296 .add(cf.payDate)
297 .add(cf.type)
298 .add(effectiveAmount)
299 .add(ccy)
300 .add(cf.rate)
301 .add(cf.accrualPeriod)
302 .add(cf.accrualStartDate)
303 .add(cf.accrualEndDate)
304 .add(cf.accruedAmount * (cf.accruedAmount == Null<Real>() ? 1.0 : multiplier))
305 .add(cf.fixingDate)
306 .add(cf.fixingValue)
307 .add(cf.notional * (cf.notional == Null<Real>() ? 1.0 : multiplier))
308 .add(discountFactor)
309 .add(presentValue)
310 .add(fxRateLocalBase)
311 .add(presentValueBase)
312 .add(baseCurrency)
313 .add(floorStrike)
314 .add(capStrike)
315 .add(floorVolatility)
316 .add(capVolatility)
317 .add(effectiveFloorVolatility)
318 .add(effectiveCapVolatility);
319 }
320 }
321 }
322 if (trade->legs().size() >= 1 && cashFlowResults == addResults.end()) {
323
324 // leg based cashflow reporting
325 auto maxLegNoIter = std::max_element(cashflowNumber.begin(), cashflowNumber.end());
326 Size addResultsLegs = 0;
327 if (maxLegNoIter != cashflowNumber.end())
328 addResultsLegs = maxLegNoIter->first + 1;
329
330 const vector<Leg>& legs = trade->legs();
331 for (size_t i = 0; i < legs.size(); i++) {
332 const QuantLib::Leg& leg = legs[i];
333 bool payer = trade->legPayers()[i];
334 string ccy = trade->legCurrencies()[i];
335 Handle<YieldTermStructure> discountCurve;
336 if (market)
337 discountCurve = market->discountCurve(ccy, configuration);
338 for (size_t j = 0; j < leg.size(); j++) {
339 QuantLib::ext::shared_ptr<QuantLib::CashFlow> ptrFlow = leg[j];
340 Date payDate = ptrFlow->date();
341 if (!ptrFlow->hasOccurred(asof) || includePastCashflows) {
342 Real amount = ptrFlow->amount();
343 string flowType = "";
344 if (payer)
345 amount *= -1.0;
346 std::string ccy = trade->legCurrencies()[i];
347
348 QuantLib::ext::shared_ptr<QuantLib::Coupon> ptrCoupon =
349 QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(ptrFlow);
350 QuantLib::ext::shared_ptr<QuantExt::CommodityCashFlow> ptrCommCf =
351 QuantLib::ext::dynamic_pointer_cast<QuantExt::CommodityCashFlow>(ptrFlow);
352
353 Real coupon;
354 Real accrual;
355 Real notional;
356 Date accrualStartDate, accrualEndDate;
357 Real accruedAmount;
358
359 if (ptrCoupon) {
360 coupon = ptrCoupon->rate();
361 accrual = ptrCoupon->accrualPeriod();
362 notional = ptrCoupon->nominal();
363 accrualStartDate = ptrCoupon->accrualStartDate();
364 accrualEndDate = ptrCoupon->accrualEndDate();
365 accruedAmount = ptrCoupon->accruedAmount(asof);
366 if (payer)
367 accruedAmount *= -1.0;
368 flowType = "Interest";
369 } else if (ptrCommCf) {
370 coupon = Null<Real>();
371 accrual = Null<Real>();
372 notional =
373 ptrCommCf->periodQuantity(); // this is measured in units, e.g. barrels for oil
374 accrualStartDate = accrualEndDate = Null<Date>();
375 accruedAmount = Null<Real>();
376 flowType = "Notional (units)";
377 } else {
378 coupon = Null<Real>();
379 accrual = Null<Real>();
380 notional = Null<Real>();
381 accrualStartDate = accrualEndDate = Null<Date>();
382 accruedAmount = Null<Real>();
383 flowType = "Notional";
384 }
385
386 if (auto cpn = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(ptrFlow)) {
387 ptrFlow = unpackIndexedCoupon(cpn);
388 }
389
390 QuantLib::ext::shared_ptr<QuantLib::FloatingRateCoupon> ptrFloat =
391 QuantLib::ext::dynamic_pointer_cast<QuantLib::FloatingRateCoupon>(ptrFlow);
392 QuantLib::ext::shared_ptr<QuantLib::InflationCoupon> ptrInfl =
393 QuantLib::ext::dynamic_pointer_cast<QuantLib::InflationCoupon>(ptrFlow);
394 QuantLib::ext::shared_ptr<QuantLib::IndexedCashFlow> ptrIndCf =
395 QuantLib::ext::dynamic_pointer_cast<QuantLib::IndexedCashFlow>(ptrFlow);
396 QuantLib::ext::shared_ptr<QuantExt::FXLinkedCashFlow> ptrFxlCf =
397 QuantLib::ext::dynamic_pointer_cast<QuantExt::FXLinkedCashFlow>(ptrFlow);
398 QuantLib::ext::shared_ptr<QuantExt::EquityCoupon> ptrEqCp =
399 QuantLib::ext::dynamic_pointer_cast<QuantExt::EquityCoupon>(ptrFlow);
400
401 Date fixingDate;
402 Real fixingValue = Null<Real>();
403 if (ptrFloat) {
404 fixingDate = ptrFloat->fixingDate();
405 if (fixingDate > asof)
406 flowType = "InterestProjected";
407
408 try {
409 fixingValue = ptrFloat->index()->fixing(fixingDate);
410 } catch (...) {
411 }
412
413 if (auto c = QuantLib::ext::dynamic_pointer_cast<QuantLib::IborCoupon>(ptrFloat)) {
414 fixingValue = (c->rate() - c->spread()) / c->gearing();
415 }
416
417 if (auto c = QuantLib::ext::dynamic_pointer_cast<QuantLib::CappedFlooredIborCoupon>(
418 ptrFloat)) {
419 fixingValue = (c->underlying()->rate() - c->underlying()->spread()) /
420 c->underlying()->gearing();
421 }
422
423 if (auto sc =
424 QuantLib::ext::dynamic_pointer_cast<QuantLib::StrippedCappedFlooredCoupon>(
425 ptrFloat)) {
426 if (auto c = QuantLib::ext::dynamic_pointer_cast<QuantLib::CappedFlooredIborCoupon>(
427 sc->underlying())) {
428 fixingValue = (c->underlying()->rate() - c->underlying()->spread()) /
429 c->underlying()->gearing();
430 }
431 }
432
433 // for (capped-floored) BMA / ON / subperiod coupons the fixing value is the
434 // compounded / averaged rate, not a single index fixing
435
436 if (auto on = QuantLib::ext::dynamic_pointer_cast<QuantExt::AverageONIndexedCoupon>(
437 ptrFloat)) {
438 fixingValue = (on->rate() - on->spread()) / on->gearing();
439 } else if (auto on =
440 QuantLib::ext::dynamic_pointer_cast<QuantExt::OvernightIndexedCoupon>(
441 ptrFloat)) {
442 fixingValue = (on->rate() - on->effectiveSpread()) / on->gearing();
443 } else if (auto c = QuantLib::ext::dynamic_pointer_cast<QuantLib::AverageBMACoupon>(
444 ptrFloat)) {
445 fixingValue = (c->rate() - c->spread()) / c->gearing();
446 } else if (auto c = QuantLib::ext::dynamic_pointer_cast<
447 QuantExt::CappedFlooredAverageONIndexedCoupon>(ptrFloat)) {
448 fixingValue = (c->underlying()->rate() - c->underlying()->spread()) /
449 c->underlying()->gearing();
450 } else if (auto c = QuantLib::ext::dynamic_pointer_cast<
451 QuantExt::CappedFlooredOvernightIndexedCoupon>(ptrFloat)) {
452 fixingValue = (c->underlying()->rate() - c->underlying()->effectiveSpread()) /
453 c->underlying()->gearing();
454 } else if (auto c = QuantLib::ext::dynamic_pointer_cast<
455 QuantExt::CappedFlooredAverageBMACoupon>(ptrFloat)) {
456 fixingValue = (c->underlying()->rate() - c->underlying()->spread()) /
457 c->underlying()->gearing();
458 } else if (auto sp = QuantLib::ext::dynamic_pointer_cast<QuantExt::SubPeriodsCoupon1>(
459 ptrFloat)) {
460 fixingValue = (sp->rate() - sp->spread()) / sp->gearing();
461 }
462 } else if (ptrInfl) {
463 fixingDate = ptrInfl->fixingDate();
464 fixingValue = ptrInfl->indexFixing();
465 flowType = "Inflation";
466 } else if (ptrIndCf) {
467 fixingDate = ptrIndCf->fixingDate();
468 fixingValue = ptrIndCf->indexFixing();
469 flowType = "Index";
470 } else if (ptrFxlCf) {
471 fixingDate = ptrFxlCf->fxFixingDate();
472 fixingValue = ptrFxlCf->fxRate();
473 } else if (ptrEqCp) {
474 fixingDate = ptrEqCp->fixingEndDate();
475 fixingValue = ptrEqCp->equityCurve()->fixing(fixingDate);
476 } else if (ptrCommCf) {
477 fixingDate = ptrCommCf->lastPricingDate();
478 fixingValue = ptrCommCf->fixing();
479 } else {
480 fixingDate = Null<Date>();
481 fixingValue = Null<Real>();
482 }
483
484 Real effectiveAmount = Null<Real>();
485 Real discountFactor = Null<Real>();
486 Real presentValue = Null<Real>();
487 Real presentValueBase = Null<Real>();
488 Real fxRateLocalBase = Null<Real>();
489 Real floorStrike = Null<Real>();
490 Real capStrike = Null<Real>();
491 Real floorVolatility = Null<Real>();
492 Real capVolatility = Null<Real>();
493 Real effectiveFloorVolatility = Null<Real>();
494 Real effectiveCapVolatility = Null<Real>();
495
496 if (amount != Null<Real>())
497 effectiveAmount = amount * multiplier;
498
499 if (market) {
500 discountFactor = ptrFlow->hasOccurred(asof) ? 0.0 : discountCurve->discount(payDate);
501 if (effectiveAmount != Null<Real>())
502 presentValue = discountFactor * effectiveAmount;
503 try {
504 fxRateLocalBase = market->fxRate(ccy + baseCurrency)->value();
505 presentValueBase = presentValue * fxRateLocalBase;
506 } catch (...) {
507 }
508
509 // scan for known capped / floored coupons and extract cap / floor strike and fixing
510 // date
511
512 // unpack stripped cap/floor coupon
513 QuantLib::ext::shared_ptr<CashFlow> c = ptrFlow;
514 if (auto tmp =
515 QuantLib::ext::dynamic_pointer_cast<StrippedCappedFlooredCoupon>(ptrFlow)) {
516 c = tmp->underlying();
517 }
518 Date volFixingDate;
519 std::string qlIndexName; // index used to retrieve vol
520 bool usesCapVol = false, usesSwaptionVol = false;
521 Period swaptionTenor;
522 if (auto tmp = QuantLib::ext::dynamic_pointer_cast<CappedFlooredCoupon>(c)) {
523 floorStrike = tmp->effectiveFloor();
524 capStrike = tmp->effectiveCap();
525 volFixingDate = tmp->fixingDate();
526 qlIndexName = tmp->index()->name();
527 if (auto cms = QuantLib::ext::dynamic_pointer_cast<CmsCoupon>(tmp->underlying())) {
528 swaptionTenor = cms->swapIndex()->tenor();
529 qlIndexName = cms->swapIndex()->iborIndex()->name();
530 usesSwaptionVol = true;
531 }else if(auto cms = boost::dynamic_pointer_cast<DurationAdjustedCmsCoupon>(tmp->underlying())) {
532 swaptionTenor = cms->swapIndex()->tenor();
533 qlIndexName = cms->swapIndex()->iborIndex()->name();
534 usesSwaptionVol = true;
535 }else if (auto ibor = QuantLib::ext::dynamic_pointer_cast<IborCoupon>(tmp->underlying())) {
536 qlIndexName = ibor->index()->name();
537 usesCapVol = true;
538 }
539 } else if (auto tmp =
540 QuantLib::ext::dynamic_pointer_cast<CappedFlooredOvernightIndexedCoupon>(
541 c)) {
542 floorStrike = tmp->effectiveFloor();
543 capStrike = tmp->effectiveCap();
544 volFixingDate = tmp->underlying()->fixingDates().front();
545 qlIndexName = tmp->index()->name();
546 usesCapVol = true;
547 if (floorStrike != Null<Real>())
548 effectiveFloorVolatility = tmp->effectiveFloorletVolatility();
549 if (capStrike != Null<Real>())
550 effectiveCapVolatility = tmp->effectiveCapletVolatility();
551 } else if (auto tmp =
552 QuantLib::ext::dynamic_pointer_cast<CappedFlooredAverageONIndexedCoupon>(
553 c)) {
554 floorStrike = tmp->effectiveFloor();
555 capStrike = tmp->effectiveCap();
556 volFixingDate = tmp->underlying()->fixingDates().front();
557 qlIndexName = tmp->index()->name();
558 usesCapVol = true;
559 if (floorStrike != Null<Real>())
560 effectiveFloorVolatility = tmp->effectiveFloorletVolatility();
561 if (capStrike != Null<Real>())
562 effectiveCapVolatility = tmp->effectiveCapletVolatility();
563 } else if (auto tmp =
564 QuantLib::ext::dynamic_pointer_cast<CappedFlooredAverageBMACoupon>(c)) {
565 floorStrike = tmp->effectiveFloor();
566 capStrike = tmp->effectiveCap();
567 volFixingDate = tmp->underlying()->fixingDates().front();
568 qlIndexName = tmp->index()->name();
569 usesCapVol = true;
570 if (floorStrike != Null<Real>())
571 effectiveFloorVolatility = tmp->effectiveFloorletVolatility();
572 if (capStrike != Null<Real>())
573 effectiveCapVolatility = tmp->effectiveCapletVolatility();
574 }
575
576 // get market volaility for cap / floor
577
578 if (volFixingDate != Date() && fixingDate > market->asofDate()) {
579 volFixingDate = std::max(volFixingDate, market->asofDate() + 1);
580 if (floorStrike != Null<Real>()) {
581 if (usesSwaptionVol) {
582 floorVolatility =
583 market
584 ->swaptionVol(IndexNameTranslator::instance().oreName(qlIndexName),
585 configuration)
586 ->volatility(volFixingDate, swaptionTenor, floorStrike);
587 } else if (usesCapVol && floorVolatility == Null<Real>()) {
588 floorVolatility =
589 market
590 ->capFloorVol(IndexNameTranslator::instance().oreName(qlIndexName),
591 configuration)
592 ->volatility(volFixingDate, floorStrike);
593 }
594 }
595 if (capStrike != Null<Real>()) {
596 if (usesSwaptionVol) {
597 capVolatility =
598 market
599 ->swaptionVol(IndexNameTranslator::instance().oreName(qlIndexName),
600 configuration)
601 ->volatility(volFixingDate, swaptionTenor, capStrike);
602 } else if (usesCapVol && capVolatility == Null<Real>()) {
603 capVolatility =
604 market
605 ->capFloorVol(IndexNameTranslator::instance().oreName(qlIndexName),
606 configuration)
607 ->volatility(volFixingDate, capStrike);
608 }
609 }
610 }
611 }
612
613 report.next()
614 .add(trade->id())
615 .add(trade->tradeType())
616 .add(j + 1)
617 .add(i + addResultsLegs)
618 .add(payDate)
619 .add(flowType)
620 .add(effectiveAmount)
621 .add(ccy)
622 .add(coupon)
623 .add(accrual)
624 .add(accrualStartDate)
625 .add(accrualEndDate)
626 .add(accruedAmount * (accruedAmount == Null<Real>() ? 1.0 : multiplier))
627 .add(fixingDate)
628 .add(fixingValue)
629 .add(notional * (notional == Null<Real>() ? 1.0 : multiplier))
630 .add(discountFactor)
631 .add(presentValue)
632 .add(fxRateLocalBase)
633 .add(presentValueBase)
634 .add(baseCurrency)
635 .add(floorStrike)
636 .add(capStrike)
637 .add(floorVolatility)
638 .add(capVolatility)
639 .add(effectiveFloorVolatility)
640 .add(effectiveCapVolatility);
641 }
642 }
643 }
644 }
645
646 } catch (std::exception& e) {
647 StructuredTradeErrorMessage(trade->id(), trade->tradeType(), "Error during cashflow report generation",
648 e.what())
649 .log();
650 }
651 }
652 report.end();
653 LOG("Cashflow report written");
654}
655
656void ReportWriter::writeCashflowNpv(ore::data::Report& report, const ore::data::InMemoryReport& cashflowReport,
657 QuantLib::ext::shared_ptr<ore::data::Market> market, const std::string& configuration,
658 const std::string& baseCcy, const Date& horizon) {
659 // Pick the following fields form the in memory report:
660 // - tradeId
661 // - payment date
662 // - currency
663 // - present value
664 // Then convert PVs into base currency, aggrate per trade if payment date is within the horizon
665 // Write the resulting aggregate PV per trade into the report.
666
667 Size tradeIdColumn = 0;
668 Size tradeTypeColumn = 1;
669 Size payDateColumn = 4;
670 Size ccyColumn = 7;
671 Size pvColumn = 17;
672 QL_REQUIRE(cashflowReport.header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
673 QL_REQUIRE(cashflowReport.header(tradeTypeColumn) == "Type", "incorrect trade type column " << tradeTypeColumn);
674 QL_REQUIRE(cashflowReport.header(payDateColumn) == "PayDate", "incorrect payment date column " << payDateColumn);
675 QL_REQUIRE(cashflowReport.header(ccyColumn) == "Currency", "incorrect currency column " << ccyColumn);
676 QL_REQUIRE(cashflowReport.header(pvColumn) == "PresentValue", "incorrect pv column " << pvColumn);
677
678 map<string, Real> npvMap;
679 Date asof = Settings::instance().evaluationDate();
680 for (Size i = 0; i < cashflowReport.rows(); ++i) {
681 string tradeId = QuantLib::ext::get<string>(cashflowReport.data(tradeIdColumn).at(i));
682 string tradeType = QuantLib::ext::get<string>(cashflowReport.data(tradeTypeColumn).at(i));
683 Date payDate = QuantLib::ext::get<Date>(cashflowReport.data(payDateColumn).at(i));
684 string ccy = QuantLib::ext::get<string>(cashflowReport.data(ccyColumn).at(i));
685 Real pv = QuantLib::ext::get<Real>(cashflowReport.data(pvColumn).at(i));
686 Real fx = 1.0;
687 // There shouldn't be entries in the cf report without ccy. We assume ccy = baseCcy in this case and log an error.
688 if (ccy.empty()) {
689 StructuredTradeErrorMessage(tradeId, tradeType, "Error during CashflowNpv calculation.",
690 "Cashflow in row " + std::to_string(i) +
691 " has no ccy. Assuming ccy = baseCcy = " + baseCcy + ".")
692 .log();
693 }
694 if (!ccy.empty() && ccy != baseCcy)
695 fx = market->fxRate(ccy + baseCcy, configuration)->value();
696 if (npvMap.find(tradeId) == npvMap.end())
697 npvMap[tradeId] = 0.0;
698 if (payDate > asof && payDate <= horizon) {
699 npvMap[tradeId] += pv * fx;
700 DLOG("Cashflow NPV for trade " << tradeId << ": pv " << pv << " fx " << fx << " sum " << npvMap[tradeId]);
701 }
702 }
703
704 LOG("Writing cashflow NPV report for " << asof);
705 report.addColumn("TradeId", string())
706 .addColumn("PresentValue", double(), 10)
707 .addColumn("BaseCurrency", string())
708 .addColumn("Horizon", string());
709
710 for (auto r: npvMap)
711 report.next().add(r.first).add(r.second).add(baseCcy).add(horizon < Date::maxDate() ? ore::data::to_string(horizon) : "infinite");
712
713 report.end();
714 LOG("Cashflow NPV report written");
715}
716
717void ReportWriter::writeCurves(ore::data::Report& report, const std::string& configID, const DateGrid& grid,
718 const TodaysMarketParameters& marketConfig, const QuantLib::ext::shared_ptr<Market>& market,
719 const bool continueOnError) {
720 LOG("Write curves... ");
721
722 QL_REQUIRE(marketConfig.hasConfiguration(configID), "curve configuration " << configID << " not found");
723
724 map<string, string> discountCurves = marketConfig.mapping(MarketObject::DiscountCurve, configID);
725 map<string, string> YieldCurves = marketConfig.mapping(MarketObject::YieldCurve, configID);
726 map<string, string> indexCurves = marketConfig.mapping(MarketObject::IndexCurve, configID);
727 map<string, string> zeroInflationIndices, defaultCurves;
728 if (marketConfig.hasMarketObject(MarketObject::ZeroInflationCurve))
729 zeroInflationIndices = marketConfig.mapping(MarketObject::ZeroInflationCurve, configID);
730 if (marketConfig.hasMarketObject(MarketObject::DefaultCurve))
731 defaultCurves = marketConfig.mapping(MarketObject::DefaultCurve, configID);
732
733 vector<Handle<YieldTermStructure>> yieldCurves;
734 vector<Handle<ZeroInflationIndex>> zeroInflationFixings;
735 vector<Handle<DefaultProbabilityTermStructure>> probabilityCurves;
736
737 report.addColumn("Tenor", Period()).addColumn("Date", Date());
738
739 for (auto it : discountCurves) {
740 DLOG("discount curve - " << it.first);
741 try {
742 yieldCurves.push_back(market->discountCurve(it.first, configID));
743 report.addColumn(it.first, double(), 15);
744 } catch (const std::exception& e) {
745 if (continueOnError) {
746 WLOG("skip this curve: " << e.what());
747 } else {
748 QL_FAIL(e.what());
749 }
750 }
751 }
752 for (auto it : YieldCurves) {
753 DLOG("yield curve - " << it.first);
754 try {
755 yieldCurves.push_back(market->yieldCurve(it.first, configID));
756 report.addColumn(it.first, double(), 15);
757 } catch (const std::exception& e) {
758 if (continueOnError) {
759 WLOG("skip this curve: " << e.what());
760 } else {
761 QL_FAIL(e.what());
762 }
763 }
764 }
765 for (auto it : indexCurves) {
766 DLOG("index curve - " << it.first);
767 try {
768 yieldCurves.push_back(market->iborIndex(it.first, configID)->forwardingTermStructure());
769 report.addColumn(it.first, double(), 15);
770 } catch (const std::exception& e) {
771 if (continueOnError) {
772 WLOG("skip this curve: " << e.what());
773 } else {
774 QL_FAIL(e.what());
775 }
776 }
777 }
778 for (auto it : zeroInflationIndices) {
779 DLOG("inflation curve - " << it.first);
780 try {
781 zeroInflationFixings.push_back(market->zeroInflationIndex(it.first, configID));
782 report.addColumn(it.first, double(), 15);
783 } catch (const std::exception& e) {
784 if (continueOnError) {
785 WLOG("skip this curve: " << e.what());
786 } else {
787 QL_FAIL(e.what());
788 }
789 }
790 }
791 for (auto it : defaultCurves) {
792 DLOG("default curve - " << it.first);
793 try {
794 probabilityCurves.push_back(market->defaultCurve(it.first, configID)->curve());
795 report.addColumn(it.first, double(), 15);
796 } catch (const std::exception& e) {
797 if (continueOnError) {
798 WLOG("skip this curve: " << e.what());
799 } else {
800 QL_FAIL(e.what());
801 }
802 }
803 }
804
805 for (Size j = 0; j < grid.size(); ++j) {
806 Date date = grid[j];
807 report.next().add(grid.tenors()[j]).add(date);
808 for (Size i = 0; i < yieldCurves.size(); ++i)
809 report.add(yieldCurves[i]->discount(date));
810 for (Size i = 0; i < zeroInflationFixings.size(); ++i)
811 report.add(zeroInflationFixings[i]->fixing(date));
812 for (Size i = 0; i < probabilityCurves.size(); ++i)
813 report.add(probabilityCurves[i]->survivalProbability(date));
814 }
815 report.end();
816}
817
818void ReportWriter::writeTradeExposures(ore::data::Report& report, QuantLib::ext::shared_ptr<PostProcess> postProcess,
819 const string& tradeId) {
820 const vector<Date> dates = postProcess->cube()->dates();
821 Date today = Settings::instance().evaluationDate();
822 DayCounter dc = ActualActual(ActualActual::ISDA);
823 const vector<Real>& epe = postProcess->tradeEPE(tradeId);
824 const vector<Real>& ene = postProcess->tradeENE(tradeId);
825 const vector<Real>& ee_b = postProcess->tradeEE_B(tradeId);
826 const vector<Real>& eee_b = postProcess->tradeEEE_B(tradeId);
827 const vector<Real>& pfe = postProcess->tradePFE(tradeId);
828 const vector<Real>& aepe = postProcess->allocatedTradeEPE(tradeId);
829 const vector<Real>& aene = postProcess->allocatedTradeENE(tradeId);
830 report.addColumn("TradeId", string())
831 .addColumn("Date", Date())
832 .addColumn("Time", double(), 6)
833 .addColumn("EPE", double())
834 .addColumn("ENE", double())
835 .addColumn("AllocatedEPE", double())
836 .addColumn("AllocatedENE", double())
837 .addColumn("PFE", double())
838 .addColumn("BaselEE", double())
839 .addColumn("BaselEEE", double());
840 report.next()
841 .add(tradeId)
842 .add(today)
843 .add(0.0)
844 .add(epe[0])
845 .add(ene[0])
846 .add(aepe[0])
847 .add(aene[0])
848 .add(pfe[0])
849 .add(ee_b[0])
850 .add(eee_b[0]);
851 for (Size j = 0; j < dates.size(); ++j) {
852
853 Time time = dc.yearFraction(today, dates[j]);
854 report.next()
855 .add(tradeId)
856 .add(dates[j])
857 .add(time)
858 .add(epe[j + 1])
859 .add(ene[j + 1])
860 .add(aepe[j + 1])
861 .add(aene[j + 1])
862 .add(pfe[j + 1])
863 .add(ee_b[j + 1])
864 .add(eee_b[j + 1]);
865 }
866 report.end();
867}
868
869void addNettingSetExposure(ore::data::Report& report, QuantLib::ext::shared_ptr<PostProcess> postProcess,
870 const string& nettingSetId) {
871 const vector<Date> dates = postProcess->cube()->dates();
872 Date today = Settings::instance().evaluationDate();
873 DayCounter dc = ActualActual(ActualActual::ISDA);
874 const vector<Real>& epe = postProcess->netEPE(nettingSetId);
875 const vector<Real>& ene = postProcess->netENE(nettingSetId);
876 const vector<Real>& ee_b = postProcess->netEE_B(nettingSetId);
877 const vector<Real>& eee_b = postProcess->netEEE_B(nettingSetId);
878 const vector<Real>& pfe = postProcess->netPFE(nettingSetId);
879 const vector<Real>& ecb = postProcess->expectedCollateral(nettingSetId);
880
881 report.next()
882 .add(nettingSetId)
883 .add(today)
884 .add(0.0)
885 .add(epe[0])
886 .add(ene[0])
887 .add(pfe[0])
888 .add(ecb[0])
889 .add(ee_b[0])
890 .add(eee_b[0]);
891 for (Size j = 0; j < dates.size(); ++j) {
892 Real time = dc.yearFraction(today, dates[j]);
893 report.next()
894 .add(nettingSetId)
895 .add(dates[j])
896 .add(time)
897 .add(epe[j + 1])
898 .add(ene[j + 1])
899 .add(pfe[j + 1])
900 .add(ecb[j + 1])
901 .add(ee_b[j + 1])
902 .add(eee_b[j + 1]);
903 }
904}
905
906void ReportWriter::writeNettingSetExposures(ore::data::Report& report, QuantLib::ext::shared_ptr<PostProcess> postProcess,
907 const string& nettingSetId) {
908 report.addColumn("NettingSet", string())
909 .addColumn("Date", Date())
910 .addColumn("Time", double(), 6)
911 .addColumn("EPE", double(), 2)
912 .addColumn("ENE", double(), 2)
913 .addColumn("PFE", double(), 2)
914 .addColumn("ExpectedCollateral", double(), 2)
915 .addColumn("BaselEE", double(), 2)
916 .addColumn("BaselEEE", double(), 2);
917 addNettingSetExposure(report, postProcess, nettingSetId);
918 report.end();
919}
920
921void ReportWriter::writeNettingSetExposures(ore::data::Report& report, QuantLib::ext::shared_ptr<PostProcess> postProcess) {
922 report.addColumn("NettingSet", string())
923 .addColumn("Date", Date())
924 .addColumn("Time", double(), 6)
925 .addColumn("EPE", double(), 2)
926 .addColumn("ENE", double(), 2)
927 .addColumn("PFE", double(), 2)
928 .addColumn("ExpectedCollateral", double(), 2)
929 .addColumn("BaselEE", double(), 2)
930 .addColumn("BaselEEE", double(), 2);
931
932 for (const auto& [n,_] : postProcess->nettingSetIds()) {
933 addNettingSetExposure(report, postProcess, n);
934 }
935 report.end();
936}
937
938void ReportWriter::writeNettingSetCvaSensitivities(ore::data::Report& report,
939 QuantLib::ext::shared_ptr<PostProcess> postProcess,
940 const string& nettingSetId) {
941 const vector<Real> grid = postProcess->spreadSensitivityTimes();
942 const vector<Real>& sensiHazardRate = postProcess->netCvaHazardRateSensitivity(nettingSetId);
943 const vector<Real>& sensiCdsSpread = postProcess->netCvaSpreadSensitivity(nettingSetId);
944 report.addColumn("NettingSet", string())
945 .addColumn("Time", double(), 6)
946 .addColumn("CvaHazardRateSensitivity", double(), 6)
947 .addColumn("CvaSpreadSensitivity", double(), 6);
948
949 if (sensiHazardRate.size() == 0 || sensiCdsSpread.size() == 0)
950 return;
951
952 for (Size j = 0; j < grid.size(); ++j) {
953 report.next().add(nettingSetId).add(grid[j]).add(sensiHazardRate[j]).add(sensiCdsSpread[j]);
954 }
955 report.end();
956}
957
958void ReportWriter::writeXVA(ore::data::Report& report, const string& allocationMethod,
959 QuantLib::ext::shared_ptr<Portfolio> portfolio, QuantLib::ext::shared_ptr<PostProcess> postProcess) {
960 const vector<Date> dates = postProcess->cube()->dates();
961 DayCounter dc = ActualActual(ActualActual::ISDA);
962 Size precision = 2;
963 report.addColumn("TradeId", string())
964 .addColumn("NettingSetId", string())
965 .addColumn("CVA", double(), precision)
966 .addColumn("DVA", double(), precision)
967 .addColumn("FBA", double(), precision)
968 .addColumn("FCA", double(), precision)
969 .addColumn("FBAexOwnSP", double(), precision)
970 .addColumn("FCAexOwnSP", double(), precision)
971 .addColumn("FBAexAllSP", double(), precision)
972 .addColumn("FCAexAllSP", double(), precision)
973 .addColumn("COLVA", double(), precision)
974 .addColumn("MVA", double(), precision)
975 .addColumn("OurKVACCR", double(), precision)
976 .addColumn("TheirKVACCR", double(), precision)
977 .addColumn("OurKVACVA", double(), precision)
978 .addColumn("TheirKVACVA", double(), precision)
979 .addColumn("CollateralFloor", double(), precision)
980 .addColumn("AllocatedCVA", double(), precision)
981 .addColumn("AllocatedDVA", double(), precision)
982 .addColumn("AllocationMethod", string())
983 .addColumn("BaselEPE", double(), precision)
984 .addColumn("BaselEEPE", double(), precision);
985
986 for (const auto& [n, _] : postProcess->nettingSetIds()) {
987 try {
988 postProcess->nettingSetCVA(n);
989 report.next()
990 .add("")
991 .add(n)
992 .add(postProcess->nettingSetCVA(n))
993 .add(postProcess->nettingSetDVA(n))
994 .add(postProcess->nettingSetFBA(n))
995 .add(postProcess->nettingSetFCA(n))
996 .add(postProcess->nettingSetFBA_exOwnSP(n))
997 .add(postProcess->nettingSetFCA_exOwnSP(n))
998 .add(postProcess->nettingSetFBA_exAllSP(n))
999 .add(postProcess->nettingSetFCA_exAllSP(n))
1000 .add(postProcess->nettingSetCOLVA(n))
1001 .add(postProcess->nettingSetMVA(n))
1002 .add(postProcess->nettingSetOurKVACCR(n))
1003 .add(postProcess->nettingSetTheirKVACCR(n))
1004 .add(postProcess->nettingSetOurKVACVA(n))
1005 .add(postProcess->nettingSetTheirKVACVA(n))
1006 .add(postProcess->nettingSetCollateralFloor(n))
1007 .add(postProcess->nettingSetCVA(n))
1008 .add(postProcess->nettingSetDVA(n))
1009 .add(allocationMethod)
1010 .add(postProcess->netEPE_B(n))
1011 .add(postProcess->netEEPE_B(n));
1012 } catch (const std::exception& e) {
1013 StructuredAnalyticsErrorMessage("XVA Report", "Error during writing xva for netting set.", e.what(),
1014 {{"nettingSetId", n}})
1015 .log();
1016 }
1017
1018 for (auto& [tid, trade] : portfolio->trades()) {
1019
1020 string nid = trade->envelope().nettingSetId();
1021 if (nid != n)
1022 continue;
1023 try {
1024 postProcess->tradeCVA(tid);
1025 report.next()
1026 .add(tid)
1027 .add(nid)
1028 .add(postProcess->tradeCVA(tid))
1029 .add(postProcess->tradeDVA(tid))
1030 .add(postProcess->tradeFBA(tid))
1031 .add(postProcess->tradeFCA(tid))
1032 .add(postProcess->tradeFBA_exOwnSP(tid))
1033 .add(postProcess->tradeFCA_exOwnSP(tid))
1034 .add(postProcess->tradeFBA_exAllSP(tid))
1035 .add(postProcess->tradeFCA_exAllSP(tid))
1036 .add(Null<Real>())
1037 .add(Null<Real>())
1038 .add(Null<Real>())
1039 .add(Null<Real>())
1040 .add(Null<Real>())
1041 .add(Null<Real>())
1042 .add(Null<Real>())
1043 .add(postProcess->allocatedTradeCVA(tid))
1044 .add(postProcess->allocatedTradeDVA(tid))
1045 .add(allocationMethod)
1046 .add(postProcess->tradeEPE_B(tid))
1047 .add(postProcess->tradeEEPE_B(tid));
1048 } catch (const std::exception& e) {
1049 StructuredAnalyticsErrorMessage("XVA Report", "Error during writing xva for trade.", e.what(),
1050 {{"tradeId", n}})
1051 .log();
1052 }
1053 }
1054 }
1055 report.end();
1056}
1057
1058void ReportWriter::writeNettingSetColva(ore::data::Report& report, QuantLib::ext::shared_ptr<PostProcess> postProcess,
1059 const string& nettingSetId) {
1060 const vector<Date> dates = postProcess->cube()->dates();
1061 Date today = Settings::instance().evaluationDate();
1062 DayCounter dc = ActualActual(ActualActual::ISDA);
1063 const vector<Real>& collateral = postProcess->expectedCollateral(nettingSetId);
1064 const vector<Real>& colvaInc = postProcess->colvaIncrements(nettingSetId);
1065 const vector<Real>& floorInc = postProcess->collateralFloorIncrements(nettingSetId);
1066 Real colva = postProcess->nettingSetCOLVA(nettingSetId);
1067 Real floorValue = postProcess->nettingSetCollateralFloor(nettingSetId);
1068
1069 report.addColumn("NettingSet", string())
1070 .addColumn("Date", Date())
1071 .addColumn("Time", double(), 4)
1072 .addColumn("CollateralBalance", double(), 4)
1073 .addColumn("COLVA Increment", double(), 4)
1074 .addColumn("COLVA", double(), 4)
1075 .addColumn("CollateralFloor Increment", double(), 4)
1076 .addColumn("CollateralFloor", double(), 4);
1077
1078 report.next()
1079 .add(nettingSetId)
1080 .add(Null<Date>())
1081 .add(Null<Real>())
1082 .add(Null<Real>())
1083 .add(Null<Real>())
1084 .add(colva)
1085 .add(Null<Real>())
1086 .add(floorValue);
1087 Real colvaSum = 0.0;
1088 Real floorSum = 0.0;
1089 for (Size j = 0; j < dates.size(); ++j) {
1090 Real time = dc.yearFraction(today, dates[j]);
1091 colvaSum += colvaInc[j + 1];
1092 floorSum += floorInc[j + 1];
1093 report.next()
1094 .add(nettingSetId)
1095 .add(dates[j])
1096 .add(time)
1097 .add(collateral[j + 1])
1098 .add(colvaInc[j + 1])
1099 .add(colvaSum)
1100 .add(floorInc[j + 1])
1101 .add(floorSum);
1102 }
1103 report.end();
1104}
1105
1106void ReportWriter::writeAggregationScenarioData(ore::data::Report& report, const AggregationScenarioData& data) {
1107 report.addColumn("Date", Size()).addColumn("Scenario", Size());
1108 for (auto const& k : data.keys()) {
1109 std::string tmp = ore::data::to_string(k.first) + k.second;
1110 report.addColumn(tmp.c_str(), double(), 8);
1111 }
1112 for (Size d = 0; d < data.dimDates(); ++d) {
1113 for (Size s = 0; s < data.dimSamples(); ++s) {
1114 report.next();
1115 report.add(d).add(s);
1116 for (auto const& k : data.keys()) {
1117 report.add(data.get(d, s, k.first, k.second));
1118 }
1119 }
1120 }
1121 report.end();
1122}
1123
1124void ReportWriter::writeScenarioReport(ore::data::Report& report,
1125 const std::vector<QuantLib::ext::shared_ptr<SensitivityCube>>& sensitivityCubes,
1126 Real outputThreshold) {
1127
1128 LOG("Writing Scenario report");
1129
1130 report.addColumn("TradeId", string());
1131 report.addColumn("Factor", string());
1132 report.addColumn("Up/Down", string());
1133 report.addColumn("Base NPV", double(), 2);
1134 report.addColumn("ShiftSize_1", double(), 6);
1135 report.addColumn("ShiftSize_2", double(), 6);
1136 report.addColumn("Scenario NPV", double(), 2);
1137 report.addColumn("Difference", double(), 2);
1138
1139 for (auto const& sensitivityCube : sensitivityCubes) {
1140
1141 auto scenarioDescriptions = sensitivityCube->scenarioDescriptions();
1142 auto tradeIds = sensitivityCube->tradeIdx();
1143 auto npvCube = sensitivityCube->npvCube();
1144
1145 for (const auto& [tradeId, i] : tradeIds) {
1146
1147 Real baseNpv = npvCube->getT0(i);
1148 for (const auto& [j, scenarioNpv] : npvCube->getTradeNPVs(i)) {
1149 auto scenarioDescription = scenarioDescriptions[j];
1150 Real difference = scenarioNpv - baseNpv;
1151 Real shift1 = scenarioDescription.key1().keytype == RiskFactorKey::KeyType::None
1152 ? Null<Real>()
1153 : sensitivityCube->actualShiftSize(scenarioDescription.key1());
1154 Real shift2 = scenarioDescription.key2().keytype == RiskFactorKey::KeyType::None
1155 ? Null<Real>()
1156 : sensitivityCube->actualShiftSize(scenarioDescription.key2());
1157 if (fabs(difference) > outputThreshold) {
1158 report.next();
1159 report.add(tradeId);
1160 report.add(prettyPrintInternalCurveName(scenarioDescription.factors()));
1161 report.add(scenarioDescription.typeString());
1162 report.add(baseNpv);
1163 report.add(shift1);
1164 report.add(shift2);
1165 report.add(scenarioNpv);
1166 report.add(difference);
1167 } else if (!std::isfinite(difference)) {
1168 // TODO: is this needed?
1169 ALOG("sensitivity scenario for trade " << tradeId << ", factor " << scenarioDescription.factors()
1170 << " is not finite (" << difference << ")");
1171 }
1172 }
1173 }
1174 }
1175
1176 report.end();
1177 LOG("Scenario report finished");
1178}
1179
1180void ReportWriter::writeSensitivityReport(Report& report, const QuantLib::ext::shared_ptr<SensitivityStream>& ss,
1181 Real outputThreshold, Size outputPrecision) {
1182
1183 LOG("Writing Sensitivity report");
1184
1185 Size shiftSizePrecision = outputPrecision < 6 ? 6 : outputPrecision;
1186 Size amountPrecision = outputPrecision < 2 ? 2 : outputPrecision;
1187
1188 report.addColumn("TradeId", string());
1189 report.addColumn("IsPar", string());
1190 report.addColumn("Factor_1", string());
1191 report.addColumn("ShiftSize_1", double(), shiftSizePrecision);
1192 report.addColumn("Factor_2", string());
1193 report.addColumn("ShiftSize_2", double(), shiftSizePrecision);
1194 report.addColumn("Currency", string());
1195 report.addColumn("Base NPV", double(), amountPrecision);
1196 report.addColumn("Delta", double(), amountPrecision);
1197 report.addColumn("Gamma", double(), amountPrecision);
1198
1199 // Make sure that we are starting from the start
1200 ss->reset();
1201 while (SensitivityRecord sr = ss->next()) {
1202 if ((outputThreshold == Null<Real>()) || (fabs(sr.delta) > outputThreshold ||
1203 (sr.gamma != Null<Real>() && fabs(sr.gamma) > outputThreshold))) {
1204 report.next();
1205 report.add(sr.tradeId);
1206 report.add(ore::data::to_string(sr.isPar));
1207 report.add(prettyPrintInternalCurveName(reconstructFactor(sr.key_1, sr.desc_1)));
1208 report.add(sr.shift_1);
1209 report.add(prettyPrintInternalCurveName(reconstructFactor(sr.key_2, sr.desc_2)));
1210 report.add(sr.shift_2);
1211 report.add(sr.currency);
1212 report.add(sr.baseNpv);
1213 report.add(sr.delta);
1214 report.add(sr.gamma);
1215 } else if (!std::isfinite(sr.delta) || !std::isfinite(sr.gamma)) {
1216 // TODO: Again, is this needed?
1217 ALOG("sensitivity record has infinite values: " << sr);
1218 }
1219 }
1220
1221 report.end();
1222 LOG("Sensitivity report finished");
1223}
1224
1225void ReportWriter::writeSensitivityConfigReport(ore::data::Report& report,
1226 const std::map<RiskFactorKey, QuantLib::Real>& shiftSizes,
1227 const std::map<RiskFactorKey, QuantLib::Real>& baseValues,
1228 const std::map<RiskFactorKey, std::string>& keyToFactor) {
1229 LOG("Writing Sensitivity Config report");
1230
1231 report.addColumn("Key", string())
1232 .addColumn("Factor", string())
1233 .addColumn("BaseValue", double(), 8)
1234 .addColumn("ShiftSize", double(), 8);
1235
1236 for (auto const& [key, shift] : shiftSizes) {
1237 report.next();
1238 std::string keyStr = "na", factorStr = "na";
1239 Real baseValue = Null<Real>();
1240 keyStr = ore::data::to_string(key);
1241 if (auto it = keyToFactor.find(key); it != keyToFactor.end())
1242 factorStr = it->second;
1243 if (auto it = baseValues.find(key); it != baseValues.end())
1244 baseValue = it->second;
1245 report.add(keyStr).add(factorStr).add(baseValue).add(shift);
1246 }
1247
1248 report.end();
1249 LOG("Sensitivity Config report finished.");
1250}
1251
1252template <class T>
1253void addMapResults(boost::any resultMap, const std::string& tradeId, const std::string& resultName, Report& report) {
1254 T map = boost::any_cast<T>(resultMap);
1255 for (auto it : map) {
1256 std::string name = resultName + "_" + it.first.code();
1257 boost::any tmp = it.second;
1258 auto p = parseBoostAny(tmp);
1259 report.next().add(tradeId).add(name).add(p.first).add(p.second);
1260 }
1261}
1262
1263void ReportWriter::writeAdditionalResultsReport(Report& report, QuantLib::ext::shared_ptr<Portfolio> portfolio,
1264 QuantLib::ext::shared_ptr<Market> market, const std::string& baseCurrency,
1265 const std::size_t precision) {
1266
1267 LOG("Writing AdditionalResults report");
1268
1269 report.addColumn("TradeId", string())
1270 .addColumn("ResultId", string())
1271 .addColumn("ResultType", string())
1272 .addColumn("ResultValue", string());
1273
1274 for (auto & [tId, trade] : portfolio->trades()) {
1275 try {
1276 // we first add any additional trade data.
1277 string tradeId = tId;
1278 string tradeType = trade->tradeType();
1279 Real notional2 = Null<Real>();
1280 string notional2Ccy = "";
1281 // Get the additional data for the current instrument.
1282 auto additionalData = trade->additionalData();
1283 for (const auto& kv : additionalData) {
1284 auto p = parseBoostAny(kv.second, precision);
1285 if (boost::starts_with(p.first, "vector")) {
1286 vector<std::string> tokens;
1287 string vect = p.second;
1288 vect.erase(remove(vect.begin(), vect.end(), '\"'), vect.end());
1289 boost::split(tokens, vect, boost::is_any_of(","));
1290 for (Size i = 0; i < tokens.size(); i++) {
1291 boost::trim(tokens[i]);
1292 report.next()
1293 .add(tradeId)
1294 .add(kv.first + "[" + std::to_string(i) + "]")
1295 .add(p.first.substr(7))
1296 .add(tokens[i]);
1297 }
1298 } else
1299 report.next().add(tradeId).add(kv.first).add(p.first).add(p.second);
1300 }
1301 // if the 'notional[2]' has been provided convert it to base currency
1302 if (additionalData.count("notional[2]") != 0 && additionalData.count("notionalCurrency[2]") != 0) {
1303 notional2 = trade->additionalDatum<Real>("notional[2]");
1304 notional2Ccy = trade->additionalDatum<string>("notionalCurrency[2]");
1305 }
1306
1307 auto additionalResults = trade->instrument()->additionalResults();
1308 if (additionalResults.count("notional[2]") != 0 && additionalResults.count("notionalCurrency[2]") != 0) {
1309 notional2 = trade->instrument()->qlInstrument()->result<Real>("notional[2]");
1310 notional2Ccy = trade->instrument()->qlInstrument()->result<string>("notionalCurrency[2]");
1311 }
1312
1313 if (notional2 != Null<Real>() && notional2Ccy != "") {
1314 Real fx = 1.0;
1315 if (notional2Ccy != baseCurrency)
1316 fx = market->fxRate(notional2Ccy + baseCurrency)->value();
1317 std::ostringstream oss;
1318 oss << std::fixed << std::setprecision(8) << notional2 * fx;
1319 // report.next().add(tradeId).add("notionalInBaseCurrency[2]").add("double").add(oss.str());
1320 }
1321
1322 // Just use the unadjusted trade ID in the additional results report for the main instrument.
1323 // If we have one or more additional instruments, use "_i" as suffix where i = 1, 2, 3, ... for each
1324 // additional instrument in turn and underscore as prefix to reduce risk of ID clash. We also add the
1325 // multiplier as an extra additional result if additional results exist.
1326 auto instruments = trade->instrument()->additionalInstruments();
1327 auto multipliers = trade->instrument()->additionalMultipliers();
1328 QL_REQUIRE(instruments.size() == multipliers.size(),
1329 "Expected the number of "
1330 << "additional instruments (" << instruments.size() << ") to equal the number of "
1331 << "additional multipliers (" << multipliers.size() << ").");
1332
1333 for (Size i = 0; i <= instruments.size(); ++i) {
1334
1335 if (i > 0 && instruments[i - 1] == nullptr)
1336 continue;
1337
1338 std::map<std::string, boost::any> thisAddResults =
1339 i == 0 ? additionalResults : instruments[i - 1]->additionalResults();
1340
1341 // Trade ID suffix for additional instruments. Put underscores to reduce risk of clash with other IDs in
1342 // the portfolio (still a risk).
1343 tradeId = i == 0 ? trade->id() : ("_" + trade->id() + "_" + std::to_string(i));
1344
1345 // Add the multiplier if there are additional results.
1346 // Check on 'instMultiplier' already existing is probably unnecessary.
1347 if (!thisAddResults.empty() && thisAddResults.count("instMultiplier") == 0) {
1348 thisAddResults["instMultiplier"] = i == 0 ? trade->instrument()->multiplier() : multipliers[i - 1];
1349 }
1350
1351 // Write current instrument's additional results.
1352 for (const auto& kv : thisAddResults) {
1353 // some results are stored as maps. We loop over these so that there is one result per line
1354 if (kv.second.type() == typeid(result_type_matrix)) {
1355 addMapResults<result_type_matrix>(kv.second, tradeId, kv.first, report);
1356 } else if (kv.second.type() == typeid(result_type_vector)) {
1357 addMapResults<result_type_vector>(kv.second, tradeId, kv.first, report);
1358 } else if (kv.second.type() == typeid(result_type_scalar)) {
1359 addMapResults<result_type_scalar>(kv.second, tradeId, kv.first, report);
1360 } else {
1361 auto p = parseBoostAny(kv.second, precision);
1362 if (boost::starts_with(p.first, "vector")) {
1363 vector<std::string> tokens;
1364 string vect = p.second;
1365 vect.erase(remove(vect.begin(), vect.end(), '\"'), vect.end());
1366 boost::split(tokens, vect, boost::is_any_of(","));
1367 for (Size i = 0; i < tokens.size(); i++) {
1368 boost::trim(tokens[i]);
1369 report.next()
1370 .add(tradeId)
1371 .add(kv.first + "[" + std::to_string(i) + "]")
1372 .add(p.first.substr(7))
1373 .add(tokens[i]);
1374 }
1375 } else
1376 report.next().add(tradeId).add(kv.first).add(p.first).add(p.second);
1377 }
1378 }
1379 }
1380 } catch (const std::exception& e) {
1381 StructuredTradeErrorMessage(trade->id(), trade->tradeType(),
1382 "Error during trade pricing (additional results)", e.what())
1383 .log();
1384 }
1385 }
1386
1387 report.end();
1388
1389 LOG("AdditionalResults report written");
1390}
1391
1392void ReportWriter::addMarketDatum(Report& report, const ore::data::MarketDatum& md, const Date& actualDate) {
1393 const Date& d = actualDate == Null<Date>() ? md.asofDate() : actualDate;
1394 report.next().add(d).add(md.name()).add(md.quote()->value());
1395}
1396
1397void ReportWriter::writeMarketData(Report& report, const QuantLib::ext::shared_ptr<Loader>& loader, const Date& asof,
1398 const set<string>& quoteNames, bool returnAll) {
1399
1400 LOG("Writing MarketData report");
1401
1402 report.addColumn("datumDate", Date()).addColumn("datumId", string()).addColumn("datumValue", double(), 10);
1403
1404 if (returnAll) {
1405 for (const auto& md : loader->loadQuotes(asof)) {
1406 addMarketDatum(report, *md, loader->actualDate());
1407 }
1408 return;
1409 }
1410
1411 set<string> names;
1412 set<string> regexStrs;
1413 partitionQuotes(quoteNames, names, regexStrs);
1414
1415 vector<std::regex> regexes;
1416 regexes.reserve(regexStrs.size());
1417 for (auto regexStr : regexStrs) {
1418 regexes.push_back(regex(regexStr));
1419 }
1420
1421 for (const auto& md : loader->loadQuotes(asof)) {
1422 const auto& mdName = md->name();
1423
1424 if (names.find(mdName) != names.end()) {
1425 addMarketDatum(report, *md, loader->actualDate());
1426 continue;
1427 }
1428
1429 // This could be slow
1430 for (const auto& regex : regexes) {
1431 if (regex_match(mdName, regex)) {
1432 addMarketDatum(report, *md, loader->actualDate());
1433 break;
1434 }
1435 }
1436 }
1437
1438 report.end();
1439 LOG("MarketData report written");
1440}
1441
1442void ReportWriter::writeFixings(Report& report, const QuantLib::ext::shared_ptr<Loader>& loader) {
1443
1444 LOG("Writing Fixings report");
1445
1446 report.addColumn("fixingDate", Date()).addColumn("fixingId", string()).addColumn("fixingValue", double(), 10);
1447
1448 for (const auto& f : loader->loadFixings()) {
1449 report.next().add(f.date).add(f.name).add(f.fixing);
1450 }
1451
1452 report.end();
1453 LOG("Fixings report written");
1454}
1455
1456void ReportWriter::writeDividends(Report& report, const QuantLib::ext::shared_ptr<Loader>& loader) {
1457
1458 LOG("Writing Dividends report");
1459
1460 report.addColumn("dividendExDate", Date())
1461 .addColumn("equityId", string())
1462 .addColumn("dividendRate", double(), 10)
1463 .addColumn("dividendPaymentDate", Date());
1464
1465 for (const auto& f : loader->loadDividends()) {
1466 report.next().add(f.exDate).add(f.name).add(f.rate).add(f.payDate);
1467 }
1468
1469 report.end();
1470 LOG("Dividends report written");
1471}
1472
1473void ReportWriter::writePricingStats(ore::data::Report& report, const QuantLib::ext::shared_ptr<Portfolio>& portfolio) {
1474
1475 LOG("Writing Pricing stats report");
1476
1477 report.addColumn("TradeId", string())
1478 .addColumn("TradeType", string())
1479 .addColumn("NumberOfPricings", Size())
1480 .addColumn("CumulativeTiming", Size())
1481 .addColumn("AverageTiming", Size());
1482
1483 for (auto const& [tid, trade] : portfolio->trades()) {
1484 std::size_t num = trade->getNumberOfPricings();
1485 Size cumulative = trade->getCumulativePricingTime() / 1000;
1486 Size average = num > 0 ? cumulative / num : 0;
1487 report.next().add(tid).add(trade->tradeType()).add(num).add(cumulative).add(average);
1488 }
1489
1490 report.end();
1491 LOG("Pricing stats report written");
1492}
1493
1494void ReportWriter::writeCube(ore::data::Report& report, const QuantLib::ext::shared_ptr<NPVCube>& cube,
1495 const std::map<std::string, std::string>& nettingSetMap) {
1496 LOG("Writing cube report");
1497
1498 report.addColumn("Id", string())
1499 .addColumn("NettingSet", string())
1500 .addColumn("DateIndex", Size())
1501 .addColumn("Date", string())
1502 .addColumn("Sample", Size())
1503 .addColumn("Depth", Size())
1504 .addColumn("Value", double(), 4);
1505
1506 const map<string, Size>& idsAndPos = cube->idsAndIndexes();
1507 vector<string> dateStrings(cube->numDates());
1508 for (Size i = 0; i < cube->numDates(); ++i) {
1509 std::ostringstream oss;
1510 oss << QuantLib::io::iso_date(cube->dates()[i]);
1511 dateStrings[i] = oss.str();
1512 }
1513
1514 std::ostringstream oss;
1515 oss << QuantLib::io::iso_date(cube->asof());
1516 string asofString = oss.str();
1517
1518 vector<string> ids(idsAndPos.size());
1519 vector<string> nettingSetIds(idsAndPos.size());
1520 for (const auto& [id, idCubePos] : idsAndPos) {
1521 ids[idCubePos] = id;
1522 auto it = nettingSetMap.find(id);
1523 if (it != nettingSetMap.end())
1524 nettingSetIds[idCubePos] = it->second;
1525 else
1526 nettingSetIds[idCubePos] = "";
1527 }
1528
1529 // T0
1530 for (Size i = 0; i < ids.size(); ++i) {
1531 report.next();
1532 report.add(ids[i])
1533 .add(nettingSetIds[i])
1534 .add(static_cast<Size>(0))
1535 .add(asofString)
1536 .add(static_cast<Size>(0))
1537 .add(static_cast<Size>(0))
1538 .add(cube->getT0(i));
1539 }
1540
1541 // Cube
1542 for (Size i = 0; i < ids.size(); i++) {
1543 for (Size j = 0; j < cube->numDates(); j++) {
1544 for (Size k = 0; k < cube->samples(); k++) {
1545 for (Size l = 0; l < cube->depth(); l++) {
1546 report.next();
1547 report.add(ids[i])
1548 .add(nettingSetIds[i])
1549 .add(j + 1)
1550 .add(dateStrings[j])
1551 .add(k+1)
1552 .add(l)
1553 .add(cube->get(i, j, k, l));
1554 }
1555 }
1556 }
1557 }
1558
1559 report.end();
1560
1561 LOG("Cube report written");
1562}
1563
1564// Ease notation again
1565typedef CrifRecord::ProductClass ProductClass;
1566typedef SimmConfiguration::RiskClass RiskClass;
1567typedef SimmConfiguration::MarginType MarginType;
1568typedef SimmConfiguration::SimmSide SimmSide;
1569
1570void ReportWriter::writeSIMMReport(
1571 const map<SimmSide, map<NettingSetDetails, pair<string, SimmResults>>>& finalSimmResultsMap,
1572 const QuantLib::ext::shared_ptr<Report> report, const bool hasNettingSetDetails, const string& simmResultCcy,
1573 const string& simmCalcCcyCall, const string& simmCalcCcyPost, const string& reportCcy, Real fxSpot,
1574 Real outputThreshold) {
1575
1576
1577 // Transform final SIMM results
1578 map<SimmSide, map<NettingSetDetails, map<string, SimmResults>>> finalSimmResults;
1579 for (const auto& sv : finalSimmResultsMap) {
1580 const SimmSide& side = sv.first;
1581 for (const auto& nv : sv.second) {
1582 const NettingSetDetails& nettingSetDetails = nv.first;
1583 const string& regulation = nv.second.first;
1584 const SimmResults& simmResults = nv.second.second;
1585
1586 finalSimmResults[side][nettingSetDetails][regulation] = simmResults;
1587 }
1588 }
1589
1590 writeSIMMReport(finalSimmResults, report, hasNettingSetDetails, simmResultCcy, simmCalcCcyCall, simmCalcCcyPost,
1591 reportCcy, true, fxSpot, outputThreshold);
1592}
1593
1594void ReportWriter::writeSIMMReport(
1595 const map<SimmSide, map<NettingSetDetails, map<string, SimmResults>>>& simmResultsMap,
1596 const QuantLib::ext::shared_ptr<Report> report, const bool hasNettingSetDetails, const string& simmResultCcy,
1597 const string& simmCalcCcyCall, const string& simmCalcCcyPost, const string& reportCcy, const bool isFinalSimm, Real fxSpot,
1598 Real outputThreshold) {
1599
1600 if (isFinalSimm) {
1601 LOG("Writing SIMM results report.");
1602 } else {
1603 LOG("Writing full SIMM results report.");
1604 }
1605
1606 // netting set headers
1607 report->addColumn("Portfolio", string());
1608 if (hasNettingSetDetails) {
1609 for (const string& field : NettingSetDetails::optionalFieldNames())
1610 report->addColumn(field, string());
1611 }
1612
1613 report->addColumn("ProductClass", string())
1614 .addColumn("RiskClass", string())
1615 .addColumn("MarginType", string())
1616 .addColumn("Bucket", string())
1617 .addColumn("SimmSide", string())
1618 .addColumn("Regulation", string())
1619 .addColumn("InitialMargin", double(), 2)
1620 .addColumn("Currency", string())
1621 .addColumn("CalculationCurrency", string());
1622 if (!reportCcy.empty()) {
1623 report->addColumn("InitialMargin(Report)", double(), 2).addColumn("ReportCurrency", string());
1624 }
1625
1626 // Ensure that fxSpot is 1 if no reporting currency provided
1627 if (reportCcy.empty() && fxSpot != 1.0)
1628 fxSpot = 1.0;
1629
1630 const vector<SimmSide> sides({SimmSide::Call, SimmSide::Post});
1631 for (const SimmSide side : sides) {
1632 const string& sideString = ore::data::to_string(side);
1633
1634 // Variable to hold sum of initial margin over all portfolios
1635 Real sumSidePortfolios = 0.0;
1636 Real sumSidePortfoliosReporting = 0.0;
1637
1638 set<string> winningRegs;
1639 if (simmResultsMap.find(side) != simmResultsMap.end()) {
1640 for (const auto& nv : simmResultsMap.at(side)) {
1641 const NettingSetDetails& portfolioId = nv.first;
1642 const auto& simmResultsMap = nv.second;
1643
1644 if (isFinalSimm)
1645 QL_REQUIRE(simmResultsMap.size() <= 1,
1646 "Final SIMM results should only have one (winning) regulation per netting set.");
1647
1648 for (const auto& rv : simmResultsMap) {
1649 const string& regulation = rv.first;
1650 const SimmResults& results = rv.second;
1651
1652 if (isFinalSimm)
1653 winningRegs.insert(regulation);
1654
1655 QL_REQUIRE(results.resultCurrency() == simmResultCcy,
1656 "writeSIMMReport(): SIMM results ("
1657 << results.resultCurrency() << ") should be denominated in the SIMM result currency ("
1658 << simmResultCcy << ").");
1659
1660 // Loop over the results for this portfolio
1661 for (const auto& result : results.data()) {
1662 // Get the key values
1663 const auto& key = result.first;
1664 ProductClass pc = get<0>(key);
1665 RiskClass rc = get<1>(key);
1666 MarginType mt = get<2>(key);
1667 string b = get<3>(key);
1668 Real im = result.second;
1669 Real simmReporting = 0.0;
1670
1671 // Write row if IM not negligible relative to outputThreshold.
1672 if (fabs(im) >= outputThreshold ||
1673 (pc == ProductClass::All && rc == RiskClass::All && mt == MarginType::All)) {
1674 report->next();
1675 map<string, string> nettingSetMap = portfolioId.mapRepresentation();
1676 for (const string& field : NettingSetDetails::fieldNames(hasNettingSetDetails)) {
1677 report->add(nettingSetMap[field]);
1678 }
1679 report->add(ore::data::to_string(pc))
1680 .add(ore::data::to_string(rc))
1681 .add(ore::data::to_string(mt))
1682 .add(b)
1683 .add(sideString)
1684 .add(regulation)
1685 .add(result.second)
1686 .add(results.resultCurrency())
1687 .add(results.calculationCurrency());
1688 if (!reportCcy.empty()) {
1689 simmReporting = result.second * fxSpot;
1690 report->add(simmReporting).add(reportCcy);
1691 }
1692 // Update aggregate portfolio IM value if necessary
1693 // SimmResults should always contain an entry with this key - it is the portfolio IM
1694 if (isFinalSimm &&
1695 (pc == ProductClass::All && rc == RiskClass::All && mt == MarginType::All)) {
1696 sumSidePortfolios += result.second;
1697 sumSidePortfoliosReporting += simmReporting;
1698 }
1699 }
1700 }
1701 }
1702 }
1703 }
1704
1705 // Write out a row for the aggregate IM over all portfolios
1706 // We only write out this row if either reporting ccy was provided or if currency of all the results is the same
1707 if (isFinalSimm) {
1708 string finalWinningReg = winningRegs.size() == 1 ? *(winningRegs.begin()) : "";
1709
1710 // Write out common columns
1711 report->next();
1712 Size numNettingSetFields = NettingSetDetails::fieldNames(hasNettingSetDetails).size();
1713 for (Size t = 0; t < numNettingSetFields; t++)
1714 report->add("All");
1715 report->add("All")
1716 .add("All")
1717 .add("All")
1718 .add("All")
1719 .add(sideString)
1720 .add(finalWinningReg)
1721 .add(sumSidePortfolios)
1722 .add(simmResultCcy)
1723 .add(side == SimmSide::Call ? simmCalcCcyCall : simmCalcCcyPost);
1724
1725 // Write out SIMM in reporting currency if we can
1726 if (!reportCcy.empty())
1727 report->add(sumSidePortfoliosReporting).add(reportCcy);
1728 }
1729
1730 report->end();
1731
1732 LOG("SIMM results report written.");
1733 }
1734}
1735
1736void ReportWriter::writeSIMMData(const ore::analytics::Crif& simmData, const QuantLib::ext::shared_ptr<Report>& dataReport,
1737 const bool hasNettingSetDetails) {
1738
1739 LOG("Writing SIMM data report.");
1740
1741 // Add the headers to the report
1742
1743 bool hasRegulations = false;
1744 for (const auto& cr : simmData) {
1745 if (!cr.collectRegulations.empty() || !cr.postRegulations.empty()) {
1746 hasRegulations = true;
1747 break;
1748 }
1749 }
1750
1751 // netting set headers
1752 dataReport->addColumn("Portfolio", string());
1753 if (hasNettingSetDetails) {
1754 for (const string& field : NettingSetDetails::optionalFieldNames())
1755 dataReport->addColumn(field, string());
1756 }
1757
1758 dataReport->addColumn("RiskType", string())
1759 .addColumn("ProductClass", string())
1760 .addColumn("Bucket", string())
1761 .addColumn("Qualifier", string())
1762 .addColumn("Label1", string())
1763 .addColumn("Label2", string())
1764 .addColumn("Amount", double())
1765 .addColumn("IMModel", string());
1766
1767 if (hasRegulations)
1768 dataReport->addColumn("collect_regulations", string())
1769 .addColumn("post_regulations", string());
1770
1771 // Write the report body by looping over the netted CRIF records
1772 for (const auto& cr : simmData) {
1773 // Skip to next netted CRIF record if 'AmountUSD' is negligible
1774 if (close_enough(cr.amountUsd, 0.0))
1775 continue;
1776
1777 // Skip Schedule IM records
1778 if (cr.imModel == "Schedule")
1779 continue;
1780
1781 // Same check as above, but for backwards compatibility, if im_model is not used
1782 // but Risk::Type is PV or Notional
1783 if (cr.imModel.empty() &&
1784 (cr.riskType == CrifRecord::RiskType::Notional || cr.riskType == CrifRecord::RiskType::PV))
1785 continue;
1786
1787 // Write current netted CRIF record
1788 dataReport->next();
1789 map<string, string> nettingSetMap = cr.nettingSetDetails.mapRepresentation();
1790 for (const string& field : NettingSetDetails::fieldNames(hasNettingSetDetails))
1791 dataReport->add(nettingSetMap[field]);
1792 dataReport->add(ore::data::to_string(cr.riskType))
1793 .add(ore::data::to_string(cr.productClass))
1794 .add(cr.bucket)
1795 .add(cr.qualifier)
1796 .add(cr.label1)
1797 .add(cr.label2)
1798 .add(cr.amountUsd)
1799 .add(cr.imModel);
1800
1801 if (hasRegulations) {
1802 string collectRegString = cr.collectRegulations.find(',') == string::npos
1803 ? cr.collectRegulations
1804 : '\"' + cr.collectRegulations + '\"';
1805 string postRegString = cr.postRegulations.find(',') == string::npos
1806 ? cr.postRegulations
1807 : '\"' + cr.postRegulations + '\"';
1808
1809 dataReport->add(collectRegString)
1810 .add(postRegString);
1811 }
1812 }
1813
1814 dataReport->end();
1815
1816 LOG("SIMM data report written.");
1817}
1818
1819void ReportWriter::writeCrifReport(const QuantLib::ext::shared_ptr<Report>& report, const Crif& crif) {
1820
1821 // If we have SIMM parameters, check if at least one of them uses netting set details optional field/s
1822 // It is easier to check here than to pass the flag from other places, since otherwise we'd have to handle certain edge cases
1823 // e.g. SIMM parameters use optional NSDs, but trades don't. So SIMM report should not display NSDs, but CRIF report still should.
1824 bool hasNettingSetDetails = false;
1825 for (const auto& cr : crif) {
1826 if (!cr.nettingSetDetails.emptyOptionalFields())
1827 hasNettingSetDetails = true;
1828 }
1829
1830 std::vector<string> addFields;
1831 bool hasCollectRegulations = false;
1832 bool hasPostRegulations = false;
1833 bool hasScheduleTrades = false;
1834 for (const auto& cr : crif) {
1835 // Check which additional fields are being used/populated
1836 for (const auto& af : cr.additionalFields) {
1837 if (std::find(addFields.begin(), addFields.end(), af.first) == addFields.end()) {
1838 addFields.push_back(af.first);
1839 }
1840 }
1841
1842 // Check if regulations are being used
1843 if (!hasCollectRegulations)
1844 hasCollectRegulations = !cr.collectRegulations.empty();
1845 if (!hasPostRegulations)
1846 hasPostRegulations = !cr.postRegulations.empty();
1847
1848 // Check if there are Schedule trades
1849 if (!hasScheduleTrades) {
1850 try {
1851 hasScheduleTrades = parseIMModel(cr.imModel) == SimmConfiguration::IMModel::Schedule;
1852 } catch (std::exception&) {
1853 }
1854 }
1855 }
1856
1857 // Add report headers
1858
1859 report->addColumn("TradeID", string()).addColumn("PortfolioID", string());
1860
1861 // Add additional netting set fields if netting set details are being used instead of just the netting set ID
1862 if (hasNettingSetDetails) {
1863 for (const string& optionalField : NettingSetDetails::optionalFieldNames())
1864 report->addColumn(optionalField, string());
1865 }
1866
1867 report->addColumn("ProductClass", string())
1868 .addColumn("RiskType", string())
1869 .addColumn("Qualifier", string())
1870 .addColumn("Bucket", string())
1871 .addColumn("Label1", string())
1872 .addColumn("Label2", string())
1873 .addColumn("AmountCurrency", string())
1874 .addColumn("Amount", double(), 2)
1875 .addColumn("AmountUSD", double(), 2)
1876 .addColumn("IMModel", string())
1877 .addColumn("TradeType", string());
1878
1879 if (hasScheduleTrades || crif.type() == Crif::CrifType::Frtb)
1880 report->addColumn("end_date", string());
1881
1882 if (crif.type() == Crif::CrifType::Frtb) {
1883 report->addColumn("Label3", string())
1884 .addColumn("CreditQuality", string())
1885 .addColumn("LongShortInd", string())
1886 .addColumn("CoveredBondInd", string())
1887 .addColumn("TrancheThickness", string())
1888 .addColumn("BB_RW", string());
1889 }
1890
1891 if (hasCollectRegulations)
1892 report->addColumn("collect_regulations", string());
1893
1894 if (hasPostRegulations)
1895 report->addColumn("post_regulations", string());
1896
1897 // Add additional CRIF fields
1898 for (const string& f : addFields) {
1899 report->addColumn(f, string());
1900 }
1901
1902 // Write individual CRIF records
1903 for (const auto& cr : crif) {
1904
1905 report->next().add(cr.tradeId).add(cr.portfolioId);
1906
1907 if (hasNettingSetDetails) {
1908 map<string, string> crNettingSetDetailsMap = NettingSetDetails(cr.nettingSetDetails).mapRepresentation();
1909 for (const string& optionalField : NettingSetDetails::optionalFieldNames())
1910 report->add(crNettingSetDetailsMap[optionalField]);
1911 }
1912
1913 report->add(ore::data::to_string(cr.productClass))
1914 .add(ore::data::to_string(cr.riskType))
1915 .add(cr.qualifier)
1916 .add(cr.bucket)
1917 .add(cr.label1)
1918 .add(cr.label2)
1919 .add(cr.amountCurrency)
1920 .add(cr.amount)
1921 .add(cr.amountUsd)
1922 .add(cr.imModel)
1923 .add(cr.tradeType);
1924
1925 if (hasScheduleTrades || crif.type() == Crif::CrifType::Frtb)
1926 report->add(cr.endDate);
1927
1928 if (crif.type() == Crif::CrifType::Frtb) {
1929 report->add(cr.label3)
1930 .add(cr.creditQuality)
1931 .add(cr.longShortInd)
1932 .add(cr.coveredBondInd)
1933 .add(cr.trancheThickness)
1934 .add(cr.bb_rw);
1935 }
1936
1937 if (hasCollectRegulations) {
1938 string regString = escapeCommaSeparatedList(cr.collectRegulations, '\0');
1939 report->add(regString);
1940 }
1941
1942 if (hasPostRegulations) {
1943 string regString = escapeCommaSeparatedList(cr.postRegulations, '\0');
1944 report->add(regString);
1945 }
1946
1947 for (const string& af : addFields) {
1948 if (cr.additionalFields.find(af) == cr.additionalFields.end())
1949 report->add("");
1950 else
1951 report->add(cr.getAdditionalFieldAsStr(af));
1952 }
1953 }
1954
1955 report->end();
1956}
1957
1958void ReportWriter::writeScenarioStatistics(const QuantLib::ext::shared_ptr<ScenarioGenerator>& generator,
1959 const std::vector<RiskFactorKey>& keys, const Size numPaths,
1960 const std::vector<Date>& dates, ore::data::Report& report) {
1961 report.addColumn("Date", Date())
1962 .addColumn("Key", string())
1963 .addColumn("min", double(), 8)
1964 .addColumn("mean", double(), 8)
1965 .addColumn("max", double(), 8)
1966 .addColumn("stddev", double(), 8)
1967 .addColumn("skewness", double(), 8)
1968 .addColumn("kurtosis", double(), 8);
1969
1970 std::vector<boost::accumulators::accumulator_set<
1971 double, boost::accumulators::stats<boost::accumulators::tag::min, boost::accumulators::tag::max,
1972 boost::accumulators::tag::mean, boost::accumulators::tag::variance,
1973 boost::accumulators::tag::skewness, boost::accumulators::tag::kurtosis>>>
1974 acc(keys.size() * dates.size());
1975
1976 for (Size i = 0; i < numPaths; ++i) {
1977 for (Size d = 0; d < dates.size(); ++d) {
1978 QuantLib::ext::shared_ptr<Scenario> currentScenario = generator->next(dates[d]);
1979 for (Size k = 0; k < keys.size(); ++k) {
1980 acc[d * keys.size() + k](currentScenario->get(keys[k]));
1981 }
1982 }
1983 }
1984 for (Size d = 0; d < dates.size(); ++d) {
1985 for (Size k = 0; k < keys.size(); ++k) {
1986 Size idx = d * keys.size() + k;
1987 report.next()
1988 .add(dates[d])
1989 .add(ore::data::to_string(keys[k]))
1990 .add(boost::accumulators::min(acc[idx]))
1991 .add(boost::accumulators::mean(acc[idx]))
1992 .add(boost::accumulators::max(acc[idx]))
1993 .add(std::sqrt(boost::accumulators::variance(acc[idx])));
1994 if (!close_enough(boost::accumulators::variance(acc[idx]), 0.0)) {
1995 report.add(boost::accumulators::skewness(acc[idx])).add(boost::accumulators::kurtosis(acc[idx]));
1996 }
1997 else {
1998 // avoid ReportWriter::non-sensical output
1999 report.add(0.0).add(0.0);
2000 }
2001 }
2002 }
2003 report.end();
2004}
2005
2006namespace {
2007template <class I>
2008void distributionCount(I begin, I end, const Size steps, std::vector<Real>& bounds, std::vector<Size>& counts) {
2009 Real xmin = *std::min_element(begin, end);
2010 Real xmax = *std::max_element(begin, end);
2011 std::vector<Real> v(begin, end);
2012 std::sort(v.begin(), v.end());
2013 Real h = (xmax - xmin) / static_cast<Real>(steps);
2014 Size idx0 = 0;
2015 counts.resize(steps);
2016 bounds.resize(steps);
2017 for (Size i = 0; i < steps; ++i) {
2018 Real v1 = xmin + static_cast<Real>(i + 1) * h;
2019 // Need the `i == steps - 1` here because noticed in backtest regression tests that xmax is not getting
2020 // included in the count in the last bucket due to numerical accuracy. This ensures that it does.
2021 Size idx1 = i == steps - 1 ? v.size() : std::upper_bound(v.begin(), v.end(), v1) - v.begin();
2022 counts[i] = idx1 - idx0;
2023 bounds[i] = v1;
2024 idx0 = idx1;
2025 }
2026} // distributionCount
2027} // namespace
2028
2029void ReportWriter::writeScenarioDistributions(const QuantLib::ext::shared_ptr<ScenarioGenerator>& generator,
2030 const std::vector<RiskFactorKey>& keys, const Size numPaths,
2031 const std::vector<Date>& dates, const Size distSteps,
2032 ore::data::Report& report) {
2033 report.addColumn("Date", Date())
2034 .addColumn("Key", string())
2035 .addColumn("Bound", double(), 8)
2036 .addColumn("Count", Size());
2037
2038 std::vector<std::vector<std::vector<Real>>> values(
2039 dates.size(), std::vector<std::vector<Real>>(keys.size(), std::vector<Real>(numPaths, 0.0)));
2040
2041 for (Size i = 0; i < numPaths; ++i) {
2042 for (Size d = 0; d < dates.size(); ++d) {
2043 QuantLib::ext::shared_ptr<Scenario> currentScenario = generator->next(dates[d]);
2044 for (Size k = 0; k < keys.size(); ++k) {
2045 values[d][k][i] = currentScenario->get(keys[k]);
2046 }
2047 }
2048 }
2049
2050 std::vector<Real> bounds;
2051 std::vector<Size> counts;
2052 for (Size d = 0; d < dates.size(); ++d) {
2053 for (Size k = 0; k < keys.size(); ++k) {
2054 distributionCount(values[d][k].begin(), values[d][k].end(), distSteps, bounds, counts);
2055 for (Size i = 0; i < distSteps; ++i) {
2056 report.next().add(dates[d]).add(ore::data::to_string(keys[k])).add(bounds[i]).add(counts[i]);
2057 }
2058 }
2059 }
2060 report.end();
2061}
2062
2063void ReportWriter::writeHistoricalScenarioDetails(
2064 const QuantLib::ext::shared_ptr<ore::analytics::HistoricalScenarioGenerator>& generator, ore::data::Report& report) {
2065
2066 report.addColumn("PLDate1", Date())
2067 .addColumn("PLDate2", Date())
2068 .addColumn("Key", string())
2069 .addColumn("BaseValue", double(), 8)
2070 .addColumn("AdjustmentFactor1", double(), 8)
2071 .addColumn("AdjustmentFactor2", double(), 8)
2072 .addColumn("ScenarioValue1", double(), 8)
2073 .addColumn("ScenarioValue2", double(), 8)
2074 .addColumn("ShiftType", string())
2075 .addColumn("Return", double(), 8)
2076 .addColumn("ScenarioValue", double(), 8);
2077
2078 Date asof = generator->baseScenario()->asof();
2079 for (Size i = 0; i < generator->startDates().size(); ++i) {
2080 std::ignore = generator->next(asof);
2081 for (auto const& d : generator->lastHistoricalScenarioCalculationDetails()) {
2082 report.next()
2083 .add(d.scenarioDate1)
2084 .add(d.scenarioDate2)
2085 .add(ore::data::to_string(d.key))
2086 .add(d.baseValue)
2087 .add(d.adjustmentFactor1)
2088 .add(d.adjustmentFactor2)
2089 .add(d.scenarioValue1)
2090 .add(d.scenarioValue2)
2091 .add(ore::data::to_string(d.returnType))
2092 .add(d.returnValue)
2093 .add(d.scenarioValue);
2094 }
2095 }
2096 report.end();
2097}
2098
2099void ReportWriter::writeStockSplitReport(const QuantLib::ext::shared_ptr<Scenario>& baseScenario,
2100 const QuantLib::ext::shared_ptr<ore::analytics::HistoricalScenarioLoader>& hsloader,
2101 const QuantLib::ext::shared_ptr<ore::data::AdjustmentFactors>& adjFactors,
2102 const QuantLib::ext::shared_ptr<ore::data::Report>& report) {
2103
2104 report->addColumn("EquityId", string())
2105 .addColumn("Date", Date())
2106 .addColumn("Price", double(), 8)
2107 .addColumn("Factor", double(), 8)
2108 .addColumn("CumulatedFactor", double(), 8)
2109 .addColumn("AdjustedPrice", double(), 8);
2110
2111 if (adjFactors) {
2112 std::set<std::string> names;
2113 for (auto const& k : baseScenario->keys()) {
2114 if (k.keytype == RiskFactorKey::KeyType::EquitySpot) {
2115 names.insert(k.name);
2116 }
2117 }
2118
2119 std::vector<QuantLib::Date> hsdates = hsloader->dates();
2120
2121 for (auto const& name : names) {
2122
2123 std::set<QuantLib::Date> dates = adjFactors->dates(name);
2124 dates.insert(hsdates.begin(), hsdates.end());
2125
2126 for (auto const& d : dates) {
2127
2128 Real price = Null<Real>();
2129 if (std::find(hsdates.begin(), hsdates.end(), d) != hsdates.end()) {
2130 auto scen = hsloader->getHistoricalScenario(d);
2131 RiskFactorKey rf(RiskFactorKey::KeyType::EquitySpot, name);
2132 if (scen->has(rf))
2133 price = scen->get(rf);
2134 }
2135 Real factor = adjFactors->getFactorContribution(name, d);
2136 Real cumFactor = adjFactors->getFactor(name, d);
2137 Real adjPrice = price == Null<Real>() ? Null<Real>() : price * cumFactor;
2138
2139 report->next().add(name).add(d).add(price).add(factor).add(cumFactor).add(adjPrice);
2140 }
2141 }
2142 }
2143 report->end();
2144}
2145
2146void ReportWriter::writeHistoricalScenarioDistributions(
2147 QuantLib::ext::shared_ptr<HistoricalScenarioGenerator>& hsgen,
2148 const QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarket>& simMarket,
2149 const QuantLib::ext::shared_ptr<ore::analytics::ScenarioSimMarketParameters>& simMarketParams,
2150 QuantLib::ext::shared_ptr<ore::data::Report> histScenDetailsReport, QuantLib::ext::shared_ptr<ore::data::Report> statReport,
2151 QuantLib::ext::shared_ptr<ore::data::Report> distReport, Size distSteps) {
2152
2153 // Don't leave it up to the caller to do this
2154 simMarket->scenarioGenerator() = hsgen;
2155 hsgen->baseScenario() = simMarket->baseScenario();
2156
2157 // If both report pointers are null, return early
2158 if (!statReport && !distReport)
2159 return;
2160
2161 // Make a transformed generator i.e. discount -> zero etc.
2162 auto hsgent = QuantLib::ext::make_shared<HistoricalScenarioGeneratorTransform>(hsgen, simMarket, simMarketParams);
2163
2164 const vector<RiskFactorKey>& keys = hsgen->baseScenario()->keys();
2165 Size numScen = hsgen->numScenarios();
2166 Date asof = hsgen->baseScenario()->asof();
2167
2168 // Write the statistics report if requested
2169 if (statReport) {
2170 hsgent->reset();
2171 writeScenarioStatistics(hsgent, keys, numScen, {asof}, *statReport);
2172 }
2173
2174 // Write the distribution report if requested
2175 if (distReport) {
2176 QL_REQUIRE(distSteps != Null<Size>(),
2177 "When creating a distribution report, a valid distribution step size is required");
2178 hsgent->reset();
2179 writeScenarioDistributions(hsgent, keys, numScen, {asof}, distSteps, *distReport);
2180 }
2181
2182 // Write the scenario report if requested
2183 if (histScenDetailsReport) {
2184 hsgent->reset();
2185 writeHistoricalScenarioDetails(hsgent, *histScenDetailsReport);
2186 }
2187}
2188
2189void ReportWriter::writeHistoricalScenarios(const QuantLib::ext::shared_ptr<HistoricalScenarioLoader>& hsloader,
2190 const QuantLib::ext::shared_ptr<ore::data::Report>& report) {
2191 // each scenario might have a different set of keys, so we collect the union of all keys
2192 // and write them out (missing keys will be written as NA to the report)
2193 std::set<RiskFactorKey> allKeys;
2194 for (const auto& s : hsloader->historicalScenarios())
2195 allKeys.insert(s->keys().begin(), s->keys().end());
2196 ScenarioWriter sw(nullptr, report, std::vector<RiskFactorKey>(allKeys.begin(), allKeys.end()));
2197 bool writeHeader = true;
2198 for (const auto& s : hsloader->historicalScenarios()) {
2199 sw.writeScenario(s, writeHeader);
2200 writeHeader = false;
2201 }
2202}
2203
2204// Ease notation again
2205typedef CrifRecord::ProductClass ProductClass;
2206typedef SimmConfiguration::RiskClass RiskClass;
2207typedef SimmConfiguration::MarginType MarginType;
2208typedef SimmConfiguration::SimmSide SimmSide;
2209typedef IMScheduleCalculator::IMScheduleTradeData IMScheduleTradeData;
2210
2211void ReportWriter::writeIMScheduleSummaryReport(
2212 const map<SimmSide, map<NettingSetDetails, pair<string, IMScheduleResults>>>& finalResultsMap,
2213 const QuantLib::ext::shared_ptr<Report> report, const bool hasNettingSetDetails, const string& simmResultCcy,
2214 const string& reportCcy, Real fxSpot, Real outputThreshold) {
2215
2216 LOG("Writing IM Schedule results summary report.");
2217
2218 // netting set headers
2219 report->addColumn("Portfolio", string());
2220 if (hasNettingSetDetails) {
2221 for (const string& field : NettingSetDetails::optionalFieldNames())
2222 report->addColumn(field, string());
2223 }
2224
2225 report->addColumn("ProductClass", string())
2226 .addColumn("GrossIM", double(), 2)
2227 .addColumn("GrossCurrentRC", double(), 2)
2228 .addColumn("NetCurrentRC", double(), 2)
2229 .addColumn("NetToGrossRatio", double(), 6)
2230 .addColumn("Side", string())
2231 .addColumn("Regulation", string())
2232 .addColumn("ScheduleIM", double(), 2)
2233 .addColumn("Currency", string());
2234 if (!reportCcy.empty()) {
2235 report->addColumn("ScheduleIM(Report)", double(), 2).addColumn("ReportCurrency", string());
2236 }
2237
2238 const vector<SimmSide> sides({SimmSide::Call, SimmSide::Post});
2239 for (const SimmSide side : sides) {
2240 const string& sideString = to_string(side);
2241
2242 // Variable to hold sum of schedule IM over all portfolios
2243 Real sumSideScheduleIM = 0.0;
2244 Real sumSideScheduleIMReporting = 0.0;
2245
2246 std::set<std::string> winningRegs;
2247 if (finalResultsMap.find(side) != finalResultsMap.end()) {
2248 for (const auto& nv : finalResultsMap.at(side)) {
2249 const NettingSetDetails& portfolioId = nv.first;
2250 const string& regulation = nv.second.first;
2251 const IMScheduleResults& results = nv.second.second;
2252
2253 winningRegs.insert(regulation);
2254
2255 QL_REQUIRE(results.currency() == simmResultCcy,
2256 "writeIMScheduleSummaryReport(): IMSchedule results ("
2257 << results.currency() << ") should be denominated in the SIMM result currency ("
2258 << simmResultCcy << ").");
2259
2260 // Loop over the results for this portfolio
2261 for (const auto& imScheduleResult : results.data()) {
2262 ProductClass pc = imScheduleResult.first;
2263 IMScheduleResult result = imScheduleResult.second;
2264
2265 Real im = pc == ProductClass::All ? result.scheduleIM : result.grossIM;
2266
2267 report->next();
2268 const map<string, string> nettingSetMap = portfolioId.mapRepresentation();
2269 for (const string& field : NettingSetDetails::fieldNames(hasNettingSetDetails)) {
2270 report->add(nettingSetMap.at(field));
2271 }
2272 report->add(to_string(pc))
2273 .add(result.grossIM)
2274 .add(result.grossRC)
2275 .add(result.netRC)
2276 .add(result.NGR)
2277 .add(sideString)
2278 .add(regulation)
2279 .add(im)
2280 .add(results.currency());
2281
2282 if (!reportCcy.empty()) {
2283 Real scheduleIMReporting = im * fxSpot;
2284 report->add(scheduleIMReporting).add(reportCcy);
2285
2286 if (pc == ProductClass::All)
2287 sumSideScheduleIMReporting += scheduleIMReporting;
2288 }
2289
2290 if (pc == ProductClass::All)
2291 sumSideScheduleIM += result.scheduleIM;
2292 }
2293 }
2294 }
2295
2296 // Write out a row for the aggregate IM over all portfolios
2297 // We only write out this row if either reporting ccy was provided or if currency of all the results is the same
2298 string finalWinningReg = winningRegs.size() == 1 ? *(winningRegs.begin()) : "";
2299
2300 // Write out common columns
2301 report->next();
2302 Size numNettingSetFields = NettingSetDetails::fieldNames(hasNettingSetDetails).size();
2303 for (Size t = 0; t < numNettingSetFields; t++)
2304 report->add("All");
2305 report->add(to_string(ProductClass::All))
2306 .add(Null<Real>())
2307 .add(Null<Real>())
2308 .add(Null<Real>())
2309 .add(Null<Real>())
2310 .add(sideString)
2311 .add(finalWinningReg)
2312 .add(sumSideScheduleIM)
2313 .add(simmResultCcy);
2314
2315 // Write out schedule IM in reporting currency if we can
2316 if (!reportCcy.empty())
2317 report->add(sumSideScheduleIMReporting).add(reportCcy);
2318 }
2319
2320 report->end();
2321
2322 LOG("IM Schedule results summary report written.");
2323}
2324
2325void ReportWriter::writeIMScheduleTradeReport(const map<string, vector<IMScheduleTradeData>>& tradeResults,
2326 const QuantLib::ext::shared_ptr<ore::data::Report> report,
2327 const bool hasNettingSetDetails) {
2328
2329 LOG("Writing IM Schedule trade results report.");
2330
2331 report->addColumn("TradeId", string());
2332
2333 // netting set headers
2334 report->addColumn("Portfolio", string());
2335 if (hasNettingSetDetails) {
2336 for (const string& field : NettingSetDetails::optionalFieldNames())
2337 report->addColumn(field, string());
2338 }
2339
2340 report->addColumn("ProductClass", string())
2341 .addColumn("EndDate", string())
2342 .addColumn("Maturity", double(), 5)
2343 .addColumn("Label", string())
2344 .addColumn("Multiplier", double(), 2)
2345 .addColumn("Notional", double(), 2)
2346 .addColumn("NotionalCurrency", string())
2347 .addColumn("PV", double(), 2)
2348 .addColumn("PVCurrency", string())
2349 .addColumn("Notional(Base)", double(), 2)
2350 .addColumn("PV(Base)", double(), 2)
2351 .addColumn("BaseCurrency", string())
2352 .addColumn("GrossIM(Base)", double(), 2)
2353 .addColumn("CollectRegulations", string())
2354 .addColumn("PostRegulations", string());
2355
2356 // Variable to hold sum of schedule IM over all portfolios
2357 for (const auto& kv : tradeResults) {
2358 const string& tradeId = kv.first;
2359
2360 for (const IMScheduleTradeData& tradeData : kv.second) {
2361 const NettingSetDetails& portfolioId = tradeData.nettingSetDetails;
2362
2363 // Write row if IM not negligible relative to outputThreshold.
2364 report->next();
2365 report->add(tradeId);
2366
2367 const map<string, string> nettingSetMap = portfolioId.mapRepresentation();
2368 for (const string& field : NettingSetDetails::fieldNames(hasNettingSetDetails)) {
2369 report->add(nettingSetMap.at(field));
2370 }
2371 const string collectRegsString = tradeData.collectRegulations.find(',') == string::npos
2372 ? tradeData.collectRegulations
2373 : '\"' + tradeData.collectRegulations + '\"';
2374 const string postRegsString = tradeData.postRegulations.find(',') == string::npos
2375 ? tradeData.postRegulations
2376 : '\"' + tradeData.postRegulations + '\"';
2377 report->add(to_string(tradeData.productClass))
2378 .add(to_string(tradeData.endDate))
2379 .add(tradeData.maturity)
2380 .add(tradeData.labelString)
2381 .add(tradeData.multiplier)
2382 .add(tradeData.notional)
2383 .add(tradeData.notionalCcy)
2384 .add(tradeData.presentValue)
2385 .add(tradeData.presentValueCcy)
2386 .add(tradeData.notionalCalc)
2387 .add(tradeData.presentValueCalc)
2388 .add(tradeData.calculationCcy)
2389 .add(tradeData.grossMarginCalc)
2390 .add(collectRegsString)
2391 .add(postRegsString);
2392 }
2393 }
2394
2395 report->end();
2396
2397 LOG("IM Schedule trade results report written.");
2398}
2399
2400Real aggregateTradeFlow(const std::string& tradeId, const Date& d0, const Date& d1,
2401 const ext::shared_ptr<InMemoryReport>& cashFlowReport,
2402 const ext::shared_ptr<ore::data::Market>& market,
2403 const std::string& baseCurrency) {
2404 Size tradeIdColumn = 0;
2405 Size dateColumn = 4;
2406 Size amountColumn = 6;
2407 Size ccyColumn = 7;
2408 QL_REQUIRE(cashFlowReport->header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
2409 QL_REQUIRE(cashFlowReport->header(amountColumn) == "Amount", "incorrect trade id column " << amountColumn);
2410 QL_REQUIRE(cashFlowReport->header(ccyColumn) == "Currency", "incorrect trade id column " << ccyColumn);
2411 QL_REQUIRE(cashFlowReport->header(dateColumn) == "PayDate", "incorrect trade id column " << dateColumn);
2412
2413 Real flow = 0.0;
2414 for (Size i = 0; i < cashFlowReport->rows(); ++i) {
2415 string id = boost::get<string>(cashFlowReport->data(tradeIdColumn).at(i));
2416 if (id != tradeId)
2417 continue;
2418 Date date = boost::get<Date>(cashFlowReport->data(dateColumn).at(i));
2419 if (date <= d0 || date > d1)
2420 continue;
2421 string ccy = boost::get<string>(cashFlowReport->data(ccyColumn).at(i));
2422 Real amount = boost::get<Real>(cashFlowReport->data(amountColumn).at(i));
2423 Real fx = 1.0;
2424 if (ccy != baseCurrency)
2425 fx = market->fxRate(ccy + baseCurrency)->value();
2426 flow += fx * amount;
2427 }
2428
2429 return flow;
2430}
2431
2432void ReportWriter::writePnlReport(ore::data::Report& report,
2433 const ext::shared_ptr<InMemoryReport>& t0NpvReport,
2434 const ext::shared_ptr<InMemoryReport>& t0NpvLaggedReport,
2435 const ext::shared_ptr<InMemoryReport>& t1NpvLaggedReport,
2436 const ext::shared_ptr<InMemoryReport>& t1NpvReport,
2437 const ext::shared_ptr<InMemoryReport>& t0CashFlowReport,
2438 const Date& startDate, const Date& endDate,
2439 const std::string& baseCurrency,
2440 const ext::shared_ptr<ore::data::Market>& market,
2441 const std::string& configuration,
2442 const ext::shared_ptr<Portfolio>& portfolio) {
2443
2444 LOG("PnL report");
2445
2446 report.addColumn("TradeId", string())
2447 .addColumn("TradeType", string())
2448 .addColumn("Maturity", Date())
2449 .addColumn("MaturityTime", double(), 6)
2450 .addColumn("StartDate", Date())
2451 .addColumn("EndDate", Date())
2452 .addColumn("NPV(t0)", double(), 6)
2453 .addColumn("NPV(asof=t0;mkt=t1)", double(), 6)
2454 .addColumn("NPV(asof=t1;mkt=t0)", double(), 6)
2455 .addColumn("NPV(t1)", double(), 6)
2456 .addColumn("PeriodCashFlow", double(), 6)
2457 .addColumn("Theta", double(), 6)
2458 .addColumn("HypotheticalCleanPnL", double(), 6)
2459 .addColumn("CleanPnL", double(), 6)
2460 .addColumn("DirtyPnL", double(), 6)
2461 .addColumn("Currency", string());
2462
2463 Size tradeIdColumn = 0;
2464 Size tradeTypeColumn = 1;
2465 Size maturityDateColumn = 2;
2466 Size maturityTimeColumn = 3;
2467 Size npvBaseColumn = 6;
2468 Size baseCcyColumn = 7;
2469
2470 QL_REQUIRE(t0NpvReport->rows() == t0NpvLaggedReport->rows(), "different number of rows in npv reports");
2471 QL_REQUIRE(t0NpvReport->rows() == t1NpvLaggedReport->rows(), "different number of rows in npv reports");
2472 QL_REQUIRE(t0NpvReport->rows() == t1NpvReport->rows(), "different number of rows in npv reports");
2473
2474 QL_REQUIRE(t0NpvReport->header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
2475 QL_REQUIRE(t0NpvReport->header(tradeTypeColumn) == "TradeType", "incorrect trade type column " << tradeTypeColumn);
2476 QL_REQUIRE(t0NpvReport->header(maturityDateColumn) == "Maturity", "incorrect maturity date column " << maturityDateColumn);
2477 QL_REQUIRE(t0NpvReport->header(maturityTimeColumn) == "MaturityTime", "incorrect maturity time column " << maturityTimeColumn);
2478 QL_REQUIRE(t0NpvReport->header(npvBaseColumn) == "NPV(Base)", "incorrect npv base column " << npvBaseColumn);
2479 QL_REQUIRE(t0NpvReport->header(baseCcyColumn) == "BaseCurrency", "incorrect base currency column " << baseCcyColumn);
2480
2481 QL_REQUIRE(t0NpvLaggedReport->header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
2482 QL_REQUIRE(t0NpvLaggedReport->header(tradeTypeColumn) == "TradeType", "incorrect trade type column " << tradeTypeColumn);
2483 QL_REQUIRE(t0NpvLaggedReport->header(maturityDateColumn) == "Maturity", "incorrect maturity date column " << maturityDateColumn);
2484 QL_REQUIRE(t0NpvLaggedReport->header(maturityTimeColumn) == "MaturityTime", "incorrect maturity time column " << maturityTimeColumn);
2485 QL_REQUIRE(t0NpvLaggedReport->header(npvBaseColumn) == "NPV(Base)", "incorrect npv base column " << npvBaseColumn);
2486 QL_REQUIRE(t0NpvLaggedReport->header(baseCcyColumn) == "BaseCurrency", "incorrect base currency column " << baseCcyColumn);
2487
2488 QL_REQUIRE(t1NpvLaggedReport->header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
2489 QL_REQUIRE(t1NpvLaggedReport->header(tradeTypeColumn) == "TradeType", "incorrect trade type column " << tradeTypeColumn);
2490 QL_REQUIRE(t1NpvLaggedReport->header(maturityDateColumn) == "Maturity", "incorrect maturity date column " << maturityDateColumn);
2491 QL_REQUIRE(t1NpvLaggedReport->header(maturityTimeColumn) == "MaturityTime", "incorrect maturity time column " << maturityTimeColumn);
2492 QL_REQUIRE(t1NpvLaggedReport->header(npvBaseColumn) == "NPV(Base)", "incorrect npv base column " << npvBaseColumn);
2493 QL_REQUIRE(t1NpvLaggedReport->header(baseCcyColumn) == "BaseCurrency", "incorrect base currency column " << baseCcyColumn);
2494
2495 QL_REQUIRE(t1NpvReport->header(tradeIdColumn) == "TradeId", "incorrect trade id column " << tradeIdColumn);
2496 QL_REQUIRE(t1NpvReport->header(tradeTypeColumn) == "TradeType", "incorrect trade type column " << tradeTypeColumn);
2497 QL_REQUIRE(t1NpvReport->header(maturityDateColumn) == "Maturity", "incorrect maturity date column " << maturityDateColumn);
2498 QL_REQUIRE(t1NpvReport->header(maturityTimeColumn) == "MaturityTime", "incorrect maturity time column " << maturityTimeColumn);
2499 QL_REQUIRE(t1NpvReport->header(npvBaseColumn) == "NPV(Base)", "incorrect npv base column " << npvBaseColumn);
2500 QL_REQUIRE(t1NpvReport->header(baseCcyColumn) == "BaseCurrency", "incorrect base currency column " << baseCcyColumn);
2501
2502 for (Size i = 0; i < t0NpvReport->rows(); ++i) {
2503 try {
2504 string tradeId = boost::get<string>(t0NpvReport->data(tradeIdColumn).at(i));
2505 string tradeId2 = boost::get<string>(t0NpvLaggedReport->data(tradeIdColumn).at(i));
2506 string tradeId3 = boost::get<string>(t1NpvLaggedReport->data(tradeIdColumn).at(i));
2507 string tradeId4 = boost::get<string>(t1NpvReport->data(tradeIdColumn).at(i));
2508 QL_REQUIRE(tradeId == tradeId2 && tradeId == tradeId3 && tradeId == tradeId4, "inconsistent ordering of NPV reports");
2509 string tradeType = boost::get<string>(t0NpvReport->data(tradeTypeColumn).at(i));
2510 Date maturityDate = boost::get<Date>(t0NpvReport->data(maturityDateColumn).at(i));
2511 Real maturityTime = boost::get<Real>(t0NpvReport->data(maturityTimeColumn).at(i));
2512 string ccy = boost::get<string>(t0NpvReport->data(baseCcyColumn).at(i));
2513 QL_REQUIRE(ccy == baseCurrency, "inconsistent NPV and base currencies");
2514 Real t0Npv = boost::get<Real>(t0NpvReport->data(npvBaseColumn).at(i));
2515 Real t0NpvLagged = boost::get<Real>(t0NpvLaggedReport->data(npvBaseColumn).at(i));
2516 Real t1NpvLagged = boost::get<Real>(t1NpvLaggedReport->data(npvBaseColumn).at(i));
2517 Real t1Npv = boost::get<Real>(t1NpvReport->data(npvBaseColumn).at(i));
2518
2519 Real hypotheticalCleanPnl = t0NpvLagged - t0Npv;
2520 Real periodFlow = aggregateTradeFlow(tradeId, startDate, endDate, t0CashFlowReport, market, baseCurrency);
2521 Real theta = t1NpvLagged - t0Npv + periodFlow;
2522 Real dirtyPnl = t1Npv - t0Npv;
2523 Real cleanPnl = dirtyPnl + periodFlow;
2524 LOG("PnL report, writing line " << i << " tradeId " << tradeId);
2525
2526 report.next()
2527 .add(tradeId)
2528 .add(tradeType)
2529 .add(maturityDate)
2530 .add(maturityTime)
2531 .add(startDate)
2532 .add(endDate)
2533 .add(t0Npv)
2534 .add(t0NpvLagged)
2535 .add(t1NpvLagged)
2536 .add(t1Npv)
2537 .add(periodFlow)
2538 .add(theta)
2539 .add(hypotheticalCleanPnl)
2540 .add(cleanPnl)
2541 .add(dirtyPnl)
2542 .add(ccy);
2543
2544 } catch (std::exception& e) {
2545 ALOG("Error writing PnL report line: " << e.what());
2546 }
2547 }
2548
2549 report.end();
2550
2551 LOG("PnL report written.");
2552}
2553
2554} // namespace analytics
2555} // namespace ore
ore::analytics::AggregationScenarioData
Container for storing simulated market data.
Definition: aggregationscenariodata.hpp:58
ore::analytics::Crif::type
CrifType type() const
Definition: crif.hpp:40
ore::analytics::IMScheduleResults::currency
const std::string & currency() const
Definition: imscheduleresults.hpp:97
ore::analytics::IMScheduleResults::data
const std::map< CrifRecord::ProductClass, IMScheduleResult > & data() const
Return the map containing the results.
Definition: imscheduleresults.hpp:95
ore::analytics::ReportWriter::writeNettingSetCvaSensitivities
virtual void writeNettingSetCvaSensitivities(ore::data::Report &report, QuantLib::ext::shared_ptr< PostProcess > postProcess, const std::string &nettingSetId)
Definition: reportwriter.cpp:938
ore::analytics::ReportWriter::writeCashflowNpv
virtual void writeCashflowNpv(ore::data::Report &report, const ore::data::InMemoryReport &cashflowReport, QuantLib::ext::shared_ptr< ore::data::Market > market, const std::string &configuration, const std::string &baseCcy, const Date &horizon=Date::maxDate())
Definition: reportwriter.cpp:656
ore::analytics::ReportWriter::writeNettingSetExposures
virtual void writeNettingSetExposures(ore::data::Report &report, QuantLib::ext::shared_ptr< PostProcess > postProcess, const std::string &nettingSetId)
Definition: reportwriter.cpp:906
ore::analytics::ReportWriter::writeCurves
virtual void writeCurves(ore::data::Report &report, const std::string &configID, const DateGrid &grid, const TodaysMarketParameters &marketConfig, const QuantLib::ext::shared_ptr< Market > &market, const bool continueOnError=false)
Definition: reportwriter.cpp:717
ore::analytics::ReportWriter::writeTradeExposures
virtual void writeTradeExposures(ore::data::Report &report, QuantLib::ext::shared_ptr< PostProcess > postProcess, const std::string &tradeId)
Definition: reportwriter.cpp:818
ore::analytics::ReportWriter::writeCashflow
virtual void writeCashflow(ore::data::Report &report, const std::string &baseCurrency, QuantLib::ext::shared_ptr< ore::data::Portfolio > portfolio, QuantLib::ext::shared_ptr< ore::data::Market > market=QuantLib::ext::shared_ptr< ore::data::Market >(), const std::string &configuration=ore::data::Market::defaultConfiguration, const bool includePastCashflows=false)
Definition: reportwriter.cpp:149
ore::analytics::ReportWriter::writeXVA
virtual void writeXVA(ore::data::Report &report, const string &allocationMethod, QuantLib::ext::shared_ptr< Portfolio > portfolio, QuantLib::ext::shared_ptr< PostProcess > postProcess)
Definition: reportwriter.cpp:958
ore::analytics::ReportWriter::writeNpv
virtual void writeNpv(ore::data::Report &report, const std::string &baseCurrency, QuantLib::ext::shared_ptr< ore::data::Market > market, const std::string &configuration, QuantLib::ext::shared_ptr< Portfolio > portfolio)
Definition: reportwriter.cpp:80
ore::analytics::RiskFactorKey
Data types stored in the scenario class.
Definition: scenario.hpp:48
ore::analytics::ScenarioWriter
Class for writing scenarios to file.
Definition: scenariowriter.hpp:34
ore::analytics::ScenarioWriter::writeScenario
void writeScenario(const QuantLib::ext::shared_ptr< Scenario > &s, const bool writeHeader)
Write a single scenario.
Definition: scenariowriter.cpp:73
ore::analytics::SimmConfiguration::SimmSide
SimmSide
Enum indicating the relevant side of the SIMM calculation.
Definition: simmconfiguration.hpp:44
ore::data::DateGrid::size
QuantLib::Size size() const
ore::data::DateGrid::tenors
const std::vector< QuantLib::Period > & tenors() const
ore::data::InMemoryReport::header
const string & header(Size i) const
ore::data::InMemoryReport::data
const vector< ReportType > & data(Size i) const
ore::data::MarketDatum::quote
const Handle< Quote > & quote() const
ore::data::MarketDatum::name
const string & name() const
ore::data::NettingSetDetails::mapRepresentation
const map< string, string > mapRepresentation() const
ore::data::Report::add
virtual Report & add(const ReportType &rt)=0
ore::data::Report::next
virtual Report & next()=0
ore::data::Report::end
virtual void end()=0
ore::data::Report::addColumn
virtual Report & addColumn(const string &name, const ReportType &, Size precision=0)=0
ore::data::TodaysMarketParameters::hasConfiguration
bool hasConfiguration(const string &configuration) const
ore::data::TodaysMarketParameters::mapping
const map< string, string > & mapping(const MarketObject o, const string &configuration) const
ore::data::TodaysMarketParameters::hasMarketObject
bool hasMarketObject(const MarketObject &o) const
parseBoostAny
pair< string, string > parseBoostAny(const boost::any &anyType, Size precision)
data
data
LOG
#define LOG(text)
DLOG
#define DLOG(text)
ALOG
#define ALOG(text)
WLOG
#define WLOG(text)
maturity
Time maturity
fixingDate
QuantLib::Date fixingDate(const QuantLib::Date &d, const QuantLib::Period obsLag, const QuantLib::Frequency freq, bool interpolated)
close_enough
Filter close_enough(const RandomVariable &x, const RandomVariable &y)
log
RandomVariable log(RandomVariable x)
QuantExt::unpackIndexedCoupon
boost::shared_ptr< Coupon > unpackIndexedCoupon(const boost::shared_ptr< Coupon > &c)
generator
Matrix generator(const Matrix &t, const Real horizon)
ore::analytics::addMapResults
void addMapResults(boost::any resultMap, const std::string &tradeId, const std::string &resultName, Report &report)
Definition: reportwriter.cpp:1253
ore::analytics::RiskClass
SimmConfiguration::RiskClass RiskClass
Definition: reportwriter.cpp:1566
ore::analytics::MarginType
SimmConfiguration::MarginType MarginType
Definition: reportwriter.cpp:1567
ore::analytics::ProductClass
CrifRecord::ProductClass ProductClass
Definition: reportwriter.cpp:1565
ore::analytics::parseIMModel
SimmConfiguration::IMModel parseIMModel(const string &model)
Definition: simmconfiguration.cpp:288
ore::analytics::reconstructFactor
string reconstructFactor(const RiskFactorKey &key, const string &desc)
Reconstruct the string description from a risk factor key and its index description desc.
Definition: shiftscenariogenerator.cpp:180
ore::analytics::result_type_vector
std::map< Currency, std::vector< Real >, CurrencyComparator > result_type_vector
Definition: reportwriter.cpp:77
ore::analytics::escapeCommaSeparatedList
std::string escapeCommaSeparatedList(const std::string &str, const char &csvQuoteChar)
Definition: utilities.cpp:248
ore::analytics::result_type_scalar
std::map< Currency, Real, CurrencyComparator > result_type_scalar
Definition: reportwriter.cpp:78
ore::analytics::addNettingSetExposure
void addNettingSetExposure(ore::data::Report &report, QuantLib::ext::shared_ptr< PostProcess > postProcess, const string &nettingSetId)
Definition: reportwriter.cpp:869
ore::analytics::aggregateTradeFlow
Real aggregateTradeFlow(const std::string &tradeId, const Date &d0, const Date &d1, const ext::shared_ptr< InMemoryReport > &cashFlowReport, const ext::shared_ptr< ore::data::Market > &market, const std::string &baseCurrency)
Definition: reportwriter.cpp:2400
ore::analytics::result_type_matrix
std::map< Currency, Matrix, CurrencyComparator > result_type_matrix
Definition: reportwriter.cpp:76
prettyPrintInternalCurveName
std::string prettyPrintInternalCurveName(std::string name)
size
Size size(const ValueType &v)
ore::data::to_string
std::string to_string(const LocationInfo &l)
partitionQuotes
void partitionQuotes(const set< string > &quoteNames, set< string > &names, set< string > &regexes)
reportwriter.hpp
A Class to write ORE outputs to reports.
scenariowriter.hpp
ScenarioWriter class.
structuredanalyticserror.hpp
Structured analytics error.
steps
std::vector< Size > steps
asof
Date asof(14, Jun, 2018)
to_string.hpp
name
string name
utilities.hpp
supporting utilities
Generated by Doxygen 1.9.5