Cross Asset Model Parameters. More...

#include <ored/model/crossassetmodeldata.hpp>

Inheritance diagram for CrossAssetModelData:

Collaboration diagram for CrossAssetModelData:

Classes
struct	HandleComp

Public Member Functions
Constructors
	CrossAssetModelData ()
	Default constructor. More...

	CrossAssetModelData (const vector< QuantLib::ext::shared_ptr< IrModelData > > &irConfigs, const vector< QuantLib::ext::shared_ptr< FxBsData > > &fxConfigs, const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &c, Real tolerance=1e-4, const std::string &measure="LGM", const CrossAssetModel::Discretization discretization=CrossAssetModel::Discretization::Exact)
	Detailed constructor (IR/FX only) More...

	CrossAssetModelData (const std::vector< QuantLib::ext::shared_ptr< IrModelData > > &irConfigs, const std::vector< QuantLib::ext::shared_ptr< FxBsData > > &fxConfigs, const std::vector< QuantLib::ext::shared_ptr< EqBsData > > &eqConfigs, const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &c, Real tolerance=1e-4, const std::string &measure="LGM", const CrossAssetModel::Discretization discretization=CrossAssetModel::Discretization::Exact)
	Detailed constructor (IR/FX/EQ only) More...

	CrossAssetModelData (const std::vector< QuantLib::ext::shared_ptr< IrModelData > > &irConfigs, const std::vector< QuantLib::ext::shared_ptr< FxBsData > > &fxConfigs, const std::vector< QuantLib::ext::shared_ptr< EqBsData > > &eqConfigs, const std::vector< QuantLib::ext::shared_ptr< InflationModelData > > &infConfigs, const std::vector< QuantLib::ext::shared_ptr< CrLgmData > > &crLgmConfigs, const std::vector< QuantLib::ext::shared_ptr< CrCirData > > &crCirConfigs, const std::vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > &comConfigs, const Size numberOfCreditStates, const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &c, Real tolerance=1e-4, const std::string &measure="LGM", const CrossAssetModel::Discretization discretization=CrossAssetModel::Discretization::Exact)
	Detailed constructor (all asset classes) More...

void	clear ()
	Clear all vectors and maps. More...

void	validate ()
	Check consistency of config vectors. More...

Inspectors
const string &	domesticCurrency () const

const vector< string > &	currencies () const

const vector< string > &	equities () const

const vector< string > &	infIndices () const

const vector< string > &	creditNames () const

const vector< string > &	commodities () const

const vector< QuantLib::ext::shared_ptr< IrModelData > > &	irConfigs () const

const vector< QuantLib::ext::shared_ptr< FxBsData > > &	fxConfigs () const

const vector< QuantLib::ext::shared_ptr< EqBsData > > &	eqConfigs () const

const vector< QuantLib::ext::shared_ptr< InflationModelData > > &	infConfigs () const

const vector< QuantLib::ext::shared_ptr< CrLgmData > > &	crLgmConfigs () const

const vector< QuantLib::ext::shared_ptr< CrCirData > > &	crCirConfigs () const

const vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > &	comConfigs () const

Size	numberOfCreditStates () const

const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &	correlations () const

Real	bootstrapTolerance () const

const std::string &	measure () const

CrossAssetModel::Discretization	discretization () const

Setters
string &	domesticCurrency ()

vector< string > &	currencies ()

vector< string > &	equities ()

vector< string > &	infIndices ()

vector< string > &	creditNames ()

vector< string > &	commodities ()

vector< QuantLib::ext::shared_ptr< IrModelData > > &	irConfigs ()

vector< QuantLib::ext::shared_ptr< FxBsData > > &	fxConfigs ()

vector< QuantLib::ext::shared_ptr< EqBsData > > &	eqConfigs ()

vector< QuantLib::ext::shared_ptr< InflationModelData > > &	infConfigs ()

vector< QuantLib::ext::shared_ptr< CrLgmData > > &	crLgmConfigs ()

vector< QuantLib::ext::shared_ptr< CrCirData > > &	crCirConfigs ()

vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > &	comConfigs ()

void	setCorrelations (const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &corrs)

void	setCorrelations (const QuantLib::ext::shared_ptr< InstantaneousCorrelations > &corrs)

Real &	bootstrapTolerance ()

std::string &	measure ()

CrossAssetModel::Discretization &	discretization ()

Serialisation
virtual void	fromXML (XMLNode *node) override

virtual XMLNode *	toXML (XMLDocument &doc) const override

Public Member Functions inherited from XMLSerializable
virtual	~XMLSerializable ()

virtual void	fromXML (XMLNode *node)=0

virtual XMLNode *	toXML (XMLDocument &doc) const =0

void	fromFile (const std::string &filename)

void	toFile (const std::string &filename) const

void	fromXMLString (const std::string &xml)
	Parse from XML string. More...

std::string	toXMLString () const
	Parse from XML string. More...

Operators
string	domesticCurrency_

vector< std::string >	currencies_

vector< std::string >	equities_

vector< std::string >	infindices_

vector< std::string >	creditNames_

vector< std::string >	commodities_

vector< QuantLib::ext::shared_ptr< IrModelData > >	irConfigs_

vector< QuantLib::ext::shared_ptr< FxBsData > >	fxConfigs_

vector< QuantLib::ext::shared_ptr< EqBsData > >	eqConfigs_

vector< QuantLib::ext::shared_ptr< InflationModelData > >	infConfigs_

vector< QuantLib::ext::shared_ptr< CrLgmData > >	crLgmConfigs_

vector< QuantLib::ext::shared_ptr< CrCirData > >	crCirConfigs_

vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > >	comConfigs_

Size	numberOfCreditStates_ = 0

QuantLib::ext::shared_ptr< InstantaneousCorrelations >	correlations_

Real	bootstrapTolerance_

std::string	measure_

CrossAssetModel::Discretization	discretization_

bool	operator== (const CrossAssetModelData &rhs)

bool	operator!= (const CrossAssetModelData &rhs)

void	buildIrConfigs (map< string, QuantLib::ext::shared_ptr< IrModelData > > &irMap)
	helper to convert LGM data, possibly including defaults, into an IR config vector More...

void	buildFxConfigs (std::map< std::string, QuantLib::ext::shared_ptr< FxBsData > > &fxMap)
	helper to convert FX data, possibly including defaults, into an FX config vector More...

void	buildEqConfigs (std::map< std::string, QuantLib::ext::shared_ptr< EqBsData > > &eqMap)
	helper to convert EQ data, possibly including defaults, into an EQ config vector More...

void	buildInfConfigs (const std::map< std::string, QuantLib::ext::shared_ptr< InflationModelData > > &mp)
	helper to convert INF data, possibly including defaults, into an INF config vector More...

void	buildCrConfigs (std::map< std::string, QuantLib::ext::shared_ptr< CrLgmData > > &crLgmMap, std::map< std::string, QuantLib::ext::shared_ptr< CrCirData > > &crCirMap)
	helper to convert CR LGM data, possibly including defaults, into CR config vectors More...

void	buildComConfigs (std::map< std::string, QuantLib::ext::shared_ptr< CommoditySchwartzData > > &comMap)
	helper to convert COM data, possibly including defaulta, into a COM config vector More...

Detailed Description

Cross Asset Model Parameters.

CrossAssetModelData comprises the specification of how to build and calibrate the CrossAssetModel. It contains

specifications for each currency IR component (IrLgmData)
specifications for each FX component (FxBsData)
the correlation specification between all factors of the model
a tolerance for bootstrap type calibration methods

Definition at line 115 of file crossassetmodeldata.hpp.

Constructor & Destructor Documentation

◆ CrossAssetModelData() [1/4]

CrossAssetModelData ( )

Default constructor.

Definition at line 120 of file crossassetmodeldata.hpp.

                          : bootstrapTolerance_(0.0), discretization_(CrossAssetModel::Discretization::Exact) {
        correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>();
    }

◆ CrossAssetModelData() [2/4]

CrossAssetModelData	(	const vector< QuantLib::ext::shared_ptr< IrModelData > > &	irConfigs,
		const vector< QuantLib::ext::shared_ptr< FxBsData > > &	fxConfigs,
		const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &	c,
		Real	tolerance = `1e-4`,
		const std::string &	measure = `"LGM"`,
		const CrossAssetModel::Discretization	discretization = `CrossAssetModel::Discretization::Exact`
	)

Detailed constructor (IR/FX only)

Parameters

irConfigs	Vector of IR model specifications
fxConfigs	Vector of FX model specifications
c	Correlation map
tolerance	Bootstrap tolerance used in model calibration
measure	Choice of probability measure
discretization	Choice of discretization

Definition at line 125 of file crossassetmodeldata.hpp.

        : irConfigs_(irConfigs), fxConfigs_(fxConfigs), eqConfigs_(std::vector<QuantLib::ext::shared_ptr<EqBsData>>()),
          bootstrapTolerance_(tolerance), measure_(measure), discretization_(discretization) {
        correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>(c);
        domesticCurrency_ = irConfigs_[0]->ccy();
        currencies_.clear();
        for (Size i = 0; i < irConfigs_.size(); ++i)
            currencies_.push_back(irConfigs_[i]->ccy());
        validate();
    }

Here is the call graph for this function:

◆ CrossAssetModelData() [3/4]

CrossAssetModelData	(	const std::vector< QuantLib::ext::shared_ptr< IrModelData > > &	irConfigs,
		const std::vector< QuantLib::ext::shared_ptr< FxBsData > > &	fxConfigs,
		const std::vector< QuantLib::ext::shared_ptr< EqBsData > > &	eqConfigs,
		const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &	c,
		Real	tolerance = `1e-4`,
		const std::string &	measure = `"LGM"`,
		const CrossAssetModel::Discretization	discretization = `CrossAssetModel::Discretization::Exact`
	)

Detailed constructor (IR/FX/EQ only)

Parameters

irConfigs	Vector of IR model specifications
fxConfigs	Vector of FX model specifications
eqConfigs	Vector of EQ model specifications
c	Correlation map
tolerance	Bootstrap tolerance used in model calibration
measure	Choice of probability measure
discretization	Choice of discretization

Definition at line 148 of file crossassetmodeldata.hpp.

        : irConfigs_(irConfigs), fxConfigs_(fxConfigs), eqConfigs_(eqConfigs), bootstrapTolerance_(tolerance),
          measure_(measure), discretization_(discretization) {
        correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>(c);
        domesticCurrency_ = irConfigs_[0]->ccy();
        currencies_.clear();
        for (Size i = 0; i < irConfigs_.size(); ++i)
            currencies_.push_back(irConfigs_[i]->ccy());
        validate();
    }

Here is the call graph for this function:

◆ CrossAssetModelData() [4/4]

CrossAssetModelData	(	const std::vector< QuantLib::ext::shared_ptr< IrModelData > > &	irConfigs,
		const std::vector< QuantLib::ext::shared_ptr< FxBsData > > &	fxConfigs,
		const std::vector< QuantLib::ext::shared_ptr< EqBsData > > &	eqConfigs,
		const std::vector< QuantLib::ext::shared_ptr< InflationModelData > > &	infConfigs,
		const std::vector< QuantLib::ext::shared_ptr< CrLgmData > > &	crLgmConfigs,
		const std::vector< QuantLib::ext::shared_ptr< CrCirData > > &	crCirConfigs,
		const std::vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > &	comConfigs,
		const Size	numberOfCreditStates,
		const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > &	c,
		Real	tolerance = `1e-4`,
		const std::string &	measure = `"LGM"`,
		const CrossAssetModel::Discretization	discretization = `CrossAssetModel::Discretization::Exact`
	)

Detailed constructor (all asset classes)

Parameters

irConfigs	Vector of IR model specifications
fxConfigs	Vector of FX model specifications
eqConfigs	Vector of EQ model specifications
infConfigs	Vector of INF model specifications
crLgmConfigs	Vector of CR LGM model specifications
crCirConfigs	Vector of CR CIR model specifications
comConfigs	Vector of COM Schwartz model specifications
numberOfCreditStates	Number of credit states
c	Correlation map
tolerance	Bootstrap tolerance used in model calibration
measure	Choice of probability measure
discretization	Choice of discretization

Definition at line 173 of file crossassetmodeldata.hpp.

        : irConfigs_(irConfigs), fxConfigs_(fxConfigs), eqConfigs_(eqConfigs), infConfigs_(infConfigs),
          crLgmConfigs_(crLgmConfigs), crCirConfigs_(crCirConfigs), comConfigs_(comConfigs),
          numberOfCreditStates_(numberOfCreditStates), bootstrapTolerance_(tolerance), measure_(measure),
          discretization_(discretization) {
        correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>(c);
        domesticCurrency_ = irConfigs_[0]->ccy();
        currencies_.clear();
        for (Size i = 0; i < irConfigs_.size(); ++i)
            currencies_.push_back(irConfigs_[i]->ccy());
        validate();
    }

Here is the call graph for this function:

Member Function Documentation

◆ clear()

void clear ( )

Clear all vectors and maps.

Definition at line 201 of file crossassetmodeldata.cpp.

                                {
    currencies_.clear();
    equities_.clear();
    irConfigs_.clear();
    fxConfigs_.clear();
    eqConfigs_.clear();
    infConfigs_.clear();
    crLgmConfigs_.clear();
    crCirConfigs_.clear();
    comConfigs_.clear();
    correlations_->clear();
}

Here is the caller graph for this function:

◆ validate()

void validate ( )

Check consistency of config vectors.

Definition at line 214 of file crossassetmodeldata.cpp.

                                   {
    QL_REQUIRE(irConfigs_.size() > 0, "no IR data provided");
    bool useHwModel = false;
    // All IR configs need to be either HullWhite or LGM
    if (auto hwModelData = QuantLib::ext::dynamic_pointer_cast<HwModelData>(irConfigs_.front())) {
        useHwModel = true;
    }
    for (const auto& modelData : irConfigs_) {
        if (useHwModel) {
            QL_REQUIRE(QuantLib::ext::dynamic_pointer_cast<HwModelData>(modelData),
                       "expect all ir models to be of hull white models");
        } else {
            QL_REQUIRE(QuantLib::ext::dynamic_pointer_cast<IrLgmData>(modelData), "expect all ir models to be lgm models"); 
        }
    }
 
    QL_REQUIRE(fxConfigs_.size() == irConfigs_.size() - 1, "inconsistent number of FX data provided");
    for (Size i = 0; i < fxConfigs_.size(); ++i)
        QL_REQUIRE(fxConfigs_[i]->foreignCcy() == irConfigs_[i + 1]->ccy(),
                   "currency mismatch between IR and FX config vectors");
 
    if (measure_ == "BA" && !useHwModel) {
        // ensure that the domestic LGM has shift = 0 and scaling = 1
        for (Size i = 0; i < irConfigs_.size(); ++i)
            if (irConfigs_[i]->ccy() == domesticCurrency_) {
                auto irConfig = QuantLib::ext::dynamic_pointer_cast<IrLgmData>(irConfigs_[i]);
                QL_REQUIRE(close_enough(irConfig->scaling(), 1.0),
                           "scaling for the domestic LGM must be 1 for BA measure simulations");
                QL_REQUIRE(close_enough(irConfig->shiftHorizon(), 0.0),
                           "shift horizon for the domestic LGM must be 0 for BA measure simulations");
            }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ domesticCurrency() [1/2]

const string & domesticCurrency ( ) const

Definition at line 218 of file crossassetmodeldata.hpp.

218{ return domesticCurrency_; }

◆ currencies() [1/2]

const vector< string > & currencies ( ) const

Definition at line 219 of file crossassetmodeldata.hpp.

219{ return currencies_; }

◆ equities() [1/2]

const vector< string > & equities ( ) const

Definition at line 220 of file crossassetmodeldata.hpp.

220{ return equities_; }

◆ infIndices() [1/2]

const vector< string > & infIndices ( ) const

Definition at line 221 of file crossassetmodeldata.hpp.

221{ return infindices_; }

ore::data::CrossAssetModelData::infindices_

vector< std::string > infindices_

Definition: crossassetmodeldata.hpp:300

◆ creditNames() [1/2]

const vector< string > & creditNames ( ) const

Definition at line 222 of file crossassetmodeldata.hpp.

222{ return creditNames_; }

ore::data::CrossAssetModelData::creditNames_

vector< std::string > creditNames_

Definition: crossassetmodeldata.hpp:301

◆ commodities() [1/2]

const vector< string > & commodities ( ) const

Definition at line 223 of file crossassetmodeldata.hpp.

223{ return commodities_; }

ore::data::CrossAssetModelData::commodities_

vector< std::string > commodities_

Definition: crossassetmodeldata.hpp:302

◆ irConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< IrModelData > > & irConfigs ( ) const

Definition at line 224 of file crossassetmodeldata.hpp.

224{ return irConfigs_; }

Here is the caller graph for this function:

◆ fxConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< FxBsData > > & fxConfigs ( ) const

Definition at line 225 of file crossassetmodeldata.hpp.

225{ return fxConfigs_; }

◆ eqConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< EqBsData > > & eqConfigs ( ) const

Definition at line 226 of file crossassetmodeldata.hpp.

226{ return eqConfigs_; }

◆ infConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< InflationModelData > > & infConfigs ( ) const

Definition at line 227 of file crossassetmodeldata.hpp.

227{ return infConfigs_; }

◆ crLgmConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< CrLgmData > > & crLgmConfigs ( ) const

Definition at line 228 of file crossassetmodeldata.hpp.

228{ return crLgmConfigs_; }

◆ crCirConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< CrCirData > > & crCirConfigs ( ) const

Definition at line 229 of file crossassetmodeldata.hpp.

229{ return crCirConfigs_; }

◆ comConfigs() [1/2]

const vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > & comConfigs ( ) const

Definition at line 230 of file crossassetmodeldata.hpp.

230{ return comConfigs_; }

◆ numberOfCreditStates()

Size numberOfCreditStates ( ) const

Definition at line 231 of file crossassetmodeldata.hpp.

231{ return numberOfCreditStates_; }

◆ correlations()

const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > & correlations ( ) const

Definition at line 232 of file crossassetmodeldata.hpp.

                                                                                      {
        return correlations_->correlations();
    }

◆ bootstrapTolerance() [1/2]

Real bootstrapTolerance ( ) const

Definition at line 235 of file crossassetmodeldata.hpp.

235{ return bootstrapTolerance_; }

◆ measure() [1/2]

const std::string & measure ( ) const

Definition at line 236 of file crossassetmodeldata.hpp.

236{ return measure_; }

◆ discretization() [1/2]

CrossAssetModel::Discretization discretization ( ) const

Definition at line 237 of file crossassetmodeldata.hpp.

237{ return discretization_; }

◆ domesticCurrency() [2/2]

string & domesticCurrency ( )

Definition at line 242 of file crossassetmodeldata.hpp.

242{ return domesticCurrency_; }

◆ currencies() [2/2]

vector< string > & currencies ( )

Definition at line 243 of file crossassetmodeldata.hpp.

243{ return currencies_; }

◆ equities() [2/2]

vector< string > & equities ( )

Definition at line 244 of file crossassetmodeldata.hpp.

244{ return equities_; }

◆ infIndices() [2/2]

vector< string > & infIndices ( )

Definition at line 245 of file crossassetmodeldata.hpp.

245{ return infindices_; }

◆ creditNames() [2/2]

vector< string > & creditNames ( )

Definition at line 246 of file crossassetmodeldata.hpp.

246{ return creditNames_; }

◆ commodities() [2/2]

vector< string > & commodities ( )

Definition at line 247 of file crossassetmodeldata.hpp.

247{ return commodities_; }

◆ irConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< IrModelData > > & irConfigs ( )

Definition at line 248 of file crossassetmodeldata.hpp.

248{ return irConfigs_; }

◆ fxConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< FxBsData > > & fxConfigs ( )

Definition at line 249 of file crossassetmodeldata.hpp.

249{ return fxConfigs_; }

◆ eqConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< EqBsData > > & eqConfigs ( )

Definition at line 250 of file crossassetmodeldata.hpp.

250{ return eqConfigs_; }

◆ infConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< InflationModelData > > & infConfigs ( )

Definition at line 251 of file crossassetmodeldata.hpp.

251{ return infConfigs_; }

◆ crLgmConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< CrLgmData > > & crLgmConfigs ( )

Definition at line 252 of file crossassetmodeldata.hpp.

252{ return crLgmConfigs_; }

◆ crCirConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< CrCirData > > & crCirConfigs ( )

Definition at line 253 of file crossassetmodeldata.hpp.

253{ return crCirConfigs_; }

◆ comConfigs() [2/2]

vector< QuantLib::ext::shared_ptr< CommoditySchwartzData > > & comConfigs ( )

Definition at line 254 of file crossassetmodeldata.hpp.

254{ return comConfigs_; }

◆ setCorrelations() [1/2]

void setCorrelations ( const std::map< CorrelationKey, QuantLib::Handle< QuantLib::Quote > > & corrs )

Definition at line 255 of file crossassetmodeldata.hpp.

                                                                                             {
        correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>(corrs);
    }

◆ setCorrelations() [2/2]

void setCorrelations ( const QuantLib::ext::shared_ptr< InstantaneousCorrelations > & corrs )

Definition at line 258 of file crossassetmodeldata.hpp.

258{ correlations_ = corrs; }

◆ bootstrapTolerance() [2/2]

Real & bootstrapTolerance ( )

Definition at line 259 of file crossassetmodeldata.hpp.

259{ return bootstrapTolerance_; }

◆ measure() [2/2]

std::string & measure ( )

Definition at line 260 of file crossassetmodeldata.hpp.

260{ return measure_; }

◆ discretization() [2/2]

CrossAssetModel::Discretization & discretization ( )

Definition at line 261 of file crossassetmodeldata.hpp.

261{ return discretization_; }

◆ fromXML()

void fromXML ( XMLNode * node )

overridevirtual

Implements XMLSerializable.

Definition at line 253 of file crossassetmodeldata.cpp.

                                               {
    clear();
 
    // we can read from the subnode "CrossAssetModel" of the root node "Simulation" or
    // directly from root = CrossAssetModel. This way fromXML(toXML()) works as expected.
    XMLNode* modelNode;
    if (XMLUtils::getNodeName(root) == "CrossAssetModel") {
        modelNode = root;
    } else {
        XMLNode* sim = XMLUtils::locateNode(root, "Simulation");
        modelNode = XMLUtils::getChildNode(sim, "CrossAssetModel");
        QL_REQUIRE(modelNode, "Simulation / CrossAssetModel not found, can not read cross asset model data");
    }
 
    std::string discString = XMLUtils::getChildValue(modelNode, "Discretization", false);
 
    // check deprecated way of providing Discretization under Simulation/Parameters
    if (discString.empty()) {
        if (XMLNode* node = XMLUtils::getChildNode(root, "Parameters")) {
            discString = XMLUtils::getChildValue(node, "Discretization", false);
            WLOG("Simulation/Parameters/Discretization is deprecated, use Simulation/CrossAssetModel/Discretization "
                 "instead.");
        }
    }
 
    // default discString to Exact if not found
    if(discString.empty()) {
        discString = "Exact";
        WLOG("CrossAssetModelData: Discretization is not given. Expected this in Simulation/CrossAssetModel or in "
             "Simulation/Parameters/Discretization (deprecated). Fall back to Exact.");
    }
 
    discretization_ = parseDiscretization(discString);
 
    domesticCurrency_ = XMLUtils::getChildValue(modelNode, "DomesticCcy", true); // mandatory
    LOG("CrossAssetModelData: domesticCcy " << domesticCurrency_);
 
    currencies_ = XMLUtils::getChildrenValues(modelNode, "Currencies", "Currency", true);
    for (auto ccy : currencies_) {
        LOG("CrossAssetModelData: ccy " << ccy);
    }
 
    equities_ = XMLUtils::getChildrenValues(modelNode, "Equities", "Equity");
    for (auto eq : equities_) {
        LOG("CrossAssetModelData equity " << eq);
    }
 
    infindices_ = XMLUtils::getChildrenValues(modelNode, "InflationIndices", "InflationIndex");
    for (auto inf : infindices_) {
        LOG("CrossAssetModelData inflation index " << inf);
    }
 
    creditNames_ = XMLUtils::getChildrenValues(modelNode, "CreditNames", "CreditName");
    for (auto cr : creditNames_) {
        LOG("CrossAssetModelData credit name " << cr);
    }
 
    commodities_ = XMLUtils::getChildrenValues(modelNode, "Commodities", "Commodity");
    for (auto com : commodities_) {
        LOG("CrossAssetModelData commodity " << com);
    }
 
    bootstrapTolerance_ = XMLUtils::getChildValueAsDouble(modelNode, "BootstrapTolerance", true);
    LOG("CrossAssetModelData: bootstrap tolerance = " << bootstrapTolerance_);
 
    measure_ = XMLUtils::getChildValue(modelNode, "Measure", false);
    LOG("CrossAssetModelData: measure = '" << measure_ << "'");
 
    // Configure IR model components
 
    std::map<std::string, QuantLib::ext::shared_ptr<IrModelData>> irDataMap;
    XMLNode* irNode = XMLUtils::getChildNode(modelNode, "InterestRateModels");
    if (irNode) {
        
        bool hasLgmAndHwModels = XMLUtils::getChildNode(irNode, "LGM") && XMLUtils::getChildNode(irNode, "HWModel");
 
        QL_REQUIRE(!hasLgmAndHwModels, "CrossAssetModelData: Found configuration for HullWhiteModel and LGM model, use "
                                       "only one. Please check your simulation.xml");
 
        for (XMLNode* child = XMLUtils::getChildNode(irNode, "LGM"); child;
             child = XMLUtils::getNextSibling(child, "LGM")) {
 
            QuantLib::ext::shared_ptr<IrLgmData> config(new IrLgmData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("LGM calibration swaption " << config->optionExpiries()[i] << " x " << config->optionTerms()[i]
                                                << " " << config->optionStrikes()[i]);
            }
 
            irDataMap[config->qualifier()] = config;
 
            LOG("CrossAssetModelData: IR config built for key " << config->qualifier());
 
        } // end of  for (XMLNode* child = XMLUtils::getChildNode(irNode, "LGM"); child;
 
        
        for (XMLNode* child = XMLUtils::getChildNode(irNode, "HWModel"); child;
             child = XMLUtils::getNextSibling(child, "HWModel")) {
 
            QuantLib::ext::shared_ptr<HwModelData> config(new HwModelData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("LGM calibration swaption " << config->optionExpiries()[i] << " x " << config->optionTerms()[i]
                                                << " " << config->optionStrikes()[i]);
            }
 
            irDataMap[config->qualifier()] = config;
 
            LOG("CrossAssetModelData: HullWhite IR config built for key " << config->qualifier());
 
        } // end of  for (XMLNode* child = XMLUtils::getChildNode(irNode, "LGM"); child;
 
    }     // end of if (irNode)
    else {
        LOG("No IR model section found");
    }
 
    buildIrConfigs(irDataMap);
 
    for (Size i = 0; i < irConfigs_.size(); i++)
        LOG("CrossAssetModelData: IR config currency " << i << " = " << irConfigs_[i]->ccy());
 
    // Configure FX model components
 
    std::map<std::string, QuantLib::ext::shared_ptr<FxBsData>> fxDataMap;
    XMLNode* fxNode = XMLUtils::getChildNode(modelNode, "ForeignExchangeModels");
    if (fxNode) {
        for (XMLNode* child = XMLUtils::getChildNode(fxNode, "CrossCcyLGM"); child;
             child = XMLUtils::getNextSibling(child, "CrossCcyLGM")) {
 
            QuantLib::ext::shared_ptr<FxBsData> config(new FxBsData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("CC-LGM calibration option " << config->optionExpiries()[i] << " " << config->optionStrikes()[i]);
            }
 
            fxDataMap[config->foreignCcy()] = config;
 
            LOG("CrossAssetModelData: FX config built with key (foreign ccy) " << config->foreignCcy());
        }
    } else {
        LOG("No FX Models section found");
    }
 
    buildFxConfigs(fxDataMap);
 
    for (Size i = 0; i < fxConfigs_.size(); i++)
        LOG("CrossAssetModelData: FX config currency " << i << " = " << fxConfigs_[i]->foreignCcy());
 
    // Configure EQ model components
 
    std::map<std::string, QuantLib::ext::shared_ptr<EqBsData>> eqDataMap;
    XMLNode* eqNode = XMLUtils::getChildNode(modelNode, "EquityModels");
    if (eqNode) {
        for (XMLNode* child = XMLUtils::getChildNode(eqNode, "CrossAssetLGM"); child;
             child = XMLUtils::getNextSibling(child, "CrossAssetLGM")) {
 
            QuantLib::ext::shared_ptr<EqBsData> config(new EqBsData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("Cross-Asset Equity calibration option " << config->optionExpiries()[i] << " "
                                                             << config->optionStrikes()[i]);
            }
 
            eqDataMap[config->eqName()] = config;
 
            LOG("CrossAssetModelData: Equity config built with key " << config->eqName());
        }
    } else {
        LOG("No Equity Models section found");
    }
 
    buildEqConfigs(eqDataMap);
 
    for (Size i = 0; i < eqConfigs_.size(); i++)
        LOG("CrossAssetModelData: EQ config name " << i << " = " << eqConfigs_[i]->eqName());
 
    // Read the inflation model data.
    if (XMLNode* n = XMLUtils::getChildNode(modelNode, "InflationIndexModels")) {
 
        map<string, QuantLib::ext::shared_ptr<InflationModelData>> mp;
 
        // Loop over nodes and pick out any with name: LGM, DodgsonKainth or JarrowYildirim.
        for (XMLNode* cn = XMLUtils::getChildNode(n); cn; cn = XMLUtils::getNextSibling(cn)) {
 
            QuantLib::ext::shared_ptr<InflationModelData> imData;
 
            string nodeName = XMLUtils::getNodeName(cn);
            if (nodeName == "LGM" || nodeName == "DodgsonKainth") {
                imData = QuantLib::ext::make_shared<InfDkData>();
            } else if (nodeName == "JarrowYildirim") {
                imData = QuantLib::ext::make_shared<InfJyData>();
            } else {
                WLOG("Did not recognise InflationIndexModels node with name "
                     << nodeName << " as a valid inflation index model so skipping it.");
                continue;
            }
 
            const string& indexName = imData->index();
            imData->fromXML(cn);
            mp[indexName] = imData;
 
            LOG("CrossAssetModelData: inflation index model data built with key " << indexName);
        }
 
        // Align the inflation model data with the infindices_ read in above and handle defaults
        buildInfConfigs(mp);
 
        // Log the index number and inflation index name for each inflation index model.
        for (Size i = 0; i < infConfigs_.size(); i++)
            LOG("CrossAssetModelData: INF config name " << i << " = " << infConfigs_[i]->index());
 
    } else {
        LOG("No InflationIndexModels node found so no inflation models configured.");
    }
 
    // Configure CR model components
 
    std::map<std::string, QuantLib::ext::shared_ptr<CrLgmData>> crLgmDataMap;
    std::map<std::string, QuantLib::ext::shared_ptr<CrCirData>> crCirDataMap;
    XMLNode* crNode = XMLUtils::getChildNode(modelNode, "CreditModels");
    if (crNode) {
        for (XMLNode* child = XMLUtils::getChildNode(crNode, "LGM"); child;
             child = XMLUtils::getNextSibling(child, "LGM")) {
 
            QuantLib::ext::shared_ptr<CrLgmData> config(new CrLgmData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("LGM calibration cds option " << config->optionExpiries()[i] << " x " << config->optionTerms()[i]
                                                  << " " << config->optionStrikes()[i]);
            }
 
            crLgmDataMap[config->name()] = config;
 
            LOG("CrossAssetModelData: CR LGM config built for key " << config->name());
 
        } // end of  for (XMLNode* child = XMLUtils::getChildNode(irNode, "LGM"); child;
        for (XMLNode* child = XMLUtils::getChildNode(crNode, "CIR"); child;
             child = XMLUtils::getNextSibling(child, "CIR")) {
 
            QuantLib::ext::shared_ptr<CrCirData> config(new CrCirData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("CIR calibration cds option " << config->optionExpiries()[i] << " x " << config->optionTerms()[i]
                                                  << " " << config->optionStrikes()[i]);
            }
 
            crCirDataMap[config->name()] = config;
 
            LOG("CrossAssetModelData: CR CIR config built for key " << config->name());
 
        } // end of  for (XMLNode* child = XMLUtils::getChildNode(irNode, "CIR"); child;
    }     // end of if (irNode)
    else {
        LOG("No CR model section found");
    }
 
    buildCrConfigs(crLgmDataMap, crCirDataMap);
 
    for (Size i = 0; i < crLgmConfigs_.size(); i++)
        LOG("CrossAssetModelData: CR LGM config name " << i << " = " << crLgmConfigs_[i]->name());
    for (Size i = 0; i < crCirConfigs_.size(); i++)
        LOG("CrossAssetModelData: CR CIR config name " << i << " = " << crCirConfigs_[i]->name());
 
    // Configure COM model components
 
    std::map<std::string, QuantLib::ext::shared_ptr<CommoditySchwartzData>> comDataMap;
    XMLNode* comNode = XMLUtils::getChildNode(modelNode, "CommodityModels");
    if (comNode) {
        for (XMLNode* child = XMLUtils::getChildNode(comNode, "CommoditySchwartz"); child;
             child = XMLUtils::getNextSibling(child, "CommoditySchwartz")) {
 
            QuantLib::ext::shared_ptr<CommoditySchwartzData> config(new CommoditySchwartzData());
            config->fromXML(child);
 
            for (Size i = 0; i < config->optionExpiries().size(); i++) {
                LOG("Cross-Asset Commodity calibration option " << config->optionExpiries()[i] << " "
                    << config->optionStrikes()[i]);
            }
 
            comDataMap[config->name()] = config;
 
            LOG("CrossAssetModelData: Commodity config built with key " << config->name());
        }
    } else {
        LOG("No Commodity Models section found");
    }
 
    buildComConfigs(comDataMap);
 
    for (Size i = 0; i < comConfigs_.size(); i++)
        LOG("CrossAssetModelData: COM config name " << i << " = " << comConfigs_[i]->name());
 
    // Configure credit states
 
    numberOfCreditStates_ = 0;
    XMLNode* crStateNode = XMLUtils::getChildNode(modelNode, "CreditStates");
    if(crStateNode) {
        numberOfCreditStates_ = XMLUtils::getChildValueAsInt(crStateNode, "NumberOfFactors", true);
        LOG("Set up " << numberOfCreditStates_ << " credit states.");
    }
    else {
        LOG("No credit states section found");
    }
    
    // Configure correlation structure
    LOG("CrossAssetModelData: adding correlations.");
    correlations_ = QuantLib::ext::make_shared<InstantaneousCorrelations>();
    correlations_->fromXML(modelNode);
 
    validate();
 
    LOG("CrossAssetModelData loading from XML done");
}

Here is the call graph for this function:

◆ toXML()

XMLNode * toXML ( XMLDocument & doc ) const

overridevirtual

Implements XMLSerializable.

Definition at line 776 of file crossassetmodeldata.cpp.

                                                          {
 
    XMLNode* crossAssetModelNode = doc.allocNode("CrossAssetModel");
 
    XMLUtils::addChild(doc, crossAssetModelNode, "DomesticCcy", domesticCurrency_);
    XMLUtils::addChildren(doc, crossAssetModelNode, "Currencies", "Currency", currencies_);
    XMLUtils::addChildren(doc, crossAssetModelNode, "Equities", "Equity", equities_);
    XMLUtils::addChildren(doc, crossAssetModelNode, "InflationIndices", "InflationIndex", infindices_);
    XMLUtils::addChildren(doc, crossAssetModelNode, "CreditNames", "CreditName", creditNames_);
    XMLUtils::addChildren(doc, crossAssetModelNode, "Commodities", "Commodity", commodities_);
    XMLUtils::addChild(doc, crossAssetModelNode, "BootstrapTolerance", bootstrapTolerance_);
    XMLUtils::addChild(doc, crossAssetModelNode, "Measure", measure_);
    XMLUtils::addChild(doc, crossAssetModelNode, "Discretization",
                       discretization_ == CrossAssetModel::Discretization::Exact ? "Exact" : "Euler");
 
    XMLNode* interestRateModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "InterestRateModels");
    for (Size irConfigs_Iterator = 0; irConfigs_Iterator < irConfigs_.size(); irConfigs_Iterator++) {
        XMLNode* lgmNode = irConfigs_[irConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(interestRateModelsNode, lgmNode);
    }
 
    XMLNode* foreignExchangeModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "ForeignExchangeModels");
    for (Size fxConfigs_Iterator = 0; fxConfigs_Iterator < fxConfigs_.size(); fxConfigs_Iterator++) {
        XMLNode* crossCcyLgmNode = fxConfigs_[fxConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(foreignExchangeModelsNode, crossCcyLgmNode);
    }
 
    XMLNode* eqModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "EquityModels");
    for (Size eqConfigs_Iterator = 0; eqConfigs_Iterator < eqConfigs_.size(); eqConfigs_Iterator++) {
        XMLNode* crossAssetEqNode = eqConfigs_[eqConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(eqModelsNode, crossAssetEqNode);
    }
 
    XMLNode* infModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "InflationIndexModels");
    for (Size infConfigs_Iterator = 0; infConfigs_Iterator < infConfigs_.size(); infConfigs_Iterator++) {
        XMLNode* crossAssetInfNode = infConfigs_[infConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(infModelsNode, crossAssetInfNode);
    }
 
    XMLNode* crModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "CreditModels");
    for (Size crLgmConfigs_Iterator = 0; crLgmConfigs_Iterator < crLgmConfigs_.size(); crLgmConfigs_Iterator++) {
        XMLNode* crossAssetCrLgmNode = crLgmConfigs_[crLgmConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(crModelsNode, crossAssetCrLgmNode);
    }
    for (Size crCirConfigs_Iterator = 0; crCirConfigs_Iterator < crCirConfigs_.size(); crCirConfigs_Iterator++) {
        XMLNode* crossAssetCrCirNode = crCirConfigs_[crCirConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(crModelsNode, crossAssetCrCirNode);
    }
 
    XMLNode* comModelsNode = XMLUtils::addChild(doc, crossAssetModelNode, "CommodityModels");
    for (Size comConfigs_Iterator = 0; comConfigs_Iterator < comConfigs_.size(); comConfigs_Iterator++) {
        XMLNode* crossAssetComNode = comConfigs_[comConfigs_Iterator]->toXML(doc);
        XMLUtils::appendNode(comModelsNode, crossAssetComNode);
    }
 
    XMLNode* creditStateNode = XMLUtils::addChild(doc, crossAssetModelNode, "CreditStates");
    XMLUtils::addChild(doc, creditStateNode, "NumberOfFactors", static_cast<int>(numberOfCreditStates_));
 
    XMLNode* instantaneousCorrelationsNode = correlations_->toXML(doc);
    XMLUtils::appendNode(crossAssetModelNode, instantaneousCorrelationsNode);
 
    return crossAssetModelNode;
}

Here is the call graph for this function:

◆ operator==()

bool operator== ( const CrossAssetModelData & rhs )

Definition at line 131 of file crossassetmodeldata.cpp.

                                                                   {
 
    if (*correlations_ != *rhs.correlations_)
        return false;
 
    if (domesticCurrency_ != rhs.domesticCurrency_ || currencies_ != rhs.currencies_ || equities_ != rhs.equities_ ||
        infindices_ != rhs.infindices_ || bootstrapTolerance_ != rhs.bootstrapTolerance_ ||
        irConfigs_.size() != rhs.irConfigs_.size() || fxConfigs_.size() != rhs.fxConfigs_.size() ||
        eqConfigs_.size() != rhs.eqConfigs_.size() || infConfigs_.size() != rhs.infConfigs_.size() ||
        crLgmConfigs_.size() != rhs.crLgmConfigs_.size() || crCirConfigs_.size() != rhs.crCirConfigs_.size() ||
        comConfigs_.size() != rhs.comConfigs_.size()) {
        return false;
    }
 
    for (Size i = 0; i < irConfigs_.size(); i++) {
        auto c1 = QuantLib::ext::dynamic_pointer_cast<LgmData>(irConfigs_[i]);
        auto c2 = QuantLib::ext::dynamic_pointer_cast<LgmData>(irConfigs_[i]);
        auto c3 = QuantLib::ext::dynamic_pointer_cast<HwModelData>(irConfigs_[i]);
        auto c4 = QuantLib::ext::dynamic_pointer_cast<HwModelData>(irConfigs_[i]);
        if (c1 != nullptr && c2 != nullptr) {
            if (*c1 != *c2) {
                return false;
            }
        } else if (c3 != nullptr && c4 != nullptr) {
            if (*c3 != *c4) {
                return false;
            }
        } else {
            return false;
        }
    }
 
    for (Size i = 0; i < fxConfigs_.size(); i++) {
        if (*fxConfigs_[i] != *(rhs.fxConfigs_[i])) {
            return false;
        }
    }
 
    for (Size i = 0; i < eqConfigs_.size(); i++) {
        if (*eqConfigs_[i] != *(rhs.eqConfigs_[i])) {
            return false;
        }
    }
 
    // Not checking inflation model data for equality. The equality operators were only written to support
    // unit testing toXML and fromXML. Questionable if it should be done this way.
 
    for (Size i = 0; i < crLgmConfigs_.size(); i++) {
        if (*crLgmConfigs_[i] != *(rhs.crLgmConfigs_[i])) {
            return false;
        }
    }
 
    for (Size i = 0; i < crCirConfigs_.size(); i++) {
        if (*crCirConfigs_[i] != *(rhs.crCirConfigs_[i])) {
            return false;
        }
    }
 
    for (Size i = 0; i < comConfigs_.size(); i++) {
        if (*comConfigs_[i] != *(rhs.comConfigs_[i])) {
            return false;
        }
    }
 
    return true;
}

◆ operator!=()

bool operator!= ( const CrossAssetModelData & rhs )

Definition at line 199 of file crossassetmodeldata.cpp.

199{ return !(*this == rhs); }

◆ buildIrConfigs()

void buildIrConfigs ( map< string, QuantLib::ext::shared_ptr< IrModelData > > & irMap )

helper to convert LGM data, possibly including defaults, into an IR config vector

Definition at line 574 of file crossassetmodeldata.cpp.

                                                                                                         {
    // Append IR configurations into the irConfigs vector in the order of the currencies
    // in the currencies vector.
    // If there is an IR configuration for any of the currencies missing, then we will
    // look up the configuration with key "default" and use this instead. If this is
    // not provided either we will throw an exception.
    irConfigs_.resize(currencies_.size());
    for (Size i = 0; i < currencies_.size(); i++) {
        string ccy = currencies_[i];
        std::string ccyKey;
        for (auto const& d : irDataMap) {
            if (d.second->ccy() == ccy) {
                QL_REQUIRE(ccyKey.empty(), "CrossAssetModelData: duplicate ir config for ccy " << ccy);
                ccyKey = d.first;
            }
        }
        if (!ccyKey.empty())
            irConfigs_[i] = irDataMap.at(ccyKey);
        else { // copy from default
            LOG("IR configuration missing for currency " << ccy << ", using default");
            if (irDataMap.find("default") == irDataMap.end()) {
                ALOG("Both default IR and " << ccy << " IR configuration missing");
                QL_FAIL("Both default IR and " << ccy << " IR configuration missing");
            }
            if (auto def = QuantLib::ext::dynamic_pointer_cast<HwModelData>(irDataMap["default"])) {
                irConfigs_[i] = QuantLib::ext::make_shared<HwModelData>(
                    ccy, // overwrite this and keep the others
                    def->calibrationType(), def->calibrateKappa(),
                    def->kappaType(), def->kappaTimes(), def->kappaValues(), def->calibrateSigma(), def->sigmaType(),
                    def->sigmaTimes(), def->sigmaValues(), def->optionExpiries(),
                    def->optionTerms(), def->optionStrikes());
                
            } else if (auto def = QuantLib::ext::dynamic_pointer_cast<IrLgmData>(irDataMap["default"])) {
                irConfigs_[i] = QuantLib::ext::make_shared<IrLgmData>(
                    ccy, // overwrite this and keep the others
                    def->calibrationType(), def->reversionType(), def->volatilityType(), def->calibrateH(),
                    def->hParamType(), def->hTimes(), def->hValues(), def->calibrateA(), def->aParamType(),
                    def->aTimes(), def->aValues(), def->shiftHorizon(), def->scaling(), def->optionExpiries(),
                    def->optionTerms(), def->optionStrikes());
            } else {
                QL_FAIL("Unexpected model data type,expect either HwModelData or IrLgmData");
            } 
        }
        LOG("CrossAssetModelData: IR config added for ccy " << irConfigs_[i]->ccy());
    }
}

Here is the caller graph for this function:

◆ buildFxConfigs()

void buildFxConfigs ( std::map< std::string, QuantLib::ext::shared_ptr< FxBsData > > & fxMap )

helper to convert FX data, possibly including defaults, into an FX config vector

Definition at line 621 of file crossassetmodeldata.cpp.

                                                                                                      {
    // Append FX configurations into the fxConfigs vector in the order of the foreign
    // currencies in the currencies vector.
    // If there is an FX configuration for any of the foreign currencies missing,
    // then we will look up the configuration with key "default" and use this instead.
    // If this is not provided either we will throw an exception.
    for (Size i = 0; i < currencies_.size(); i++) {
        string ccy = currencies_[i];
        if (ccy == domesticCurrency_)
            continue;
        if (fxDataMap.find(ccy) != fxDataMap.end())
            fxConfigs_.push_back(fxDataMap[ccy]);
        else { // copy from default
            LOG("FX configuration missing for foreign currency " << ccy << ", using default");
            if (fxDataMap.find("default") == fxDataMap.end()) {
                ALOG("Both default FX and " << ccy << " FX configuration missing");
                QL_FAIL("Both default FX and " << ccy << " FX configuration missing");
            }
            QuantLib::ext::shared_ptr<FxBsData> def = fxDataMap["default"];
            QuantLib::ext::shared_ptr<FxBsData> fxData = QuantLib::ext::make_shared<FxBsData>(
                ccy, def->domesticCcy(), def->calibrationType(), def->calibrateSigma(), def->sigmaParamType(),
                def->sigmaTimes(), def->sigmaValues(), def->optionExpiries(), def->optionStrikes());
 
            fxConfigs_.push_back(fxData);
        }
        LOG("CrossAssetModelData: FX config added for foreign ccy " << ccy);
    }
}

Here is the caller graph for this function:

◆ buildEqConfigs()

void buildEqConfigs ( std::map< std::string, QuantLib::ext::shared_ptr< EqBsData > > & eqMap )

helper to convert EQ data, possibly including defaults, into an EQ config vector

Definition at line 650 of file crossassetmodeldata.cpp.

                                                                                                      {
    // Append Eq configurations into the eqConfigs vector in the order of the equity
    // names in the equities) vector.
    // If there is an Eq configuration for any of the names missing,
    // then we will look up the configuration with key "default" and use this instead.
    // If this is not provided either we will throw an exception.
    for (Size i = 0; i < equities_.size(); i++) {
        string name = equities_[i];
        if (eqDataMap.find(name) != eqDataMap.end())
            eqConfigs_.push_back(eqDataMap[name]);
        else { // copy from default
            LOG("Equity configuration missing for name " << name << ", using default");
            if (eqDataMap.find("default") == eqDataMap.end()) {
                ALOG("Both default EQ and " << name << " EQ configuration missing");
                QL_FAIL("Both default EQ and " << name << " EQ configuration missing");
            }
            QuantLib::ext::shared_ptr<EqBsData> def = eqDataMap["default"];
            QuantLib::ext::shared_ptr<EqBsData> eqData = QuantLib::ext::make_shared<EqBsData>(
                name, def->currency(), def->calibrationType(), def->calibrateSigma(), def->sigmaParamType(),
                def->sigmaTimes(), def->sigmaValues(), def->optionExpiries(), def->optionStrikes());
 
            eqConfigs_.push_back(eqData);
        }
        LOG("CrossAssetModelData: EQ config added for name " << name);
    }
}

Here is the caller graph for this function:

◆ buildInfConfigs()

void buildInfConfigs ( const std::map< std::string, QuantLib::ext::shared_ptr< InflationModelData > > & mp )

helper to convert INF data, possibly including defaults, into an INF config vector

Definition at line 677 of file crossassetmodeldata.cpp.

                                                                                                          {
 
    // Append inflation model data to the infConfigs_ vector in the order of the inflation indices in the infindices_
    // vector.
 
    // If for any of the inflation indices in the infindices_ vector, there is no inflation model data in mp then the
    // default inflation model data is used. The default inflation model data should be in mp under the key name
    // "default". If it is not provided either, an exception is thrown.
 
    for (const string& indexName : infindices_) {
 
        auto it = mp.find(indexName);
        if (it != mp.end()) {
            infConfigs_.push_back(it->second);
        } else {
 
            LOG("Inflation index model data missing for index " << indexName << " so attempt to use default");
 
            auto itDefault = mp.find("default");
            QL_REQUIRE(itDefault != mp.end(),
                       "Inflation index model data missing for index " << indexName << " and for default.");
 
            // Make a copy of the model data and add to vector.
            QuantLib::ext::shared_ptr<InflationModelData> imData = itDefault->second;
            if (auto dk = QuantLib::ext::dynamic_pointer_cast<InfDkData>(imData)) {
                infConfigs_.push_back(QuantLib::ext::make_shared<InfDkData>(*dk));
            } else if (auto jy = QuantLib::ext::dynamic_pointer_cast<InfJyData>(imData)) {
                infConfigs_.push_back(QuantLib::ext::make_shared<InfJyData>(*jy));
            } else {
                QL_FAIL("Expected inflation model data to be DK or JY.");
            }
        }
 
        LOG("CrossAssetModelData: INF config added for name " << indexName);
    }
}

Here is the caller graph for this function:

◆ buildCrConfigs()

void buildCrConfigs	(	std::map< std::string, QuantLib::ext::shared_ptr< CrLgmData > > &	crLgmMap,
		std::map< std::string, QuantLib::ext::shared_ptr< CrCirData > > &	crCirMap
	)

helper to convert CR LGM data, possibly including defaults, into CR config vectors

Definition at line 714 of file crossassetmodeldata.cpp.

                                                                                                            {
    // Append IR configurations into the irConfigs vector in the order of the currencies
    // in the currencies vector.
    // If there is an IR configuration for any of the currencies missing, then we will
    // look up the configuration with key "default" and use this instead. If this is
    // not provided either we will throw an exception.
    crLgmConfigs_.clear();
    crCirConfigs_.clear();
 
    for (Size i = 0; i < creditNames_.size(); i++) {
        string name = creditNames_[i];
        if (crLgmDataMap.find(name) != crLgmDataMap.end()) {
            QL_REQUIRE(crCirDataMap.find(name) == crCirDataMap.end(), "");
            crLgmConfigs_.push_back(crLgmDataMap[name]);
        } else if (crCirDataMap.find(name) != crCirDataMap.end()) {
            crCirConfigs_.push_back(crCirDataMap[name]);
        } else { // copy from LGM default, CIR default is not used
            LOG("CR configuration missing for name " << name << ", using default");
            if (crLgmDataMap.find("default") == crLgmDataMap.end()) {
                ALOG("Both default CR LGM and " << name << " CR configuration missing");
                QL_FAIL("Both default CR and " << name << " CR configuration missing");
            }
            QuantLib::ext::shared_ptr<CrLgmData> def = crLgmDataMap["default"];
            crLgmConfigs_.push_back(QuantLib::ext::make_shared<CrLgmData>(
                name, // overwrite this and keep the others
                def->calibrationType(), def->reversionType(), def->volatilityType(), def->calibrateH(),
                def->hParamType(), def->hTimes(), def->hValues(), def->calibrateA(), def->aParamType(), def->aTimes(),
                def->aValues(), def->shiftHorizon(), def->scaling(), def->optionExpiries(), def->optionTerms(),
                def->optionStrikes()));
        }
        LOG("CrossAssetModelData: CR config added for name " << name << " " << name);
    }
}

Here is the caller graph for this function:

◆ buildComConfigs()

void buildComConfigs ( std::map< std::string, QuantLib::ext::shared_ptr< CommoditySchwartzData > > & comMap )

helper to convert COM data, possibly including defaulta, into a COM config vector

Definition at line 749 of file crossassetmodeldata.cpp.

                                                                                                                     {
    // Append Commodity configurations into the comConfigs vector in the order of the commodity
    // names in the commodities vector.
    // If there is a COM configuration for any of the names missing,
    // then we will look up the configuration with key "default" and use this instead.
    // If this is not provided either we will throw an exception.
    for (Size i = 0; i < commodities_.size(); i++) {
        string name = commodities_[i];
        if (comDataMap.find(name) != comDataMap.end())
            comConfigs_.push_back(comDataMap[name]);
        else { // copy from default
            LOG("Commodity configuration missing for name " << name << ", using default");
            if (comDataMap.find("default") == comDataMap.end()) {
                ALOG("Both default COM and " << name << " COM configuration missing");
                QL_FAIL("Both default COM and " << name << " COM configuration missing");
            }
            QuantLib::ext::shared_ptr<CommoditySchwartzData> def = comDataMap["default"];
            QuantLib::ext::shared_ptr<CommoditySchwartzData> comData = QuantLib::ext::make_shared<CommoditySchwartzData>(
                name, def->currency(), def->calibrationType(), def->calibrateSigma(), def->sigmaValue(),
                def->calibrateKappa(), def->kappaValue(), def->optionExpiries(), def->optionStrikes());
 
            comConfigs_.push_back(comData);
        }
        LOG("CrossAssetModelData: COM config added for name " << name);
    }
}

Here is the caller graph for this function:

Member Data Documentation

◆ domesticCurrency_

string domesticCurrency_

private

Definition at line 297 of file crossassetmodeldata.hpp.

◆ currencies_

vector<std::string> currencies_

private

Definition at line 298 of file crossassetmodeldata.hpp.

◆ equities_

vector<std::string> equities_

private

Definition at line 299 of file crossassetmodeldata.hpp.

◆ infindices_

vector<std::string> infindices_

private

Definition at line 300 of file crossassetmodeldata.hpp.

◆ creditNames_

vector<std::string> creditNames_

private

Definition at line 301 of file crossassetmodeldata.hpp.

◆ commodities_

vector<std::string> commodities_

private

Definition at line 302 of file crossassetmodeldata.hpp.

◆ irConfigs_

vector<QuantLib::ext::shared_ptr<IrModelData> > irConfigs_

private

Definition at line 303 of file crossassetmodeldata.hpp.

◆ fxConfigs_

vector<QuantLib::ext::shared_ptr<FxBsData> > fxConfigs_

private

Definition at line 304 of file crossassetmodeldata.hpp.

◆ eqConfigs_

vector<QuantLib::ext::shared_ptr<EqBsData> > eqConfigs_

private

Definition at line 305 of file crossassetmodeldata.hpp.

◆ infConfigs_

vector<QuantLib::ext::shared_ptr<InflationModelData> > infConfigs_

private

Definition at line 306 of file crossassetmodeldata.hpp.

◆ crLgmConfigs_

vector<QuantLib::ext::shared_ptr<CrLgmData> > crLgmConfigs_

private

Definition at line 307 of file crossassetmodeldata.hpp.

◆ crCirConfigs_

vector<QuantLib::ext::shared_ptr<CrCirData> > crCirConfigs_

private

Definition at line 308 of file crossassetmodeldata.hpp.

◆ comConfigs_

vector<QuantLib::ext::shared_ptr<CommoditySchwartzData> > comConfigs_

private

Definition at line 309 of file crossassetmodeldata.hpp.

◆ numberOfCreditStates_

Size numberOfCreditStates_ = 0

private

Definition at line 310 of file crossassetmodeldata.hpp.

◆ correlations_

QuantLib::ext::shared_ptr<InstantaneousCorrelations> correlations_

private

Definition at line 312 of file crossassetmodeldata.hpp.

◆ bootstrapTolerance_

Real bootstrapTolerance_

private

Definition at line 313 of file crossassetmodeldata.hpp.

◆ measure_

std::string measure_

private

Definition at line 314 of file crossassetmodeldata.hpp.

◆ discretization_

CrossAssetModel::Discretization discretization_

private

Definition at line 315 of file crossassetmodeldata.hpp.

Classes

Public Member Functions

Operators

Detailed Description

Constructor & Destructor Documentation

◆ CrossAssetModelData() [1/4]

◆ CrossAssetModelData() [2/4]

◆ CrossAssetModelData() [3/4]

◆ CrossAssetModelData() [4/4]

Member Function Documentation

◆ clear()

◆ validate()

◆ domesticCurrency() [1/2]

◆ currencies() [1/2]

◆ equities() [1/2]

◆ infIndices() [1/2]

◆ creditNames() [1/2]

◆ commodities() [1/2]

◆ irConfigs() [1/2]

◆ fxConfigs() [1/2]

◆ eqConfigs() [1/2]

◆ infConfigs() [1/2]

◆ crLgmConfigs() [1/2]

◆ crCirConfigs() [1/2]

◆ comConfigs() [1/2]

◆ numberOfCreditStates()

◆ correlations()

◆ bootstrapTolerance() [1/2]

◆ measure() [1/2]

◆ discretization() [1/2]

◆ domesticCurrency() [2/2]

◆ currencies() [2/2]

◆ equities() [2/2]

◆ infIndices() [2/2]

◆ creditNames() [2/2]

◆ commodities() [2/2]

◆ irConfigs() [2/2]

◆ fxConfigs() [2/2]

◆ eqConfigs() [2/2]

◆ infConfigs() [2/2]

◆ crLgmConfigs() [2/2]

◆ crCirConfigs() [2/2]

◆ comConfigs() [2/2]

◆ setCorrelations() [1/2]

◆ setCorrelations() [2/2]

◆ bootstrapTolerance() [2/2]

◆ measure() [2/2]

◆ discretization() [2/2]

◆ fromXML()

◆ toXML()

◆ operator==()

◆ operator!=()

◆ buildIrConfigs()

◆ buildFxConfigs()

◆ buildEqConfigs()

◆ buildInfConfigs()

◆ buildCrConfigs()

◆ buildComConfigs()

Member Data Documentation

◆ domesticCurrency_

◆ currencies_

◆ equities_

◆ infindices_

◆ creditNames_

◆ commodities_

◆ irConfigs_

◆ fxConfigs_

◆ eqConfigs_

◆ infConfigs_

◆ crLgmConfigs_

◆ crCirConfigs_

◆ comConfigs_

◆ numberOfCreditStates_

◆ correlations_

◆ bootstrapTolerance_

◆ measure_

◆ discretization_