QPR-11659 add historical scenario details report

Author: pcaspers

OREAnalytics/orea/scenario/historicalscenariogenerator.cpp

@@ -137,6 +137,23 @@ Real ReturnConfiguration::applyReturn(const RiskFactorKey& key, const Real baseV
     return value;
 }
 
+const std::map<RiskFactorKey::KeyType, ReturnConfiguration::ReturnType> ReturnConfiguration::returnTypes() const {
+    return returnType_;
+}
+
+std::ostream& operator<<(std::ostream& out, const ReturnConfiguration::ReturnType t) {
+    switch (t) {
+    case ReturnConfiguration::ReturnType::Absolute:
+        return out << "Absolute";
+    case ReturnConfiguration::ReturnType::Relative:
+        return out << "Relative";
+    case ReturnConfiguration::ReturnType::Log:
+        return out << "Log";
+    default:
+        return out << "Unknown ReturnType (" << static_cast<int>(t) << ")";
+    }
+}
+
 void ReturnConfiguration::check(const RiskFactorKey& key) const {
 
     auto keyType = key.keytype;
@@ -223,6 +240,8 @@ boost::shared_ptr<Scenario> HistoricalScenarioGenerator::next(const Date& d) {
     boost::shared_ptr<Scenario> scen = scenarioFactory_->buildScenario(d, "", 1.0);
 
     // loop over all keys
+    calculationDetails_.resize(baseScenario_->keys().size());
+    Size calcDetailsCounter = 0;
     for (auto key : baseScenario_->keys()) {
         Real base = baseScenario_->get(key);
         Real v1 = 1.0, v2 = 1.0;
@@ -238,14 +257,29 @@ boost::shared_ptr<Scenario> HistoricalScenarioGenerator::next(const Date& d) {
         // Calculate the returned value
         Real returnVal = returnConfiguration_.returnValue(key, v1, v2, s1->asof(), s2->asof());
         // Adjust return for any scaling
-        returnVal = returnVal * scaling(key, returnVal);
+        Real scaling = this->scaling(key, returnVal);
+        returnVal = returnVal * scaling;
         // Calculate the shifted value
         value = returnConfiguration_.applyReturn(key, base, returnVal);
         if (std::isinf(value)) {
             ALOG("Value is inf for " << key << " from date " << s1->asof() << " to " << s2->asof());
         }
         // Add it
         scen->add(key, value);
+        // Populate calculation details
+        calculationDetails_[calcDetailsCounter].scenarioDate1 = s1->asof();
+        calculationDetails_[calcDetailsCounter].scenarioDate2 = s2->asof();
+        calculationDetails_[calcDetailsCounter].key = key;
+        calculationDetails_[calcDetailsCounter].baseValue = base;
+        calculationDetails_[calcDetailsCounter].adjustmentFactor1 = adjFactors_->getFactor(key.name, s1->asof());
+        calculationDetails_[calcDetailsCounter].adjustmentFactor2 = adjFactors_->getFactor(key.name, s2->asof());
+        calculationDetails_[calcDetailsCounter].scenarioValue1 = v1;
+        calculationDetails_[calcDetailsCounter].scenarioValue2 = v2;
+        calculationDetails_[calcDetailsCounter].returnType = returnConfiguration_.returnTypes().at(key.keytype);
+        calculationDetails_[calcDetailsCounter].scaling = scaling;
+        calculationDetails_[calcDetailsCounter].returnValue = returnVal;
+        calculationDetails_[calcDetailsCounter].scenarioValue = value;
+        ++calcDetailsCounter;
     }
 
     // Label the scenario
@@ -258,6 +292,11 @@ boost::shared_ptr<Scenario> HistoricalScenarioGenerator::next(const Date& d) {
     return scen;
 }
 
+const std::vector<HistoricalScenarioGenerator::HistoricalScenarioCalculationDetails>&
+HistoricalScenarioGenerator::lastHistoricalScenarioCalculationDetails() const {
+    return calculationDetails_;
+}
+
 Size HistoricalScenarioGenerator::numScenarios() const {
     // We have a start date for each valid scenario
     return startDates_.size();

OREAnalytics/orea/scenario/historicalscenariogenerator.hpp

@@ -58,13 +58,18 @@ class ReturnConfiguration {
     QuantLib::Real applyReturn(const RiskFactorKey& key, const QuantLib::Real baseValue,
         const QuantLib::Real returnValue) const;
 
+    //! get return types
+    const std::map<RiskFactorKey::KeyType, ReturnType> returnTypes() const;
+
 private:
     const std::map<RiskFactorKey::KeyType, ReturnType> returnType_;
 
     //! Perform checks on key
     void check(const RiskFactorKey& key) const;
 };
 
+std::ostream& operator<<(std::ostream& out, const ReturnConfiguration::ReturnType t);
+
 //! Historical Scenario Generator
 /*! A Scenario Generator that takes historical scenarios and builds new scenarios by applying historical shifts to the
  * base scenario (which typically comes from todays market).
@@ -78,6 +83,21 @@ class ReturnConfiguration {
  */
 class HistoricalScenarioGenerator : public ScenarioGenerator {
 public:
+    struct HistoricalScenarioCalculationDetails {
+        Date scenarioDate1;
+        Date scenarioDate2;
+        RiskFactorKey key;
+        double baseValue;
+        double adjustmentFactor1;
+        double adjustmentFactor2;
+        double scenarioValue1;
+        double scenarioValue2;
+        ReturnConfiguration::ReturnType returnType;
+        double scaling;
+        double returnValue;
+        double scenarioValue;
+    };
+
     //! Default constructor
     HistoricalScenarioGenerator(
         //! Historical Scenario Loader containing all scenarios
@@ -125,6 +145,9 @@ class HistoricalScenarioGenerator : public ScenarioGenerator {
     */
     boost::shared_ptr<Scenario> next(const QuantLib::Date& d) override;
 
+    //! Return the calculation details of the last generated scenario */
+    const std::vector<HistoricalScenarioCalculationDetails>& lastHistoricalScenarioCalculationDetails() const;
+
     //! Reset the generator so calls to next() return the first scenario.
     /*! This allows re-generation of scenarios if required. */
     void reset() override { i_ = 0; }
@@ -174,6 +197,9 @@ class HistoricalScenarioGenerator : public ScenarioGenerator {
         Only handles equity spot adjustments at the moment */
     QuantLib::Real adjustedPrice(RiskFactorKey key, QuantLib::Date d, QuantLib::Real price);
 
+    // details on the last generated scenario
+    std::vector<HistoricalScenarioCalculationDetails> calculationDetails_;
+
 private:
     QuantLib::Calendar cal_;
     boost::shared_ptr<ore::data::AdjustmentFactors> adjFactors_;