com.opengamma.strata.measure.security.GenericSecurityTradeCalculationFunction Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.strata.measure.security;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.opengamma.strata.basics.ReferenceData;
import com.opengamma.strata.basics.currency.Currency;
import com.opengamma.strata.calc.Measure;
import com.opengamma.strata.calc.runner.CalculationFunction;
import com.opengamma.strata.calc.runner.CalculationParameters;
import com.opengamma.strata.calc.runner.FunctionRequirements;
import com.opengamma.strata.collect.result.FailureReason;
import com.opengamma.strata.collect.result.Result;
import com.opengamma.strata.data.scenario.ScenarioArray;
import com.opengamma.strata.data.scenario.ScenarioMarketData;
import com.opengamma.strata.market.observable.QuoteId;
import com.opengamma.strata.measure.Measures;
import com.opengamma.strata.product.GenericSecurityTrade;
import com.opengamma.strata.product.Security;

/**
 * Perform calculations on a single {@code GenericSecurityTrade} for each of a set of scenarios.
 * 
 * The supported built-in measures are:
 * 

 *   {@linkplain Measures#PRESENT_VALUE Present value}
 * 
 */
public class GenericSecurityTradeCalculationFunction
    implements CalculationFunction {

  /**
   * The calculations by measure.
   */
  private static final ImmutableMap CALCULATORS =
      ImmutableMap.builder()
          .put(Measures.PRESENT_VALUE, SecurityMeasureCalculations::presentValue)
          .build();

  private static final ImmutableSet MEASURES = CALCULATORS.keySet();

  /**
   * Creates an instance.
   */
  public GenericSecurityTradeCalculationFunction() {
  }

  //-------------------------------------------------------------------------
  @Override
  public Class targetType() {
    return GenericSecurityTrade.class;
  }

  @Override
  public Set supportedMeasures() {
    return MEASURES;
  }

  @Override
  public Optional identifier(GenericSecurityTrade target) {
    return target.getInfo().getId().map(id -> id.toString());
  }

  @Override
  public Currency naturalCurrency(GenericSecurityTrade trade, ReferenceData refData) {
    return trade.getCurrency();
  }

  //-------------------------------------------------------------------------
  @Override
  public FunctionRequirements requirements(
      GenericSecurityTrade trade,
      Set measures,
      CalculationParameters parameters,
      ReferenceData refData) {

    QuoteId id = QuoteId.of(trade.getSecurityId().getStandardId());

    return FunctionRequirements.builder()
        .valueRequirements(ImmutableSet.of(id))
        .outputCurrencies(trade.getCurrency())
        .build();
  }

  //-------------------------------------------------------------------------
  @Override
  public Map> calculate(
      GenericSecurityTrade trade,
      Set measures,
      CalculationParameters parameters,
      ScenarioMarketData scenarioMarketData,
      ReferenceData refData) {

    // loop around measures, calculating all scenarios for one measure
    Map> results = new HashMap<>();
    for (Measure measure : measures) {
      results.put(measure, calculate(measure, trade, scenarioMarketData));
    }
    return results;
  }

  // calculate one measure
  private Result calculate(
      Measure measure,
      GenericSecurityTrade trade,
      ScenarioMarketData scenarioMarketData) {

    SingleMeasureCalculation calculator = CALCULATORS.get(measure);
    if (calculator == null) {
      return Result.failure(FailureReason.UNSUPPORTED, "Unsupported measure for GenericSecurityTrade: {}", measure);
    }
    return Result.of(() -> calculator.calculate(trade.getSecurity(), trade.getQuantity(), scenarioMarketData));
  }

  //-------------------------------------------------------------------------
  @FunctionalInterface
  interface SingleMeasureCalculation {
    public abstract ScenarioArray calculate(
        Security security,
        double quantity,
        ScenarioMarketData marketData);
  }

}