@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Object positionOrNode = getTarget(target);
final ConventionBundleSource conventionSource =
OpenGammaExecutionContext.getConventionBundleSource(executionContext);
final ConventionBundle bundle =
conventionSource.getConventionBundle(
ExternalId.of(InMemoryConventionBundleMaster.SIMPLE_NAME_SCHEME, "USD_CAPM"));
final Clock snapshotClock = executionContext.getValuationClock();
final LocalDate now = snapshotClock.zonedDateTime().toLocalDate();
final ValueRequirement desiredValue = desiredValues.iterator().next();
final ValueProperties constraints = desiredValue.getConstraints();
final Period samplingPeriod =
getSamplingPeriod(constraints.getValues(ValuePropertyNames.SAMPLING_PERIOD));
final LocalDate startDate = now.minus(samplingPeriod);
final HistoricalTimeSeries riskFreeRateTSObject =
(HistoricalTimeSeries) inputs.getValue(ValueRequirementNames.HISTORICAL_TIME_SERIES);
final Object assetPnLObject =
inputs.getValue(
new ValueRequirement(
ValueRequirementNames.PNL_SERIES,
positionOrNode)); // TODO replace with return series when portfolio weights are in
if (assetPnLObject == null) {
throw new OpenGammaRuntimeException("Asset P&L was null");
}
final Object assetFairValueObject =
inputs.getValue(new ValueRequirement(ValueRequirementNames.FAIR_VALUE, positionOrNode));
if (assetFairValueObject == null) {
throw new OpenGammaRuntimeException("Asset fair value was null");
}
final Object betaObject =
inputs.getValue(new ValueRequirement(ValueRequirementNames.CAPM_BETA, positionOrNode));
if (betaObject == null) {
throw new OpenGammaRuntimeException("Beta was null");
}
final double beta = (Double) betaObject;
final double fairValue = (Double) assetFairValueObject;
DoubleTimeSeries<?> assetReturnTS = ((DoubleTimeSeries<?>) assetPnLObject).divide(fairValue);
DoubleTimeSeries<?> riskFreeReturnTS =
riskFreeRateTSObject.getTimeSeries().divide(100 * DAYS_PER_YEAR);
DoubleTimeSeries<?>[] series = TimeSeriesIntersector.intersect(riskFreeReturnTS, assetReturnTS);
riskFreeReturnTS = series[0];
assetReturnTS = series[1];
final TreynorRatioCalculator calculator =
getCalculator(constraints.getValues(ValuePropertyNames.EXCESS_RETURN_CALCULATOR));
final double ratio = calculator.evaluate(assetReturnTS, riskFreeReturnTS, beta);
final ValueProperties resultProperties = getResultProperties(desiredValues.iterator().next());
return Sets.newHashSet(
new ComputedValue(
new ValueSpecification(
new ValueRequirement(
ValueRequirementNames.TREYNOR_RATIO, positionOrNode, resultProperties),
getUniqueId()),
ratio));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
String curveName = null;
String curveCalculationConfig = null;
for (final ValueRequirement requirement : desiredValues) {
final ValueProperties constraints = requirement.getConstraints();
final Set<String> values = constraints.getValues(ValuePropertyNames.CURVE);
if (values != null) {
curveName = values.iterator().next();
}
final Set<String> curveConfigValues =
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if (curveConfigValues != null) {
curveCalculationConfig = curveConfigValues.iterator().next();
}
}
assert curveName != null;
assert curveCalculationConfig != null;
final RawSecurity security = (RawSecurity) target.getSecurity();
// final BigDecimal qty = target.getPosition().getQuantity();
final ValueRequirement curveRequirement =
getCurveRequirement(target, curveName, curveCalculationConfig);
final Object curveObject = inputs.getValue(curveRequirement);
if (curveObject == null) {
throw new OpenGammaRuntimeException("Could not get " + curveRequirement);
}
Object curveSpecObject = null;
final ValueRequirement curveSpecRequirement = getCurveSpecRequirement(target, curveName);
curveSpecObject = inputs.getValue(curveSpecRequirement);
if (curveSpecObject == null) {
throw new OpenGammaRuntimeException("Could not get " + curveSpecRequirement);
}
final YieldAndDiscountCurve curve = (YieldAndDiscountCurve) curveObject;
final InterpolatedYieldCurveSpecificationWithSecurities curveSpec =
(InterpolatedYieldCurveSpecificationWithSecurities) curveSpecObject;
final LinkedHashMap<String, YieldAndDiscountCurve> interpolatedCurves =
new LinkedHashMap<String, YieldAndDiscountCurve>();
interpolatedCurves.put(curveName, curve);
final YieldCurveBundle bundle = new YieldCurveBundle(interpolatedCurves);
final DoubleMatrix1D sensitivitiesForCurves =
getSensitivities(executionContext.getSecuritySource(), inputs, security, curveSpec, curve);
final ValueProperties.Builder properties =
createValueProperties(target)
.with(ValuePropertyNames.CURVE, curveName)
.with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfig);
final ComputationTargetSpecification targetSpec = target.toSpecification();
final ValueSpecification resultSpec =
new ValueSpecification(YCNS_REQUIREMENT, targetSpec, properties.get());
final Set<ComputedValue> results =
YieldCurveNodeSensitivitiesHelper.getInstrumentLabelledSensitivitiesForCurve(
curveName, bundle, sensitivitiesForCurves, curveSpec, resultSpec);
// s_logger.debug("execute, returning " + results);
return results;
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = snapshotClock.zonedDateTime();
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency payCurrency, receiveCurrency;
if (security instanceof FXForwardSecurity) {
final FXForwardSecurity forward = (FXForwardSecurity) security;
payCurrency = forward.getPayCurrency();
receiveCurrency = forward.getReceiveCurrency();
} else {
final NonDeliverableFXForwardSecurity ndf = (NonDeliverableFXForwardSecurity) security;
payCurrency = ndf.getPayCurrency();
receiveCurrency = ndf.getReceiveCurrency();
}
final ForexDefinition definition = (ForexDefinition) security.accept(VISITOR);
final ValueRequirement desiredValue = desiredValues.iterator().next();
final String payCurveName = desiredValue.getConstraint(ValuePropertyNames.PAY_CURVE);
final String receiveCurveName = desiredValue.getConstraint(ValuePropertyNames.RECEIVE_CURVE);
final String payCurveConfig = desiredValue.getConstraint(PAY_CURVE_CALC_CONFIG);
final String receiveCurveConfig = desiredValue.getConstraint(RECEIVE_CURVE_CALC_CONFIG);
final String fullPutCurveName = payCurveName + "_" + payCurrency.getCode();
final String fullCallCurveName = receiveCurveName + "_" + receiveCurrency.getCode();
final YieldAndDiscountCurve payFundingCurve =
getCurve(inputs, payCurrency, payCurveName, payCurveConfig);
final YieldAndDiscountCurve receiveFundingCurve =
getCurve(inputs, receiveCurrency, receiveCurveName, receiveCurveConfig);
final YieldAndDiscountCurve[] curves;
final Map<String, Currency> curveCurrency = new HashMap<String, Currency>();
curveCurrency.put(fullPutCurveName, payCurrency);
curveCurrency.put(fullCallCurveName, receiveCurrency);
final String[] allCurveNames;
if (FXUtils.isInBaseQuoteOrder(
payCurrency, receiveCurrency)) { // To get Base/quote in market standard order.
curves = new YieldAndDiscountCurve[] {payFundingCurve, receiveFundingCurve};
allCurveNames = new String[] {fullPutCurveName, fullCallCurveName};
} else {
curves = new YieldAndDiscountCurve[] {receiveFundingCurve, payFundingCurve};
allCurveNames = new String[] {fullCallCurveName, fullPutCurveName};
}
final YieldCurveBundle yieldCurves = new YieldCurveBundle(allCurveNames, curves);
final ValueProperties.Builder properties =
getResultProperties(
payCurveName, receiveCurveName, payCurveConfig, receiveCurveConfig, target);
final ValueSpecification spec =
new ValueSpecification(
ValueRequirementNames.VALUE_THETA, target.toSpecification(), properties.get());
final ConstantSpreadHorizonThetaCalculator calculator =
ConstantSpreadHorizonThetaCalculator.getInstance();
final MultipleCurrencyAmount theta =
calculator.getTheta(definition, now, allCurveNames, yieldCurves, DAYS_TO_MOVE_FORWARD);
return Collections.singleton(new ComputedValue(spec, theta));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final FXFutureSecurity security = (FXFutureSecurity) target.getSecurity();
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
final Currency payCurrency = security.getNumerator();
final Object payCurveObject =
inputs.getValue(
YieldCurveFunction.getCurveRequirement(payCurrency, _payCurveName, null, null));
if (payCurveObject == null) {
throw new OpenGammaRuntimeException("Could not get " + _payCurveName + " curve");
}
final Currency receiveCurrency = security.getDenominator();
final Object receiveCurveObject =
inputs.getValue(
YieldCurveFunction.getCurveRequirement(receiveCurrency, _receiveCurveName, null, null));
if (receiveCurveObject == null) {
throw new OpenGammaRuntimeException("Could not get " + _receiveCurveName + " curve");
}
// TODO: The convention is only looked up here so that we can convert the spot rate; would be
// better to request the spot rate using the correct currency pair in the first place
final CurrencyPairs currencyPairs =
OpenGammaExecutionContext.getCurrencyPairsSource(executionContext)
.getCurrencyPairs(CurrencyPairs.DEFAULT_CURRENCY_PAIRS);
final CurrencyPair currencyPair = currencyPairs.getCurrencyPair(payCurrency, receiveCurrency);
final Currency currencyBase = currencyPair.getBase();
final Object spotObject = inputs.getValue(ValueRequirementNames.SPOT_RATE);
if (spotObject == null) {
throw new OpenGammaRuntimeException("Could not get market data for spot rate");
}
double spot = (Double) spotObject;
if (!receiveCurrency.equals(currencyBase) && receiveCurrency.equals(security.getCurrency())) {
spot = 1. / spot;
}
final YieldAndDiscountCurve payCurve = (YieldAndDiscountCurve) payCurveObject;
final YieldAndDiscountCurve receiveCurve = (YieldAndDiscountCurve) receiveCurveObject;
final SimpleFXFutureDataBundle data =
new SimpleFXFutureDataBundle(payCurve, receiveCurve, spot);
final SimpleInstrument instrument = security.accept(CONVERTER).toDerivative(now);
final CurrencyAmount pv = instrument.accept(CALCULATOR, data);
final ValueProperties properties =
createValueProperties()
.with(ValuePropertyNames.PAY_CURVE, _payCurveName)
.with(ValuePropertyNames.RECEIVE_CURVE, _receiveCurveName)
.with(ValuePropertyNames.CURRENCY, pv.getCurrency().getCode())
.get();
final ValueSpecification spec =
new ValueSpecification(
ValueRequirementNames.PRESENT_VALUE, target.toSpecification(), properties);
return Collections.singleton(new ComputedValue(spec, pv.getAmount()));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency currency = FinancialSecurityUtils.getCurrency(security);
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = snapshotClock.zonedDateTime();
final HistoricalTimeSeriesBundle timeSeries =
HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
final ValueRequirement desiredValue = desiredValues.iterator().next();
final String curveCalculationConfigName =
desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
final ConfigSource configSource = OpenGammaExecutionContext.getConfigSource(executionContext);
final ConfigDBCurveCalculationConfigSource curveCalculationConfigSource =
new ConfigDBCurveCalculationConfigSource(configSource);
final MultiCurveCalculationConfig curveCalculationConfig =
curveCalculationConfigSource.getConfig(curveCalculationConfigName);
if (curveCalculationConfig == null) {
throw new OpenGammaRuntimeException(
"Could not find curve calculation configuration named " + curveCalculationConfigName);
}
final String[] curveNames = curveCalculationConfig.getYieldCurveNames();
final String[] yieldCurveNames =
curveNames.length == 1 ? new String[] {curveNames[0], curveNames[0]} : curveNames;
final String[] curveNamesForSecurity =
FixedIncomeInstrumentCurveExposureHelper.getCurveNamesForSecurity(
security, yieldCurveNames[0], yieldCurveNames[1]);
final YieldCurveBundle bundle =
YieldCurveFunctionUtils.getAllYieldCurves(
inputs, curveCalculationConfig, curveCalculationConfigSource);
final InstrumentDefinition<?> definition = security.accept(_visitor);
if (definition == null) {
throw new OpenGammaRuntimeException("Definition for security " + security + " was null");
}
final InstrumentDerivative derivative =
getDerivative(
security, now, timeSeries, curveNamesForSecurity, definition, _definitionConverter);
return getComputedValues(
derivative, bundle, security, target, curveCalculationConfigName, currency.getCode());
}
@Override
public Set<ComputedValue> execute(
FunctionExecutionContext executionContext,
FunctionInputs inputs,
ComputationTarget target,
Set<ValueRequirement> desiredValues) {
// 1. Get the expiry _time_ from the trade
SimpleTrade trade =
(SimpleTrade) target.getTrade(); // confirms that the ComputationTargetType == TRADE
EquityVarianceSwapSecurity security = (EquityVarianceSwapSecurity) trade.getSecurity();
double expiry =
TimeCalculator.getTimeBetween(
executionContext.getValuationClock().zonedDateTime(),
security.getLastObservationDate());
// ExternalId id = security.getSpotUnderlyingIdentifier();
// 2. Get the discount curve and spot value
Object discountObject = inputs.getValue(getDiscountRequirement(security));
if (discountObject == null) {
throw new OpenGammaRuntimeException("Could not get Discount Curve");
}
YieldAndDiscountCurve discountCurve = (YieldAndDiscountCurve) discountObject;
Object spotObject = inputs.getValue(getSpotRequirement(security));
if (spotObject == null) {
throw new OpenGammaRuntimeException("Could not get Underlying's Spot value");
}
double spot = (Double) spotObject;
// 3. Compute the forward
final double discountFactor = discountCurve.getDiscountFactor(expiry);
Validate.isTrue(
discountFactor != 0,
"The discount curve has returned a zero value for a discount bond. Check rates.");
final double forward = spot / discountFactor;
ValueSpecification valueSpec = getValueSpecification(security);
return Collections.singleton(new ComputedValue(valueSpec, forward));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final ValueRequirement desiredValue = Iterables.getOnlyElement(desiredValues);
final String curveName = desiredValue.getConstraint(ValuePropertyNames.CURVE);
final String curveCalculationConfig =
desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
// 1. Get the expiry _time_ from the trade
final EquityVarianceSwapSecurity security = (EquityVarianceSwapSecurity) target.getSecurity();
final double expiry =
TimeCalculator.getTimeBetween(
executionContext.getValuationClock().zonedDateTime(),
security.getLastObservationDate());
// 2. Get the discount curve and spot value
final Object discountObject =
inputs.getValue(getDiscountRequirement(security, curveName, curveCalculationConfig));
if (discountObject == null) {
throw new OpenGammaRuntimeException("Could not get Discount Curve");
}
final YieldAndDiscountCurve discountCurve = (YieldAndDiscountCurve) discountObject;
final Object spotObject = inputs.getValue(getSpotRequirement(security));
if (spotObject == null) {
throw new OpenGammaRuntimeException("Could not get Underlying's Spot value");
}
final double spot = (Double) spotObject;
// 3. Compute the forward
final double discountFactor = discountCurve.getDiscountFactor(expiry);
Validate.isTrue(
discountFactor != 0,
"The discount curve has returned a zero value for a discount bond. Check rates.");
final double forward = spot / discountFactor;
final ValueSpecification valueSpec = getValueSpecification(security);
return Collections.singleton(new ComputedValue(valueSpec, forward));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
final Object volatilitySurfaceDataObject = inputs.getValue(_requirement);
if (volatilitySurfaceDataObject == null) {
throw new OpenGammaRuntimeException("Could not get " + _requirement);
}
@SuppressWarnings("unchecked")
final VolatilitySurfaceData<LocalDate, Double> volatilitySurfaceData =
(VolatilitySurfaceData<LocalDate, Double>) volatilitySurfaceDataObject;
final int n = volatilitySurfaceData.getXs().length;
final int m = volatilitySurfaceData.getYs().length;
final DoubleArrayList t = new DoubleArrayList();
final DoubleArrayList k = new DoubleArrayList();
final DoubleArrayList sigma = new DoubleArrayList();
final LocalDate[] xDates = volatilitySurfaceData.getXs();
final Double[] y = volatilitySurfaceData.getYs();
for (int i = 0; i < n; i++) {
final Double time = DateUtils.getDifferenceInYears(now.toLocalDate(), xDates[i]);
for (int j = 0; j < m; j++) {
final Double strike = y[j];
final Double vol = volatilitySurfaceData.getVolatility(xDates[i], y[j]);
if (time != null && strike != null && vol != null) {
t.add(time);
k.add(strike);
sigma.add(vol);
}
}
}
final Surface<Double, Double, Double> surface =
InterpolatedDoublesSurface.from(
t.toDoubleArray(), k.toDoubleArray(), sigma.toDoubleArray(), _interpolator);
final VolatilitySurface volatilitySurface = new VolatilitySurface(surface);
return Collections.singleton(new ComputedValue(_result, volatilitySurface));
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency payCurrency = security.accept(ForexVisitors.getPayCurrencyVisitor());
final Currency receiveCurrency = security.accept(ForexVisitors.getReceiveCurrencyVisitor());
if (now.isAfter(security.accept(ForexVisitors.getExpiryVisitor()))) {
throw new OpenGammaRuntimeException(
"FX forward " + payCurrency.getCode() + "/" + receiveCurrency + " has expired");
}
final ValueRequirement desiredValue = desiredValues.iterator().next();
final String payCurveName = desiredValue.getConstraint(ValuePropertyNames.PAY_CURVE);
final String receiveCurveName = desiredValue.getConstraint(ValuePropertyNames.RECEIVE_CURVE);
final String payCurveConfig =
desiredValue.getConstraint(ValuePropertyNames.PAY_CURVE_CALCULATION_CONFIG);
final String receiveCurveConfig =
desiredValue.getConstraint(ValuePropertyNames.RECEIVE_CURVE_CALCULATION_CONFIG);
final String daysForward = desiredValue.getConstraint(PROPERTY_DAYS_TO_MOVE_FORWARD);
final String fullPayCurveName = payCurveName + "_" + payCurrency.getCode();
final String fullReceiveCurveName = receiveCurveName + "_" + receiveCurrency.getCode();
final YieldAndDiscountCurve payFundingCurve =
getPayCurve(inputs, payCurrency, payCurveName, payCurveConfig);
final YieldAndDiscountCurve receiveFundingCurve =
getReceiveCurve(inputs, receiveCurrency, receiveCurveName, receiveCurveConfig);
final YieldAndDiscountCurve[] curves;
final Map<String, Currency> curveCurrency = new HashMap<>();
curveCurrency.put(fullPayCurveName, payCurrency);
curveCurrency.put(fullReceiveCurveName, receiveCurrency);
final String[] allCurveNames;
final Object baseQuotePairsObject = inputs.getValue(ValueRequirementNames.CURRENCY_PAIRS);
if (baseQuotePairsObject == null) {
throw new OpenGammaRuntimeException("Could not get base/quote pair data");
}
final CurrencyPairs baseQuotePairs = (CurrencyPairs) baseQuotePairsObject;
final CurrencyPair baseQuotePair = baseQuotePairs.getCurrencyPair(payCurrency, receiveCurrency);
if (baseQuotePair == null) {
throw new OpenGammaRuntimeException(
"Could not get base/quote pair for currency pair ("
+ payCurrency
+ ", "
+ receiveCurrency
+ ")");
}
if (baseQuotePair
.getBase()
.equals(payCurrency)) { // To get Base/quote in market standard order.
curves = new YieldAndDiscountCurve[] {payFundingCurve, receiveFundingCurve};
allCurveNames = new String[] {fullPayCurveName, fullReceiveCurveName};
} else {
curves = new YieldAndDiscountCurve[] {receiveFundingCurve, payFundingCurve};
allCurveNames = new String[] {fullReceiveCurveName, fullPayCurveName};
}
final ForexSecurityConverter converter = new ForexSecurityConverter(baseQuotePairs);
final ForexDefinition definition = (ForexDefinition) security.accept(converter);
final YieldCurveBundle yieldCurves = new YieldCurveBundle(allCurveNames, curves);
final ValueProperties.Builder properties = getResultProperties(target, desiredValue);
final ValueSpecification spec =
new ValueSpecification(
getValueRequirementName(), target.toSpecification(), properties.get());
final ConstantSpreadHorizonThetaCalculator calculator =
ConstantSpreadHorizonThetaCalculator.getInstance();
final MultipleCurrencyAmount theta =
calculator.getTheta(
definition, now, allCurveNames, yieldCurves, Integer.parseInt(daysForward));
return Collections.singleton(new ComputedValue(spec, theta));
}
/**
* Gets a {@code ConventionBundleSource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static ConventionBundleSource getConventionBundleSource(
final FunctionExecutionContext context) {
return (ConventionBundleSource) context.get(CONVENTION_BUNDLE_SOURCE_NAME);
}
/**
* Gets a {@code SecuritySource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static SecuritySource getSecuritySource(final FunctionExecutionContext context) {
return context.getSecuritySource();
}
/**
* Gets a {@code HistoricalTimeSeriesSource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static HistoricalTimeSeriesSource getHistoricalTimeSeriesSource(
final FunctionExecutionContext context) {
return (HistoricalTimeSeriesSource) context.get(HISTORICAL_TIME_SERIES_SOURCE_NAME);
}
public static OverrideOperationCompiler getOverrideOperationCompiler(
final FunctionExecutionContext context) {
return (OverrideOperationCompiler) context.get(OVERRIDE_OPERATION_COMPILER_NAME);
}
/**
* Gets a {@code ConfigSource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static ConfigSource getConfigSource(final FunctionExecutionContext context) {
return (ConfigSource) context.get(CONFIG_SOURCE_NAME);
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = snapshotClock.zonedDateTime();
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final InstrumentDefinition<InstrumentDerivative> definition =
(InstrumentDefinition<InstrumentDerivative>) security.accept(VISITOR);
final Currency putCurrency = security.accept(ForexVisitors.getPutCurrencyVisitor());
final Currency callCurrency = security.accept(ForexVisitors.getCallCurrencyVisitor());
final ValueRequirement desiredValue = desiredValues.iterator().next();
final String putCurveName = desiredValue.getConstraint(PROPERTY_PUT_CURVE);
final String callCurveName = desiredValue.getConstraint(PROPERTY_CALL_CURVE);
final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
final String putForwardCurveName = desiredValue.getConstraint(PROPERTY_PUT_FORWARD_CURVE);
final String callForwardCurveName = desiredValue.getConstraint(PROPERTY_CALL_FORWARD_CURVE);
final String putCurveCalculationMethod =
desiredValue.getConstraint(PROPERTY_PUT_CURVE_CALCULATION_METHOD);
final String callCurveCalculationMethod =
desiredValue.getConstraint(PROPERTY_CALL_CURVE_CALCULATION_METHOD);
final String interpolatorName =
desiredValue.getConstraint(InterpolatedDataProperties.X_INTERPOLATOR_NAME);
final String leftExtrapolatorName =
desiredValue.getConstraint(InterpolatedDataProperties.LEFT_X_EXTRAPOLATOR_NAME);
final String rightExtrapolatorName =
desiredValue.getConstraint(InterpolatedDataProperties.RIGHT_X_EXTRAPOLATOR_NAME);
final String spread = desiredValue.getConstraint(PROPERTY_CALL_SPREAD_VALUE);
final double spreadValue = Double.parseDouble(spread);
final String fullPutCurveName = putCurveName + "_" + putCurrency.getCode();
final String fullCallCurveName = callCurveName + "_" + callCurrency.getCode();
final String[] curveNames;
if (FXUtils.isInBaseQuoteOrder(
putCurrency, callCurrency)) { // To get Base/quote in market standard order.
curveNames = new String[] {fullPutCurveName, fullCallCurveName};
} else {
curveNames = new String[] {fullCallCurveName, fullPutCurveName};
}
final YieldAndDiscountCurve putFundingCurve = getCurve(inputs, putCurrency, putCurveName);
final YieldAndDiscountCurve callFundingCurve = getCurve(inputs, callCurrency, callCurveName);
final YieldAndDiscountCurve[] curves;
final Map<String, Currency> curveCurrency = new HashMap<String, Currency>();
curveCurrency.put(fullPutCurveName, putCurrency);
curveCurrency.put(fullCallCurveName, callCurrency);
final String[] allCurveNames;
final Currency ccy1;
final Currency ccy2;
if (FXUtils.isInBaseQuoteOrder(
putCurrency, callCurrency)) { // To get Base/quote in market standard order.
ccy1 = putCurrency;
ccy2 = callCurrency;
curves = new YieldAndDiscountCurve[] {putFundingCurve, callFundingCurve};
allCurveNames = new String[] {fullPutCurveName, fullCallCurveName};
} else {
curves = new YieldAndDiscountCurve[] {callFundingCurve, putFundingCurve};
allCurveNames = new String[] {fullCallCurveName, fullPutCurveName};
ccy1 = callCurrency;
ccy2 = putCurrency;
}
final InstrumentDerivative fxOption = definition.toDerivative(now, curveNames);
final YieldCurveBundle yieldCurves = new YieldCurveBundle(allCurveNames, curves);
final Object spotObject = inputs.getValue(ValueRequirementNames.SPOT_RATE);
if (spotObject == null) {
throw new OpenGammaRuntimeException("Could not get spot rate");
}
final double spot = (Double) spotObject;
final ValueRequirement fxVolatilitySurfaceRequirement =
getSurfaceRequirement(
surfaceName,
putCurrency,
callCurrency,
interpolatorName,
leftExtrapolatorName,
rightExtrapolatorName);
final Object volatilitySurfaceObject = inputs.getValue(fxVolatilitySurfaceRequirement);
if (volatilitySurfaceObject == null) {
throw new OpenGammaRuntimeException("Could not get " + fxVolatilitySurfaceRequirement);
}
final SmileDeltaTermStructureParametersStrikeInterpolation smiles =
(SmileDeltaTermStructureParametersStrikeInterpolation) volatilitySurfaceObject;
final FXMatrix fxMatrix = new FXMatrix(ccy1, ccy2, spot);
final ValueProperties.Builder properties =
getResultProperties(
putCurveName,
putForwardCurveName,
putCurveCalculationMethod,
callCurveName,
callForwardCurveName,
callCurveCalculationMethod,
surfaceName,
spread,
interpolatorName,
leftExtrapolatorName,
rightExtrapolatorName,
target);
final ValueSpecification spec =
new ValueSpecification(_valueRequirementName, target.toSpecification(), properties.get());
final YieldCurveBundle curvesWithFX =
new YieldCurveBundle(fxMatrix, curveCurrency, yieldCurves.getCurvesMap());
final SmileDeltaTermStructureDataBundle smileBundle =
new SmileDeltaTermStructureDataBundle(curvesWithFX, smiles, Pair.of(ccy1, ccy2));
return getResult(fxOption, spreadValue, smileBundle, spec);
}
/**
* Gets a {@code CurveCalculationConfigSource} from the context.
*
* @param context the context to examine, not null
* @return the curve config source, null if not found
*/
public static CurveCalculationConfigSource getCurveCalculationConfigSource(
final FunctionExecutionContext context) {
return (CurveCalculationConfigSource) context.get(CURVE_CALCULATION_CONFIG_NAME);
}
/**
* Stores a {@code CurveCalculationConfigSource} in the context.
*
* @param context the context to store in, not null
* @param curveConfigSource the curve config source to store, not null
*/
public static void setCurveCalculationConfigSource(
final FunctionExecutionContext context,
final CurveCalculationConfigSource curveConfigSource) {
context.put(CURVE_CALCULATION_CONFIG_NAME, curveConfigSource);
}
/**
* Stores a {@code ConventionBundleSource} in the context.
*
* @param context the context to store in, not null
* @param conventionBundleSource the value to store, not null
*/
public static void setConventionBundleSource(
final FunctionExecutionContext context, final ConventionBundleSource conventionBundleSource) {
context.put(CONVENTION_BUNDLE_SOURCE_NAME, conventionBundleSource);
}
/**
* Stores a {@code ConfigSource} in the context.
*
* @param context the context to store in, not null
* @param configSource the value to store, not null
*/
public static void setConfigSource(
final FunctionExecutionContext context, final ConfigSource configSource) {
context.put(CONFIG_SOURCE_NAME, configSource);
}
/**
* Gets a {@code RegionSource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static RegionSource getRegionSource(final FunctionExecutionContext context) {
return (RegionSource) context.get(REGION_SOURCE_NAME);
}
public static void setOverrideOperationCompiler(
final FunctionExecutionContext context,
final OverrideOperationCompiler overrideOperationCompiler) {
context.put(OVERRIDE_OPERATION_COMPILER_NAME, overrideOperationCompiler);
}
/**
* Stores a {@code RegionSource} in the context.
*
* @param context the context to store in, not null
* @param regionSource the value to store, not null
*/
public static void setRegionSource(
final FunctionExecutionContext context, final RegionSource regionSource) {
context.put(REGION_SOURCE_NAME, regionSource);
}
/**
* Stores a {@code HistoricalTimeSeriesSource} in the context.
*
* @param context the context to store in, not null
* @param source the value to store, not null
*/
public static void setHistoricalTimeSeriesSource(
final FunctionExecutionContext context, final HistoricalTimeSeriesSource source) {
context.put(HISTORICAL_TIME_SERIES_SOURCE_NAME, source);
}
/**
* Gets a {@code HolidaySource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static HolidaySource getHolidaySource(final FunctionExecutionContext context) {
return (HolidaySource) context.get(HOLIDAY_SOURCE_NAME);
}
/**
* Stores a {@code SecuritySource} in the context.
*
* @param context the context to store in, not null
* @param securitySource the value to store, not null
*/
public static void setSecuritySource(
final FunctionExecutionContext context, final SecuritySource securitySource) {
context.setSecuritySource(securitySource);
}
/**
* Stores a {@code HolidaySource} in the context.
*
* @param context the context to store in, not null
* @param holidaySource the value to store, not null
*/
public static void setHolidaySource(
final FunctionExecutionContext context, final HolidaySource holidaySource) {
context.put(HOLIDAY_SOURCE_NAME, holidaySource);
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues)
throws AsynchronousExecution {
final ZonedDateTime now = ZonedDateTime.now(executionContext.getValuationClock());
final ValueRequirement requirement = desiredValues.iterator().next();
final ValueProperties properties = requirement.getConstraints().copy().get();
final LegacyVanillaCDSSecurity security = (LegacyVanillaCDSSecurity) target.getSecurity();
// LegacyVanillaCreditDefaultSwapDefinition cds =
// _converter.visitLegacyVanillaCDSSecurity(security);
final ValueRequirement desiredValue = desiredValues.iterator().next(); // all same constraints
final String quoteConventionString =
desiredValue.getConstraint(ISDAFunctionConstants.CDS_QUOTE_CONVENTION);
final StandardCDSQuotingConvention quoteConvention =
StandardCDSQuotingConvention.parse(quoteConventionString);
final CdsRecoveryRateIdentifier recoveryRateIdentifier =
security.accept(
new CreditSecurityToRecoveryRateVisitor(executionContext.getSecuritySource()));
Object recoveryRateObject =
inputs.getValue(
new ValueRequirement(
"PX_LAST",
ComputationTargetType.PRIMITIVE,
recoveryRateIdentifier.getExternalId()));
if (recoveryRateObject == null) {
throw new OpenGammaRuntimeException("Could not get recovery rate");
// s_logger.warn("Could not get recovery rate, defaulting to 0.4: " + recoveryRateIdentifier);
// recoveryRateObject = 0.4;
}
final double recoveryRate = (Double) recoveryRateObject;
// get the isda curve
final Object isdaObject = inputs.getValue(ValueRequirementNames.YIELD_CURVE);
if (isdaObject == null) {
throw new OpenGammaRuntimeException("Couldn't get isda curve");
}
final ISDACompliantYieldCurve yieldCurve = (ISDACompliantYieldCurve) isdaObject;
// spreads
NodalTenorDoubleCurve spreadObject =
(NodalTenorDoubleCurve) inputs.getValue(ValueRequirementNames.BUCKETED_SPREADS);
if (spreadObject == null) {
throw new OpenGammaRuntimeException("Unable to get spreads");
}
final double[] spreads = ArrayUtils.toPrimitive(spreadObject.getYData());
// final String pillarString = IMMDateGenerator.isIMMDate(security.getMaturityDate()) ?
// requirement.getConstraint(ISDAFunctionConstants.ISDA_BUCKET_TENORS) :
// ISDACompliantCreditCurveFunction.NON_IMM_PILLAR_TENORS;
final ZonedDateTime[] bucketDates =
SpreadCurveFunctions.getPillarDates(now, spreadObject.getXData());
final CDSQuoteConvention[] quotes =
SpreadCurveFunctions.getQuotes(
security.getMaturityDate(), spreads, security.getParSpread(), quoteConvention, false);
// spreads
NodalTenorDoubleCurve pillarObject =
(NodalTenorDoubleCurve) inputs.getValue(ValueRequirementNames.PILLAR_SPREADS);
if (pillarObject == null) {
throw new OpenGammaRuntimeException("Unable to get pillars");
}
// CDS analytics for credit curve (possible performance improvement if earlier result obtained)
// final LegacyVanillaCreditDefaultSwapDefinition curveCDS = cds.withStartDate(now);
// security.setStartDate(now); // needed for curve instruments
final CDSAnalytic[] bucketCDSs = new CDSAnalytic[bucketDates.length];
for (int i = 0; i < bucketCDSs.length; i++) {
// security.setMaturityDate(bucketDates[i]);
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(
now.toLocalDate(),
_holidaySource,
_regionSource,
security.getStartDate().toLocalDate(),
bucketDates[i].toLocalDate(),
recoveryRate);
bucketCDSs[i] = security.accept(visitor);
}
final ZonedDateTime[] pillarDates =
SpreadCurveFunctions.getPillarDates(now, pillarObject.getXData());
final CDSAnalytic[] pillarCDSs = new CDSAnalytic[pillarDates.length];
for (int i = 0; i < pillarCDSs.length; i++) {
// security.setMaturityDate(bucketDates[i]);
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(
now.toLocalDate(),
_holidaySource,
_regionSource,
security.getStartDate().toLocalDate(),
pillarDates[i].toLocalDate(),
recoveryRate);
pillarCDSs[i] = security.accept(visitor);
}
final ISDACompliantCreditCurve creditCurve =
(ISDACompliantCreditCurve) inputs.getValue(ValueRequirementNames.HAZARD_RATE_CURVE);
if (creditCurve == null) {
throw new OpenGammaRuntimeException("Couldnt get credit curve");
}
// final CDSAnalytic analytic = CDSAnalyticConverter.create(cds, now.toLocalDate());
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(now.toLocalDate(), _holidaySource, _regionSource, recoveryRate);
final CDSAnalytic analytic = security.accept(visitor);
final BuySellProtection buySellProtection =
security.isBuy() ? BuySellProtection.BUY : BuySellProtection.SELL;
// final String term = new Tenor(Period.between(security.getStartDate().toLocalDate(),
// security.getMaturityDate().toLocalDate())).getPeriod().toString();
// final Double cdsQuoteDouble = (Double) inputs.getValue(new
// ValueRequirement(MarketDataRequirementNames.MARKET_VALUE,
// ComputationTargetType.PRIMITIVE, ExternalId.of("Tenor", term)));
final Double cdsQuoteDouble = (Double) inputs.getValue(MarketDataRequirementNames.MARKET_VALUE);
if (cdsQuoteDouble == null) {
throw new OpenGammaRuntimeException("Couldn't get spread for " + security);
}
final CDSQuoteConvention quote =
SpreadCurveFunctions.getQuotes(
security.getMaturityDate(),
new double[] {cdsQuoteDouble},
security.getParSpread(),
quoteConvention,
true)[0];
boolean isNonIMMFAndFromPUF =
!IMMDateLogic.isIMMDate(security.getMaturityDate().toLocalDate())
&& quote instanceof PointsUpFront;
boolean isNonIMMAndFromSpread =
!IMMDateLogic.isIMMDate(security.getMaturityDate().toLocalDate())
&& (quote instanceof QuotedSpread || quote instanceof ParSpread);
int buySellPremiumFactor = security.isBuy() ? -1 : 1;
final double notional = security.getNotional().getAmount();
final double coupon = security.getParSpread() * ONE_BPS;
final PointsUpFront puf =
getPointsUpfront(quote, buySellProtection, yieldCurve, analytic, creditCurve);
final double accruedPremiumPrim =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 : analytic.getAccruedPremium(coupon);
// final double accruedPremium = isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 :
// analytic.getAccruedPremium(coupon) * notional * buySellPremiumFactor;
final double accruedPremium =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF
? 0
: accruedPremiumPrim * notional * buySellPremiumFactor;
final int accruedDays =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 : analytic.getAccuredDays();
final double quotedSpread =
getQuotedSpread(quote, puf, buySellProtection, yieldCurve, analytic).getQuotedSpread();
final double upfrontAmount =
isNonIMMAndFromSpread
? 0
: getUpfrontAmount(analytic, puf, notional, accruedPremiumPrim, buySellProtection);
final double cleanPV = puf.getPointsUpFront() * notional;
final double principal = isNonIMMAndFromSpread ? 0 : cleanPV;
final double cleanPrice = getCleanPrice(puf);
final TenorLabelledMatrix1D bucketedCS01 =
getBucketedCS01(
analytic,
bucketCDSs,
spreadObject.getXData(),
quote,
notional,
yieldCurve,
creditCurve);
final double parallelCS01 =
getParallelCS01(
quote,
analytic,
yieldCurve,
notional,
pillarCDSs,
ArrayUtils.toPrimitive(pillarObject.getYData()));
final Set<ComputedValue> results = Sets.newHashSetWithExpectedSize(_valueRequirements.length);
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.ACCRUED_PREMIUM, target.toSpecification(), properties),
accruedPremium));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.ACCRUED_DAYS, target.toSpecification(), properties),
accruedDays));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.QUOTED_SPREAD, target.toSpecification(), properties),
quotedSpread / ONE_BPS));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.UPFRONT_AMOUNT, target.toSpecification(), properties),
upfrontAmount));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.DIRTY_PRESENT_VALUE, target.toSpecification(), properties),
upfrontAmount));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.CLEAN_PRESENT_VALUE, target.toSpecification(), properties),
cleanPV));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.PRINCIPAL, target.toSpecification(), properties),
principal));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.CLEAN_PRICE, target.toSpecification(), properties),
cleanPrice));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.BUCKETED_CS01, target.toSpecification(), properties),
bucketedCS01));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.PARALLEL_CS01, target.toSpecification(), properties),
parallelCS01));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.POINTS_UPFRONT, target.toSpecification(), properties),
puf.getPointsUpFront()));
return results;
}
/**
* Gets a {@code ExchangeSource} from the context.
*
* @param context the context to examine, not null
* @return the value, null if not found
*/
public static ExchangeSource getExchangeSource(final FunctionExecutionContext context) {
return (ExchangeSource) context.get(EXCHANGE_SOURCE_NAME);
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Clock snapshotClock = executionContext.getValuationClock();
final ZonedDateTime now = ZonedDateTime.now(snapshotClock);
final SecuritySource securitySource =
OpenGammaExecutionContext.getSecuritySource(executionContext);
final SwaptionSecurity security = (SwaptionSecurity) target.getSecurity();
final ValueRequirement desiredValue = desiredValues.iterator().next();
final Currency currency = FinancialSecurityUtils.getCurrency(security);
final String surfaceName = desiredValue.getConstraint(ValuePropertyNames.SURFACE);
final String curveCalculationConfigName =
desiredValue.getConstraint(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
final ConfigSource configSource = OpenGammaExecutionContext.getConfigSource(executionContext);
final ConfigDBCurveCalculationConfigSource curveCalculationConfigSource =
new ConfigDBCurveCalculationConfigSource(configSource);
final MultiCurveCalculationConfig curveCalculationConfig =
curveCalculationConfigSource.getConfig(curveCalculationConfigName);
if (curveCalculationConfig == null) {
throw new OpenGammaRuntimeException(
"Could not find curve calculation configuration named " + curveCalculationConfigName);
}
String[] curveNames = curveCalculationConfig.getYieldCurveNames(); // TODO
if (curveNames.length == 1) {
curveNames = new String[] {curveNames[0], curveNames[0]};
}
final String[] fullCurveNames = new String[curveNames.length];
for (int i = 0; i < curveNames.length; i++) {
fullCurveNames[i] = curveNames[i] + "_" + currency.getCode();
}
final YieldCurveBundle curves =
YieldCurveFunctionUtils.getYieldCurves(inputs, curveCalculationConfig);
final Object volatilitySurfaceObject =
inputs.getValue(getVolatilityRequirement(surfaceName, currency));
if (volatilitySurfaceObject == null) {
throw new OpenGammaRuntimeException("Could not get volatility surface");
}
final VolatilitySurface volatilitySurface = (VolatilitySurface) volatilitySurfaceObject;
if (!(volatilitySurface.getSurface() instanceof InterpolatedDoublesSurface)) {
throw new OpenGammaRuntimeException(
"Expecting an InterpolatedDoublesSurface; got "
+ volatilitySurface.getSurface().getClass());
}
final InstrumentDefinition<?> definition = security.accept(_visitor);
final HistoricalTimeSeriesBundle timeSeries =
HistoricalTimeSeriesFunctionUtils.getHistoricalTimeSeriesInputs(executionContext, inputs);
final InstrumentDerivative swaption =
_definitionConverter.convert(security, definition, now, fullCurveNames, timeSeries);
final ValueProperties properties =
getResultProperties(currency.getCode(), curveCalculationConfigName, surfaceName);
final ValueSpecification spec =
new ValueSpecification(_valueRequirementName, target.toSpecification(), properties);
final BlackFlatSwaptionParameters parameters =
new BlackFlatSwaptionParameters(
volatilitySurface.getSurface(),
SwaptionUtils.getSwapGenerator(security, definition, securitySource));
final YieldCurveWithBlackSwaptionBundle data =
new YieldCurveWithBlackSwaptionBundle(parameters, curves);
return getResult(swaption, data, spec);
}
/**
* Stores a {@code ExchangeSource} in the context.
*
* @param context the context to store in, not null
* @param exchangeSource the value to store, not null
*/
public static void setExchangeSource(
final FunctionExecutionContext context, final ExchangeSource exchangeSource) {
context.put(EXCHANGE_SOURCE_NAME, exchangeSource);
}
