Work in progress, fix overlapping closeout grid

Author: mgroncki

OREAnalytics/orea/app/analytics/xvaanalytic.cpp

@@ -757,6 +757,8 @@ void XvaAnalyticImpl::runAnalytic(const boost::shared_ptr<ore::data::InMemoryLoa
         map<string, string> nettingSetMap = analytic()->portfolio()->nettingSetMap();
         auto report = boost::make_shared<InMemoryReport>();
         ReportWriter(inputs_->reportNaString()).writeCube(*report, cube_, nettingSetMap);
+        auto csvReprt = boost::make_shared<CSVFileReport>("test_report.csv");
+        ReportWriter(inputs_->reportNaString()).writeCube(*csvReprt, cube_, nettingSetMap);
         analytic()->reports()["XVA"]["rawcube"] = report;
     }
 

OREAnalytics/orea/engine/amcvaluationengine.cpp

@@ -90,15 +90,18 @@ Real discount(const boost::shared_ptr<CrossAssetModel>& model,
 
 std::vector<QuantExt::RandomVariable>
 simulatePathInterface2(const boost::shared_ptr<AmcCalculator>& amcCalc, const std::vector<Real>& pathTimes,
-                       std::vector<std::vector<RandomVariable>>& paths, const std::vector<bool>& isRelevantTime,
+                       std::vector<std::vector<RandomVariable>>& paths, const std::vector<size_t>& pathIdx,
+                       const std::vector<size_t>& timeIdx,
                        const bool moveStateToPreviousTime, const std::string& tradeLabel,
                        const std::string& tradeType) {
+    QL_REQUIRE(pathIdx.size() == timeIdx.size(),
+               "internal error, mismatch between relevant path idx and timegrid idx, please contact dev");
     try {
-        return amcCalc->simulatePath(pathTimes, paths, isRelevantTime, moveStateToPreviousTime);
+        return amcCalc->simulatePath(pathTimes, paths, pathIdx, timeIdx, moveStateToPreviousTime);
     } catch (const std::exception& e) {
         StructuredTradeErrorMessage(tradeLabel, tradeType, "error during amc path simulation for trade.", e.what())
             .log();
-        return std::vector<QuantExt::RandomVariable>(std::count(isRelevantTime.begin(), isRelevantTime.end(), true) + 1,
+        return std::vector<QuantExt::RandomVariable>(pathIdx.size() + 1,
                                                      RandomVariable(paths.front().front().size()));
     }
 }
@@ -406,44 +409,37 @@ void runCoreEngine(const boost::shared_ptr<ore::data::Portfolio>& portfolio,
     // Run AmcCalculators
 
     LOG("Run simulation...");
-
-    for (size_t i = 0; i < sgd->getGrid()->dates().size(); i++){
-        std::cout << i << " Date " << sgd->getGrid()->dates()[i] << std::endl;
-    }
-
-    for (size_t i = 0; i < sgd->getGrid()->times().size(); i++) {
-        std::cout << i << " time " << sgd->getGrid()->times()[i] << std::endl;
-    }
-
-    for (size_t i = 0; i < sgd->getGrid()->isCloseOutDate().size(); i++) {
-        std::cout << i << " isCloseOutDate " << sgd->getGrid()->isCloseOutDate()[i] << std::endl;
-    }
-
-    for (size_t i = 0; i < sgd->getGrid()->isValuationDate().size(); i++) {
-        std::cout << i << " isValuationDate " << sgd->getGrid()->isValuationDate()[i] << std::endl;
-    }
-
     // set up vectors indicating valuation times, close-out times and all times
 
-    std::vector<bool> allTimes(pathTimes.size(), true);
-    std::vector<bool> valuationTimes(pathTimes.size()), closeOutTimes(pathTimes.size());
-    for (Size i = 0; i < pathTimes.size(); ++i) {
-        std::cout << pathTimes[i] << " " << sgd->getGrid()->isValuationDate()[i] << " "
-                  << sgd->getGrid()->isCloseOutDate()[i] << std::endl;
-        valuationTimes[i] = sgd->getGrid()->isValuationDate()[i];
-        closeOutTimes[i] = sgd->getGrid()->isCloseOutDate()[i];
+    std::vector<size_t> allTimes;
+    std::vector<size_t> valuationTimeIdx, closeOutTimeIdx;
+    const auto& grid = sgd->getGrid();
+    const auto& dates = grid->dates();
+    size_t j = 0;
+    for (size_t i = 0; i < pathTimes.size(); ++i) {
+        allTimes.push_back(i);
+        auto& d = dates[i];
+        if (grid->isValuationDate()[i]) {
+            valuationTimeIdx.push_back(i);
+            auto closeOutDate = grid->closeOutDateFromValuationDate(d);
+            while (j < pathTimes.size() && dates[j] != closeOutDate) {
+                ++j;
+            }
+            QL_REQUIRE(j < pathTimes.size(), "couldnt find close out date");
+            closeOutTimeIdx.push_back(j);
+        }
     }
 
-    // loop over amc calculators, get result and populate cube
+        // loop over amc calculators, get result and populate cube
 
-    timer.start();
+        timer.start();
     for (Size j = 0; j < amcCalculators.size(); ++j) {
         auto resFee = feeContributions(j, sgd, model->irModel(0)->termStructure()->referenceDate(),
                                        outputCube->samples(), tradeFees, model, fxBuffer, irStateBuffer);
 
         if (!sgd->withCloseOutLag()) {
             // no close-out lag, fill depth 0 with npv on path
-            auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, allTimes, false, tradeLabel[j],
+            auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, allTimes, allTimes, false, tradeLabel[j],
                                               tradeType[j]);
             Real v = outputCube->getT0(tradeId[j], 0);
             outputCube->setT0(v +
@@ -467,16 +463,12 @@ void runCoreEngine(const boost::shared_ptr<ore::data::Portfolio>& portfolio,
         } else {
             // with close-out lag, fill depth 0 with valuation date npvs, depth 1 with (inflated) close-out npvs
             if (sgd->withMporStickyDate()) {
-                std::cout << "Simulate with sticky date the valuationTimes" << std::endl;
                 // sticky date mpor mode. simulate the valuation times...
-                auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, valuationTimes, false,
-                                                  tradeLabel[j], tradeType[j]);
+                auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, valuationTimeIdx,
+                                                  valuationTimeIdx, false, tradeLabel[j], tradeType[j]);
                 // ... and then the close-out times, but times moved to the valuation times
-                std::cout << "Simulate with sticky date the closeOutTimes" << std::endl;
-                
-                auto resLag = simulatePathInterface2(amcCalculators[j], pathTimes, paths, closeOutTimes, true,
-                                                     tradeLabel[j], tradeType[j]);
-                std::cout << "Finished closeOutTime simulation" << std::endl;
+                auto resLag = simulatePathInterface2(amcCalculators[j], pathTimes, paths, closeOutTimeIdx,
+                                                     valuationTimeIdx, true, tradeLabel[j], tradeType[j]);
                 Real v = outputCube->getT0(tradeId[j], 0);
                 outputCube->setT0(v +
                                       res[0].at(0) * fx(fxBuffer, currencyIndex[j], 0, 0) *
@@ -485,39 +477,33 @@ void runCoreEngine(const boost::shared_ptr<ore::data::Portfolio>& portfolio,
                                       resFee[0][0],
                                   tradeId[j], 0);
                 int dateIndex = -1;
-                std::map<QuantLib::Date, std::queue<std::tuple<QuantLib::Date, double, size_t>>> closeOutDateToValuationDate;
+                std::map<QuantLib::Date, std::vector<std::tuple<QuantLib::Date, double, size_t>>> closeOutDateToValuationDate;
                 for (Size k = 0; k < sgd->getGrid()->dates().size(); ++k) {
 
                     Real t = sgd->getGrid()->timeGrid()[k + 1];
-                    std::cout << k << " " << t << std::endl;
                     if (sgd->getGrid()->isCloseOutDate()[k]) {
                         Date closeOutDate = sgd->getGrid()->dates()[k];
                         auto dateIndexIt = closeOutDateToValuationDate.find(closeOutDate);
                         QL_REQUIRE(dateIndexIt != closeOutDateToValuationDate.end() && !dateIndexIt->second.empty(), 
                                     "The valuation date needs to before the corresponding close out date");
-                        Date valuationDate;
-                        double valuationTime;
-                        size_t valuationIndex;
-                        std::tie(valuationDate, valuationTime, valuationIndex) = dateIndexIt->second.front();
-                        dateIndexIt->second.pop();
-                        std::cout << "Is closeOut date: " << to_string(closeOutDate) << " for valuation Date " << to_string(valuationDate) << std::endl;
-                        for (Size i = 0; i < outputCube->samples(); ++i) {
-                            Real v = outputCube->get(tradeId[j], valuationIndex, i, 1);
-                            outputCube->set(
-                                v +
-                                    resLag[dateIndex + 1][i] * fx(fxBuffer, currencyIndex[j], k + 1, i) *
-                                        num(model, irStateBuffer, currencyIndex[j], k + 1, valuationTime, i) *
-                                        effectiveMultiplier[j] +
-                                    resFee[dateIndex + 1][i],
-                                tradeId[j], valuationIndex, i, 1);
+                        for (const auto& [valuationDate, valuationTime, valuationIndex] : dateIndexIt->second){
+                            for (Size i = 0; i < outputCube->samples(); ++i) {
+                                Real v = outputCube->get(tradeId[j], valuationIndex, i, 1);
+                                outputCube->set(
+                                    v +
+                                        resLag[valuationIndex + 1][i] * fx(fxBuffer, currencyIndex[j], k + 1, i) *
+                                            num(model, irStateBuffer, currencyIndex[j], k + 1, valuationTime, i) *
+                                            effectiveMultiplier[j] +
+                                        resFee[valuationIndex + 1][i],
+                                    tradeId[j], valuationIndex, i, 1);
+                            }
                         }
+                        
                     }
                     if (sgd->getGrid()->isValuationDate()[k]) {
                         Date valuationDate = sgd->getGrid()->dates()[k];
                         Date closeOutDate = sgd->getGrid()->closeOutDateFromValuationDate(valuationDate);
-                        std::cout << "Is valuationDate date: " << to_string(valuationDate) << " with Index " << to_string(dateIndex + 1)
-                                  << " and closeOutDate " << to_string(closeOutDate) << std::endl; 
-                        closeOutDateToValuationDate[closeOutDate].push(std::make_tuple(valuationDate, t, ++dateIndex));
+                        closeOutDateToValuationDate[closeOutDate].push_back(std::make_tuple(valuationDate, t, ++dateIndex));
                         for (Size i = 0; i < outputCube->samples(); ++i) {
                             Real v = outputCube->get(tradeId[j], dateIndex, i, 0);
                             outputCube->set(v +
@@ -531,14 +517,14 @@ void runCoreEngine(const boost::shared_ptr<ore::data::Portfolio>& portfolio,
                 }
             } else {
                 // actual date mpor mode: simulate all times in one go
-                auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, allTimes, false, tradeLabel[j],
-                                                  tradeType[j]);
+                auto res = simulatePathInterface2(amcCalculators[j], pathTimes, paths, allTimes, allTimes, false,
+                                                  tradeLabel[j], tradeType[j]);
                 Real v = outputCube->getT0(tradeId[j], 0);
                 outputCube->setT0(v + res[0].at(0) * fx(fxBuffer, currencyIndex[j], 0, 0) *
                                           numRatio(model, irStateBuffer, currencyIndex[j], 0, 0.0, 0) *
                                           effectiveMultiplier[j],
                                   tradeId[j], 0);
-                std::map<QuantLib::Date, std::queue<std::tuple<QuantLib::Date, double, size_t>>>
+                std::map<QuantLib::Date, std::vector<std::tuple<QuantLib::Date, double, size_t>>>
                     closeOutDateToValuationDate;
                 int dateIndex = -1;
                 for (Size k = 1; k < res.size(); ++k) {
@@ -548,24 +534,22 @@ void runCoreEngine(const boost::shared_ptr<ore::data::Portfolio>& portfolio,
                         auto dateIndexIt = closeOutDateToValuationDate.find(closeOutDate);
                         QL_REQUIRE(dateIndexIt != closeOutDateToValuationDate.end() && !dateIndexIt->second.empty(),
                                    "The valuation date needs to before the corresponding close out date");
-                        Date valuationDate;
-                        double valuationTime;
-                        size_t valuationIndex;
-                        std::tie(valuationDate, valuationTime, valuationIndex) = dateIndexIt->second.front();
-                        for (Size i = 0; i < outputCube->samples(); ++i) {
-                            Real v = outputCube->get(tradeId[j], valuationIndex, i, 1);
-                            outputCube->set(v +
-                                                res[k][i] * fx(fxBuffer, currencyIndex[j], k, i) *
-                                                    num(model, irStateBuffer, currencyIndex[j], k, t, i) *
-                                                    effectiveMultiplier[j] +
-                                                resFee[k][i],
-                                            tradeId[j], valuationIndex, i, 1);
+                        for (const auto& [valuationDate, valuationTime, valuationIndex] : dateIndexIt->second) {
+                            for (Size i = 0; i < outputCube->samples(); ++i) {
+                                Real v = outputCube->get(tradeId[j], valuationIndex, i, 1);
+                                outputCube->set(v +
+                                                    res[k][i] * fx(fxBuffer, currencyIndex[j], k, i) *
+                                                        num(model, irStateBuffer, currencyIndex[j], k, t, i) *
+                                                        effectiveMultiplier[j] +
+                                                    resFee[k][i],
+                                                tradeId[j], valuationIndex, i, 1);
+                            }
                         }
                     }
                     if (sgd->getGrid()->isValuationDate()[k - 1]) {
                         Date valuationDate = sgd->getGrid()->dates()[k - 1];
                         Date closeOutDate = sgd->getGrid()->closeOutDateFromValuationDate(valuationDate);
-                        closeOutDateToValuationDate[closeOutDate].push(std::make_tuple(valuationDate, t, ++dateIndex));
+                        closeOutDateToValuationDate[closeOutDate].push_back(std::make_tuple(valuationDate, t, ++dateIndex));
                         for (Size i = 0; i < outputCube->samples(); ++i) {
                             Real v = outputCube->get(tradeId[j], dateIndex, i, 0);
                             outputCube->set(v +

OREAnalytics/orea/engine/multithreadedvaluationengine.cpp

@@ -229,10 +229,10 @@ void MultiThreadedValuationEngine::buildCube(
     miniNettingSetCubes_.clear();
     miniCptyCubes_.clear();
     for (Size i = 0; i < eff_nThreads; ++i) {
-        miniCubes_.push_back(cubeFactory_(today_, portfolios[i]->ids(), dateGrid_->dates(), nSamples_));
-        miniNettingSetCubes_.push_back(nettingSetCubeFactory_(today_, dateGrid_->dates(), nSamples_));
+        miniCubes_.push_back(cubeFactory_(today_, portfolios[i]->ids(), dateGrid_->valuationDates(), nSamples_));
+        miniNettingSetCubes_.push_back(nettingSetCubeFactory_(today_, dateGrid_->valuationDates(), nSamples_));
         miniCptyCubes_.push_back(
-            cptyCubeFactory_(today_, portfolios[i]->counterparties(), dateGrid_->dates(), nSamples_));
+            cptyCubeFactory_(today_, portfolios[i]->counterparties(), dateGrid_->valuationDates(), nSamples_));
     }
 
     // build progress indicator consolidating the results from the threads