/**
* Copyright (C) 2011 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.financial.analytics.model.sensitivities;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.threeten.bp.Period;
import com.google.common.collect.Sets;
import com.opengamma.OpenGammaRuntimeException;
import com.opengamma.analytics.financial.interestrate.YieldCurveBundle;
import com.opengamma.analytics.financial.model.interestrate.curve.YieldAndDiscountCurve;
import com.opengamma.analytics.math.matrix.DoubleMatrix1D;
import com.opengamma.core.security.Security;
import com.opengamma.core.security.SecuritySource;
import com.opengamma.engine.ComputationTarget;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.function.AbstractFunction;
import com.opengamma.engine.function.FunctionCompilationContext;
import com.opengamma.engine.function.FunctionExecutionContext;
import com.opengamma.engine.function.FunctionInputs;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.engine.value.ComputedValue;
import com.opengamma.engine.value.ValueProperties;
import com.opengamma.engine.value.ValuePropertyNames;
import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.engine.value.ValueRequirementNames;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.financial.OpenGammaCompilationContext;
import com.opengamma.financial.analytics.ircurve.FixedIncomeStripWithSecurity;
import com.opengamma.financial.analytics.ircurve.InterpolatedYieldCurveSpecificationWithSecurities;
import com.opengamma.financial.analytics.model.YieldCurveNodeSensitivitiesHelper;
import com.opengamma.financial.analytics.timeseries.DateConstraint;
import com.opengamma.financial.analytics.timeseries.HistoricalTimeSeriesFunctionUtils;
import com.opengamma.financial.security.FinancialSecurityUtils;
import com.opengamma.financial.sensitivities.FactorExposureData;
import com.opengamma.financial.sensitivities.FactorType;
import com.opengamma.financial.sensitivities.RawSecurityUtils;
import com.opengamma.financial.sensitivities.SecurityEntryData;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.master.historicaltimeseries.HistoricalTimeSeriesResolutionResult;
import com.opengamma.master.historicaltimeseries.HistoricalTimeSeriesResolver;
import com.opengamma.master.historicaltimeseries.ManageableHistoricalTimeSeries;
import com.opengamma.master.security.RawSecurity;
import com.opengamma.util.money.Currency;
import com.opengamma.util.time.DateUtils;
/**
*
*/
public class ExternallyProvidedSensitivitiesYieldCurveNodeSensitivitiesFunction extends AbstractFunction.NonCompiledInvoker {
private static final Logger s_logger = LoggerFactory.getLogger(ExternallyProvidedSensitivitiesYieldCurveNodeSensitivitiesFunction.class);
/**
* The value name calculated by this function.
*/
public static final String YCNS_REQUIREMENT = ValueRequirementNames.YIELD_CURVE_NODE_SENSITIVITIES;
private static final CharSequence SWAP_TEXT = "SWAP";
private static final CharSequence BOND_TEXT = "BOND";
private HistoricalTimeSeriesResolver _htsResolver;
@Override
public void init(final FunctionCompilationContext context) {
// REVIEW: jim 24-Oct-2012 -- this is a terrible, terrible hack. Blame Andrew Griffin - he told me to do it.
_htsResolver = OpenGammaCompilationContext.getHistoricalTimeSeriesResolver(context);
}
@Override
public ComputationTargetType getTargetType() {
return ComputationTargetType.SECURITY;
}
@Override
public boolean canApplyTo(final FunctionCompilationContext context, final ComputationTarget target) {
if (!(target.getSecurity() instanceof RawSecurity)) {
return false;
}
final RawSecurity security = (RawSecurity) target.getSecurity();
return security.getSecurityType().equals(SecurityEntryData.EXTERNAL_SENSITIVITIES_SECURITY_TYPE);
}
private ValueProperties.Builder createValueProperties(final ComputationTarget target) {
final Security security = target.getSecurity();
final String currency = FinancialSecurityUtils.getCurrency(security).getCode();
final ValueProperties.Builder properties = createValueProperties();
properties.with(ValuePropertyNames.CURRENCY, currency);
properties.with(ValuePropertyNames.CURVE_CURRENCY, currency);
return properties;
}
@Override
public Set<ValueSpecification> getResults(final FunctionCompilationContext context, final ComputationTarget target) {
final ValueProperties.Builder properties = createValueProperties(target);
properties.withAny(ValuePropertyNames.CURVE);
properties.withAny(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
final Set<ValueSpecification> results = Sets.newHashSetWithExpectedSize(2);
final ComputationTargetSpecification targetSpec = target.toSpecification();
results.add(new ValueSpecification(YCNS_REQUIREMENT, targetSpec, properties.get()));
s_logger.debug("getResults(1) = " + results);
return results;
}
@Override
public Set<ValueRequirement> getRequirements(final FunctionCompilationContext context, final ComputationTarget target, final ValueRequirement desiredValue) {
final Set<String> curves = desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE);
final Set<String> curveCalcConfigs = desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if ((curves == null) || (curves.size() != 1)) {
s_logger.warn("no curve specified");
// Can't support an unbound request; an injection function must be used (or declare all as optional and use [PLAT-1771])
return null;
}
if ((curveCalcConfigs == null) || (curveCalcConfigs.size() != 1)) {
s_logger.warn("no curve config specified");
return null;
}
final String curve = curves.iterator().next();
final String curveCalcConfig = curveCalcConfigs.iterator().next();
final Set<ValueRequirement> requirements = Sets.newHashSet();
requirements.add(getCurveRequirement(target, curve, curveCalcConfig));
requirements.add(getCurveSpecRequirement(target, curve));
requirements.addAll(getSensitivityRequirements(context.getSecuritySource(), (RawSecurity) target.getSecurity()));
return requirements;
}
@Override
public Set<ValueSpecification> getResults(final FunctionCompilationContext context, final ComputationTarget target, final Map<ValueSpecification, ValueRequirement> inputs) {
String curveName = null;
String curveCalculationConfig = null;
final ComputationTargetSpecification targetSpec = target.toSpecification();
final Set<ValueSpecification> results = Sets.newHashSetWithExpectedSize(2);
for (final Map.Entry<ValueSpecification, ValueRequirement> input : inputs.entrySet()) {
if (ValueRequirementNames.YIELD_CURVE.equals(input.getKey().getValueName())) {
assert curveName == null;
assert curveCalculationConfig == null;
curveName = input.getKey().getProperty(ValuePropertyNames.CURVE);
curveCalculationConfig = input.getKey().getProperty(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
assert curveName != null;
assert curveCalculationConfig != null;
final ValueProperties.Builder properties = createValueProperties(target);
properties.with(ValuePropertyNames.CURVE, curveName);
properties.with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfig);
results.add(new ValueSpecification(YCNS_REQUIREMENT, targetSpec, properties.get()));
}
}
s_logger.debug("getResults(2) returning " + results);
return results;
}
@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;
}
private DoubleMatrix1D getSensitivities(final SecuritySource secSource, final FunctionInputs inputs, final RawSecurity rawSecurity, final InterpolatedYieldCurveSpecificationWithSecurities curveSpec,
final YieldAndDiscountCurve curve) {
final Collection<FactorExposureData> decodedSensitivities = RawSecurityUtils.decodeFactorExposureData(secSource, rawSecurity);
final double[] entries = new double[curveSpec.getStrips().size()];
int i = 0;
for (final FixedIncomeStripWithSecurity strip : curveSpec.getStrips()) {
final FactorExposureData swapExternalSensitivitiesData = searchForSwapTenorMatch(decodedSensitivities, strip);
if (swapExternalSensitivitiesData != null) {
final ComputedValue computedValue = inputs.getComputedValue(getSensitivityRequirement(swapExternalSensitivitiesData.getExposureExternalId()));
if (computedValue != null) {
final ManageableHistoricalTimeSeries mhts = (ManageableHistoricalTimeSeries) computedValue.getValue();
final Double value = mhts.getTimeSeries().getLatestValue();
entries[i] = -value; //* (qty.doubleValue() ); // we invert here because OpenGamma uses -1bp shift rather than +1. DV01 function will invert back.
} else {
s_logger.warn("Value was null when getting required input data " + swapExternalSensitivitiesData.getExposureExternalId());
entries[i] = 0d;
}
} else {
entries[i] = 0d;
}
i++;
}
// Quick hack to map in bond data.
i = 0;
for (final FixedIncomeStripWithSecurity strip : curveSpec.getStrips()) {
final FactorExposureData bondExternalSensitivitiesData = searchForBondTenorMatch(decodedSensitivities, strip);
if (bondExternalSensitivitiesData != null) {
final ComputedValue computedValue = inputs.getComputedValue(getSensitivityRequirement(bondExternalSensitivitiesData.getExposureExternalId()));
if (computedValue != null) {
final ManageableHistoricalTimeSeries mhts = (ManageableHistoricalTimeSeries) computedValue.getValue();
final Double value = mhts.getTimeSeries().getLatestValue();
entries[i] -= value; //* (qty.doubleValue() ); // we invert here because OpenGamma uses -1bp shift rather than +1. DV01 function will invert back.
} else {
s_logger.warn("Value was null when getting required input data " + bondExternalSensitivitiesData.getExposureExternalId());
}
}
i++;
}
return new DoubleMatrix1D(entries);
}
private FactorExposureData searchForSwapTenorMatch(final Collection<FactorExposureData> exposures, final FixedIncomeStripWithSecurity strip) {
for (final FactorExposureData exposure : exposures) {
if (exposure.getFactorType().equals(FactorType.YIELD) && exposure.getFactorName().contains(SWAP_TEXT)) {
if (exposure.getNode() != null && exposure.getNode().length() > 0) {
final Period nodePeriod = Period.parse("P" + exposure.getNode());
if (strip.getTenor().getPeriod().toTotalMonths() == nodePeriod.toTotalMonths()) {
return exposure;
}
}
}
}
return null;
}
private FactorExposureData searchForBondTenorMatch(final Collection<FactorExposureData> exposures, final FixedIncomeStripWithSecurity strip) {
for (final FactorExposureData exposure : exposures) {
if (exposure.getFactorType().equals(FactorType.YIELD) && exposure.getFactorName().contains(BOND_TEXT)) {
if (exposure.getNode() != null && exposure.getNode().length() > 0) {
final Period nodePeriod = Period.parse("P" + exposure.getNode());
if (strip.getTenor().getPeriod().toTotalMonths() == nodePeriod.toTotalMonths()) {
return exposure;
}
}
}
}
return null;
}
@Override
public String getShortName() {
return "ExternallyProvidedSensitivitiesYieldCurveNodeSensitivitiesFunction";
}
protected Set<ValueRequirement> getSensitivityRequirements(final SecuritySource secSource, final RawSecurity rawSecurity) {
final Set<ValueRequirement> requirements = Sets.newHashSet();
final Collection<FactorExposureData> decodedSensitivities = RawSecurityUtils.decodeFactorExposureData(secSource, rawSecurity);
for (final FactorExposureData exposureEntry : decodedSensitivities) {
requirements.add(getSensitivityRequirement(exposureEntry.getExposureExternalId()));
}
return requirements;
}
protected ValueRequirement getSensitivityRequirement(final ExternalId externalId) {
final HistoricalTimeSeriesResolutionResult resolutionResult = _htsResolver.resolve(ExternalIdBundle.of(externalId), null, null, null, "EXPOSURE", null);
final ValueRequirement htsRequirement = HistoricalTimeSeriesFunctionUtils.createHTSRequirement(resolutionResult, "EXPOSURE", DateConstraint.VALUATION_TIME, true, DateConstraint.VALUATION_TIME,
true);
return htsRequirement;
//return new ValueRequirement();
//return new ValueRequirement(/*ExternalDataRequirementNames.SENSITIVITY*/"EXPOSURE", ComputationTargetType.PRIMITIVE, UniqueId.of(externalId.getScheme().getName(), externalId.getValue()));
}
protected ValueRequirement getCurveRequirement(final ComputationTarget target, final String curveName, final String curveCalculationConfig) {
final Currency currency = FinancialSecurityUtils.getCurrency(target.getSecurity());
final ValueProperties.Builder properties = ValueProperties.with(ValuePropertyNames.CURVE, curveName);
properties.with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfig);
return new ValueRequirement(ValueRequirementNames.YIELD_CURVE, ComputationTargetSpecification.of(currency), properties.get());
}
protected ValueRequirement getCurveSpecRequirement(final ComputationTarget target, final String curveName) {
final Currency currency = FinancialSecurityUtils.getCurrency(target.getSecurity());
final ValueProperties.Builder properties = ValueProperties.builder().with(ValuePropertyNames.CURVE, curveName);
return new ValueRequirement(ValueRequirementNames.YIELD_CURVE_SPEC, ComputationTargetSpecification.of(currency), properties.get());
}
}