git subrepo pull (merge) ore

subrepo:
  subdir:   "ore"
  merged:   "9a48f18cf1"
upstream:
  origin:   "git@gitlab.acadiasoft.net:qs/ore.git"
  branch:   "master"
  commit:   "e9e7a78680"
git-subrepo:
  version:  "0.4.6"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "73a0129"

Author: jenkins

Docs/UserGuide/tradedata/compositetrade.tex

@@ -23,6 +23,19 @@ \subsubsection{Composite Trade}
 	\label{lst:compositetrade_data}
 \end{listing}
 
+\begin{listing}[H]
+	%\hrule\medskip
+	\begin{minted}[fontsize=\footnotesize]{xml}
+		<CompositeTradeData>
+		  <Currency>USD</Currency>
+		  <NotionalCalculation>Sum</NotionalCalculation>
+		  <PortfolioBasket>true</PortfolioBasket>
+		  <BasketName>NAME</BasketName>
+		</CompositeTradeData>
+	\end{minted}
+	\caption{Composite trade data with Reference Data}
+\end{listing}
+
 The meanings and allowable values of the elements in the \lstinline!CompositeTradeData!  node follow below.
 
 \begin{itemize}
@@ -43,4 +56,8 @@ \subsubsection{Composite Trade}
       Allowable values: Any non-negative real number.
 	\item Components: The portfolio of trades that make up the composite trade. \\
       Allowable values: These trades should be valid xmls that could otherwise be entered into the portfolio, with the exception that they can have empty ids.
+    \item PortfolioBasket [Optional]: Indicate if the Component represent a portfolio basket. \\
+    Allowable values: Boolean true or false.
+    \item BasketName [Optional]: The portfolio Id. \\
+    Allowable values: Any string. Note that if PortfolioBasket is True then there must be a BasketName. We look up the Basket within the reference data.
 \end{itemize}

OREData/ored/portfolio/compositetrade.cpp

@@ -38,20 +38,23 @@ void CompositeTrade::build(const QuantLib::ext::shared_ptr<EngineFactory>& engin
     fxRates_.clear();
     fxRatesNotional_.clear();
     legs_.clear();
-    QL_REQUIRE(trades_.size() > 0, "Failed to build composite trade.");
+
+    populateFromReferenceData(engineFactory->referenceData());
+
+    
     for (const QuantLib::ext::shared_ptr<Trade>& trade : trades_) {
 
-	trade->reset();
-	trade->build(engineFactory);
-	trade->validate();
+	    trade->reset();
+	    trade->build(engineFactory);
+	    trade->validate();
 
         if (sensitivityTemplate_.empty())
             setSensitivityTemplate(trade->sensitivityTemplate());
 
         Handle<Quote> fx = Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(1.0));
-	if (trade->npvCurrency() != npvCurrency_)
-	    fx = engineFactory->market()->fxRate(trade->npvCurrency() + npvCurrency_);
-	fxRates_.push_back(fx);
+	    if (trade->npvCurrency() != npvCurrency_)
+	        fx = engineFactory->market()->fxRate(trade->npvCurrency() + npvCurrency_);
+	    fxRates_.push_back(fx);
 
         Handle<Quote> fxNotional = Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(1.0));
         if (trade->notionalCurrency().empty()) {
@@ -69,29 +72,29 @@ void CompositeTrade::build(const QuantLib::ext::shared_ptr<EngineFactory>& engin
 
         QuantLib::ext::shared_ptr<InstrumentWrapper> instrumentWrapper = trade->instrument();
         Real effectiveMultiplier = instrumentWrapper->multiplier();
-	if (auto optionWrapper = QuantLib::ext::dynamic_pointer_cast<ore::data::OptionWrapper>(instrumentWrapper)) {
-	    effectiveMultiplier *= optionWrapper->isLong() ? 1.0 : -1.0;
-	}
-
-	compositeInstrument->add(instrumentWrapper->qlInstrument(), effectiveMultiplier, fx);
-	for (Size i = 0; i < instrumentWrapper->additionalInstruments().size(); ++i) {
-	    compositeInstrument->add(instrumentWrapper->additionalInstruments()[i],
-				     instrumentWrapper->additionalMultipliers()[i]);
-	}
-    
-    bool isDuplicate = false;
-    try {
-        if (instrumentWrapper->additionalResults().find("cashFlowResults") != trade->instrument()->additionalResults().end())
-            isDuplicate = true;
-    } catch (...) {}
-    if (!isDuplicate) {
-        // For cashflows
-        legs_.insert(legs_.end(), trade->legs().begin(), trade->legs().end());
-        legPayers_.insert(legPayers_.end(), trade->legPayers().begin(), trade->legPayers().end());
-        legCurrencies_.insert(legCurrencies_.end(), trade->legCurrencies().begin(), trade->legCurrencies().end());
-    }
+        if (auto optionWrapper = QuantLib::ext::dynamic_pointer_cast<ore::data::OptionWrapper>(instrumentWrapper)) {
+	        effectiveMultiplier *= optionWrapper->isLong() ? 1.0 : -1.0;
+	    }
+
+	    compositeInstrument->add(instrumentWrapper->qlInstrument(), effectiveMultiplier, fx);
+	    for (Size i = 0; i < instrumentWrapper->additionalInstruments().size(); ++i) {
+	        compositeInstrument->add(instrumentWrapper->additionalInstruments()[i],
+				         instrumentWrapper->additionalMultipliers()[i]);
+	    }
+
+        bool isDuplicate = false;
+        try {
+            if (instrumentWrapper->additionalResults().find("cashFlowResults") != trade->instrument()->additionalResults().end())
+                isDuplicate = true;
+        } catch (...) {}
+        if (!isDuplicate) {
+            // For cashflows
+            legs_.insert(legs_.end(), trade->legs().begin(), trade->legs().end());
+            legPayers_.insert(legPayers_.end(), trade->legPayers().begin(), trade->legPayers().end());
+            legCurrencies_.insert(legCurrencies_.end(), trade->legCurrencies().begin(), trade->legCurrencies().end());
+        }
 
-	maturity_ = std::max(maturity_, trade->maturity());
+	    maturity_ = std::max(maturity_, trade->maturity());
     }
     instrument_ = QuantLib::ext::shared_ptr<InstrumentWrapper>(new VanillaInstrument(compositeInstrument));
 
@@ -120,7 +123,6 @@ void CompositeTrade::fromXML(XMLNode* node) {
                "Wrong trade type in composite trade builder.");
     Trade::fromXML(node);
     this->id() = XMLUtils::getAttribute(node, "id");
-
     // We read the data particular to composite trades
     XMLNode* compNode = XMLUtils::getChildNode(node, "CompositeTradeData");
     QL_REQUIRE(compNode, "Could not find CompositeTradeData node.");
@@ -140,45 +142,58 @@ void CompositeTrade::fromXML(XMLNode* node) {
         QL_REQUIRE(notionalCalculation_ != "Override", "Notional override value has not been provided.");
     }
 
-    XMLNode* tradesNode = XMLUtils::getChildNode(compNode, "Components");
-    QL_REQUIRE(tradesNode, "Could not find Components node.");
+    if (XMLUtils::getChildNode(compNode, "PortfolioBasket")) {
+        portfolioBasket_ = XMLUtils::getChildValueAsBool(node, "PortfolioBasket", false);
+    } else {
+        portfolioBasket_ = false;
+    }
 
-    vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(tradesNode, "Trade");
-    for (Size i = 0; i < nodes.size(); i++) {
-        string tradeType = XMLUtils::getChildValue(nodes[i], "TradeType", true);
+    portfolioId_ = XMLUtils::getChildValue(compNode, "BasketName", false);
 
-        string id = XMLUtils::getAttribute(nodes[i], "id");
-        if (id == "") {
-            WLOG("Empty component trade id being overwritten in composite trade " << this->id() << ".");
-        }
-        id = this->id() + "_" + std::to_string(i);
-        DLOG("Parsing composite trade " << this->id() << " node " << i << " with id: " << id);
-
-        QuantLib::ext::shared_ptr<Trade> trade;
-        try {
-            trade = TradeFactory::instance().build(tradeType);
-            trade->id() = id;
-            Envelope componentEnvelope;
-            if (XMLNode* envNode = XMLUtils::getChildNode(nodes[i], "Envelope")) {
-                componentEnvelope.fromXML(envNode);
+    XMLNode* tradesNode = XMLUtils::getChildNode(compNode, "Components");
+    if (portfolioBasket_ && portfolioId_.empty()) {
+        QL_REQUIRE(tradesNode, "Required a Portfolio Id or a Components Node.");
+    }
+    if ((portfolioBasket_ && portfolioId_.empty()) || (!portfolioBasket_)) {
+    
+        vector<XMLNode*> nodes = XMLUtils::getChildrenNodes(tradesNode, "Trade");
+        for (Size i = 0; i < nodes.size(); i++) {
+            string tradeType = XMLUtils::getChildValue(nodes[i], "TradeType", true);
+            string id = XMLUtils::getAttribute(nodes[i], "id");
+            if (id == "") {
+                WLOG("Empty component trade id being overwritten in composite trade " << this->id() << ".");
+            }
+            id = this->id() + "_" + std::to_string(i);
+            DLOG("Parsing composite trade " << this->id() << " node " << i << " with id: " << id);
+
+            QuantLib::ext::shared_ptr<Trade> trade;
+            try {
+                trade = TradeFactory::instance().build(tradeType);
+                trade->id() = id;
+                Envelope componentEnvelope;
+                if (XMLNode* envNode = XMLUtils::getChildNode(nodes[i], "Envelope")) {
+                    componentEnvelope.fromXML(envNode);
+                }
+                Envelope env = this->envelope();
+                // the component trade's envelope is the main trade's envelope with possibly overwritten add fields
+                for (auto const& [k, v] : componentEnvelope.fullAdditionalFields()) {
+                    env.setAdditionalField(k,v);
+                }
+                    
+                trade->setEnvelope(env);
+                trade->fromXML(nodes[i]);
+                trades_.push_back(trade);
+                DLOG("Added Trade " << id << " (" << trade->id() << ")"
+                                    << " type:" << tradeType << " to composite trade " << this->id() << ".");
+            } catch (const std::exception& e) {
+                StructuredTradeErrorMessage(
+                    id, this->tradeType(),
+                    "Failed to build subtrade with id '" + id + "' inside composite trade: ", e.what())
+                    .log();
             }
-            Envelope env = this->envelope();
-            // the component trade's envelope is the main trade's envelope with possibly overwritten add fields
-            for (auto const& [k, v] : componentEnvelope.fullAdditionalFields())
-                env.setAdditionalField(k,v);
-            trade->setEnvelope(env);
-            trade->fromXML(nodes[i]);
-            trades_.push_back(trade);
-            DLOG("Added Trade " << id << " (" << trade->id() << ")"
-                                << " type:" << tradeType << " to composite trade " << this->id() << ".");
-        } catch (const std::exception& e) {
-            StructuredTradeErrorMessage(
-                id, this->tradeType(),
-                "Failed to build subtrade with id '" + id + "' inside composite trade: ", e.what())
-                .log();
         }
+        LOG("Finished Parsing XML doc");
     }
-    LOG("Finished Parsing XML doc");
 }
 
 XMLNode* CompositeTrade::toXML(XMLDocument& doc) const {
@@ -256,5 +271,34 @@ const std::map<std::string, boost::any>& CompositeTrade::additionalData() const
     return additionalData_;
 }
 
+void CompositeTrade::populateFromReferenceData(const QuantLib::ext::shared_ptr<ReferenceDataManager>& referenceData) {
+
+    if (!portfolioId_.empty() && referenceData != nullptr &&
+        (referenceData->hasData(PortfolioBasketReferenceDatum::TYPE, portfolioId_))) {
+        auto ptfRefData = QuantLib::ext::dynamic_pointer_cast<PortfolioBasketReferenceDatum>(
+                referenceData->getData(PortfolioBasketReferenceDatum::TYPE, portfolioId_));
+            QL_REQUIRE(ptfRefData, "could not cast to PortfolioBasketReferenceDatum, this is unexpected");
+            getTradesFromReferenceData(ptfRefData);
+    } else {
+        DLOG("Could not get PortfolioBasketReferenceDatum for Id " << portfolioId_ << " leave data in trade unchanged");
+    }
+   
+}
+
+void CompositeTrade::getTradesFromReferenceData(
+    const QuantLib::ext::shared_ptr<PortfolioBasketReferenceDatum>& ptfReferenceDatum) {
+
+    DLOG("populating portfolio basket data from reference data");
+    QL_REQUIRE(ptfReferenceDatum, "populateFromReferenceData(): empty cbo reference datum given");
+
+    auto refData = ptfReferenceDatum->getTrades();
+    trades_.clear();
+    for (Size i = 0; i < refData.size(); i++) {
+        trades_.push_back(refData[i]);
+    }
+    LOG("Finished Parsing XML doc");
+
+}
+
 } // namespace data
 } // namespace oreplus

OREData/ored/portfolio/compositetrade.hpp

@@ -24,6 +24,7 @@
 
 #include <ored/portfolio/trade.hpp>
 #include <ored/portfolio/tradefactory.hpp>
+#include <ored/portfolio/referencedata.hpp>
 #include <ostream>
 
 namespace ore {
@@ -70,6 +71,8 @@ class CompositeTrade : public Trade {
     //! \name Inspectors
     //@{
     const string& currency() const { return currency_; }
+    const string& portfolioId() const { return portfolioId_; }
+    const bool& portfolioBasket() const { return portfolioBasket_; }
     const string& notionalCalculation() const { return notionalCalculation_; }
     const vector<QuantLib::ext::shared_ptr<Trade>>& trades() const { return trades_; }
     //@}
@@ -97,11 +100,17 @@ class CompositeTrade : public Trade {
     //@}
 
 private:
+
+    void populateFromReferenceData(const QuantLib::ext::shared_ptr<ReferenceDataManager>& referenceDataManager);
+    void getTradesFromReferenceData(const QuantLib::ext::shared_ptr<PortfolioBasketReferenceDatum>& ptfReferenceDatum);
+
     string currency_;
     Real notionalOverride_;
     string notionalCalculation_;
     vector<QuantLib::ext::shared_ptr<Trade>> trades_;
     vector<Handle<Quote>> fxRates_, fxRatesNotional_;
+    string portfolioId_;
+    bool portfolioBasket_;
 };
 
 } // namespace data