/**
* Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.integration.tool.config;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.threeten.bp.ZonedDateTime;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.opengamma.OpenGammaRuntimeException;
import com.opengamma.analytics.util.time.TimeCalculator;
import com.opengamma.bbg.BloombergConstants;
import com.opengamma.bbg.referencedata.ReferenceDataProvider;
import com.opengamma.bbg.util.BloombergDataUtils;
import com.opengamma.bbg.util.BloombergTickerParserBondFutureOption;
import com.opengamma.bbg.util.BloombergTickerParserCommodityFutureOption;
import com.opengamma.bbg.util.BloombergTickerParserEQVanillaOption;
import com.opengamma.bbg.util.BloombergTickerParserFutureOption;
import com.opengamma.bbg.util.BloombergTickerParserIRFutureOption;
import com.opengamma.component.tool.AbstractTool;
import com.opengamma.core.config.impl.ConfigItem;
import com.opengamma.core.id.ExternalSchemes;
import com.opengamma.core.value.MarketDataRequirementNames;
import com.opengamma.financial.analytics.model.InstrumentTypeProperties;
import com.opengamma.financial.analytics.volatility.surface.BloombergBondFuturePriceCurveInstrumentProvider;
import com.opengamma.financial.analytics.volatility.surface.BloombergCommodityFuturePriceCurveInstrumentProvider;
import com.opengamma.financial.analytics.volatility.surface.BloombergEquityFuturePriceCurveInstrumentProvider;
import com.opengamma.financial.analytics.volatility.surface.BloombergIRFuturePriceCurveInstrumentProvider;
import com.opengamma.financial.analytics.volatility.surface.FuturePriceCurveDefinition;
import com.opengamma.financial.analytics.volatility.surface.FuturePriceCurveInstrumentProvider;
import com.opengamma.financial.analytics.volatility.surface.FuturePriceCurveSpecification;
import com.opengamma.financial.analytics.volatility.surface.VolatilitySurfaceDefinition;
import com.opengamma.financial.security.FinancialSecurity;
import com.opengamma.financial.security.FinancialSecurityVisitorAdapter;
import com.opengamma.financial.security.bond.GovernmentBondSecurity;
import com.opengamma.financial.security.equity.EquitySecurity;
import com.opengamma.financial.security.future.AgricultureFutureSecurity;
import com.opengamma.financial.security.future.BondFutureSecurity;
import com.opengamma.financial.security.future.EnergyFutureSecurity;
import com.opengamma.financial.security.future.EquityFutureSecurity;
import com.opengamma.financial.security.future.InterestRateFutureSecurity;
import com.opengamma.financial.security.future.MetalFutureSecurity;
import com.opengamma.financial.security.option.BondFutureOptionSecurity;
import com.opengamma.financial.security.option.CommodityFutureOptionSecurity;
import com.opengamma.financial.security.option.EquityIndexOptionSecurity;
import com.opengamma.financial.security.option.EquityOptionSecurity;
import com.opengamma.financial.security.option.FXBarrierOptionSecurity;
import com.opengamma.financial.security.option.FXDigitalOptionSecurity;
import com.opengamma.financial.security.option.FXOptionSecurity;
import com.opengamma.financial.security.option.IRFutureOptionSecurity;
import com.opengamma.financial.security.option.NonDeliverableFXDigitalOptionSecurity;
import com.opengamma.financial.security.option.NonDeliverableFXOptionSecurity;
import com.opengamma.financial.security.option.SwaptionSecurity;
import com.opengamma.financial.security.swap.SwapSecurity;
import com.opengamma.financial.tool.ToolContext;
import com.opengamma.id.ExternalId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.UniqueIdentifiable;
import com.opengamma.integration.tool.IntegrationToolContext;
import com.opengamma.scripts.Scriptable;
import com.opengamma.util.tuple.ObjectsPair;
import com.opengamma.master.config.ConfigDocument;
import com.opengamma.master.config.ConfigMaster;
import com.opengamma.master.config.ConfigMasterUtils;
import com.opengamma.master.config.ConfigSearchRequest;
import com.opengamma.master.config.impl.ConfigSearchIterator;
import com.opengamma.master.security.SecurityDocument;
import com.opengamma.master.security.SecurityMaster;
import com.opengamma.master.security.SecuritySearchRequest;
import com.opengamma.master.security.SecuritySearchSortOrder;
import com.opengamma.master.security.impl.SecuritySearchIterator;
import com.opengamma.util.OpenGammaClock;
/**
* Create future price curve based on the instruments in security master.
*/
@Scriptable
public class FuturePriceCurveCreator extends AbstractTool<IntegrationToolContext> {
/** the logger */
static Logger s_logger = LoggerFactory.getLogger(FuturePriceCurveCreator.class);
/** bbg surface prefix */
private static final String BBG_PREFIX = "BBG_";
/** for ir bonds when using price */
private static final String PRICE = "PRICE_";
/** when getting price instead of vol */
private static final String FIELD_NAME_PRICE = MarketDataRequirementNames.MARKET_VALUE;
/** wildcard search symbol */
private static final String WILDCARD_SEARCH = "*";
//Track surfaces we create so we dont recreate them when multiple securities need them
/** vol definitions we have created */
private final Set<String> _curveDefinitionNames = new HashSet<>();
/** vol specifications we have created */
private final Set<String> _curveSpecificationNames = new HashSet<>();
/** regexp to get strike from option ticker */
private static final String STRIKE_REGEXP = "[CP][ ]*((\\d)+(.\\d+)*)\\b";
/**
* Main method to run the tool.
*
* @param args command line arguments
*/
public static void main(String[] args) { // CSIGNORE
new FuturePriceCurveCreator().initAndRun(args, IntegrationToolContext.class);
System.exit(0);
}
//-------------------------------------------------------------------------
@Override
protected void doRun() {
ToolContext toolContext = getToolContext();
ConfigMaster configMaster = toolContext.getConfigMaster();
CommandLine commandLine = getCommandLine();
final String name = commandLine.getOptionValue("name", WILDCARD_SEARCH);
final boolean dryRun = commandLine.hasOption("do-not-persist");
final boolean skipExisting = commandLine.hasOption("skip");
// if skipping existing surfaces get the list now
if (skipExisting) {
ConfigSearchRequest<FuturePriceCurveDefinition<?>> curveDefinitionSearchRequest = new ConfigSearchRequest<>();
curveDefinitionSearchRequest.setType(VolatilitySurfaceDefinition.class);
// can't use name to restrict search as ticker symbol may not be same as underlying symbol (e.g. RUT vs RUY)
curveDefinitionSearchRequest.setName(WILDCARD_SEARCH);
for (ConfigDocument doc : ConfigSearchIterator.iterable(configMaster, curveDefinitionSearchRequest)) {
_curveDefinitionNames.add(doc.getName());
}
ConfigSearchRequest<FuturePriceCurveSpecification> curveSpecSearchRequest = new ConfigSearchRequest<>();
curveSpecSearchRequest.setType(FuturePriceCurveSpecification.class);
// can't use name to restrict search as ticker symbol may not be same as underlying symbol (e.g. RUT vs RUY)
curveSpecSearchRequest.setName(WILDCARD_SEARCH);
for (ConfigDocument doc : ConfigSearchIterator.iterable(configMaster, curveSpecSearchRequest)) {
_curveSpecificationNames.add(doc.getName());
}
}
createSurfaces(name, dryRun);
}
/**
* Create surfaces for all (non-expired) securities
*
* @param name the pattern to match securities
* @param dryRun set to true to not write to the database
*/
private void createSurfaces(String name, boolean dryRun) {
ConfigMaster configMaster = getToolContext().getConfigMaster();
SecurityMaster securityMaster = getToolContext().getSecurityMaster();
ReferenceDataProvider bbgRefData = getToolContext().getBloombergReferenceDataProvider();
SecuritySearchRequest securityRequest = new SecuritySearchRequest();
securityRequest.setName(name);
securityRequest.setSortOrder(SecuritySearchSortOrder.NAME_ASC);
for (SecurityDocument doc : SecuritySearchIterator.iterable(securityMaster, securityRequest)) {
FinancialSecurity security = (FinancialSecurity) doc.getSecurity();
try {
security.accept(new FuturePriceCurveCreatorVisitor(configMaster, bbgRefData, _curveSpecificationNames, _curveDefinitionNames, dryRun));
} catch (Exception ex) {
s_logger.error("Error processing " + security.getName() + ": " + ex.getLocalizedMessage());
continue;
}
}
}
/**
* Visitor that creates curves for the security it visits
*/
private class FuturePriceCurveCreatorVisitor extends FinancialSecurityVisitorAdapter<Object> {
/** the config master */
private final ConfigMaster _configMaster;
/** the reference data provider */
private final ReferenceDataProvider _referenceDataProvider;
/** known vol specifications */
private final Set<String> _knownCurveSpecNames;
/** known vol definitions */
private final Set<String> _knownCurveDefNames;
/** skip write to database */
private final boolean _dryRun;
/**
* @param configMaster the config master
* @param referenceDataProvider the reference data provider
* @param knownVolSpecNames curve specifications to skip
* @param knownVolDefNames curve definitions to skip
* @param dryRun if true skip write to the database
*/
FuturePriceCurveCreatorVisitor(final ConfigMaster configMaster, final ReferenceDataProvider referenceDataProvider, final Set<String> knownVolSpecNames, final Set<String> knownVolDefNames,
final boolean dryRun) {
_configMaster = configMaster;
_referenceDataProvider = referenceDataProvider;
_knownCurveSpecNames = knownVolSpecNames;
_knownCurveDefNames = knownVolDefNames;
_dryRun = dryRun;
}
@Override
public Object visitBondFutureOptionSecurity(final BondFutureOptionSecurity security) {
if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) {
return null;
}
final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER);
final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserBondFutureOption(ticker);
//final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond();
String underlyingOptChainTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName());
final String name = BBG_PREFIX + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.BOND_FUTURE_PRICE;
if (!_knownCurveSpecNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveSpecification \"{}\"", name);
final BloombergBondFuturePriceCurveInstrumentProvider curveInstrumentProvider =
new BloombergBondFuturePriceCurveInstrumentProvider(tickerParser.getSymbol(), tickerParser.getTypeName(), FIELD_NAME_PRICE);
createFuturePriceCurveSpecification(security.getCurrency(), name, curveInstrumentProvider);
}
createFuturePriceCurveDefinition(underlyingOptChainTicker, name, security.getCurrency());
return null;
}
@Override
public Object visitCommodityFutureOptionSecurity(final CommodityFutureOptionSecurity security) {
if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) {
return null;
}
final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER);
final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserCommodityFutureOption(ticker);
// final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond();
String underlyingOptChainTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName());
final String name = BBG_PREFIX + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.COMMODITY_FUTURE_PRICE;
if (!_knownCurveSpecNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveSpecification \"{}\"", name);
final BloombergCommodityFuturePriceCurveInstrumentProvider curveInstrumentProvider =
new BloombergCommodityFuturePriceCurveInstrumentProvider(tickerParser.getSymbol(), tickerParser.getTypeName(), FIELD_NAME_PRICE, ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName());
createFuturePriceCurveSpecification(security.getCurrency(), name, curveInstrumentProvider);
}
createFuturePriceCurveDefinition(underlyingOptChainTicker, name, security.getCurrency());
return null;
}
@Override
public Object visitIRFutureOptionSecurity(final IRFutureOptionSecurity security) {
if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) {
return null;
}
final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER);
final BloombergTickerParserFutureOption tickerParser = new BloombergTickerParserIRFutureOption(ticker);
// final String postfix = BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond();
String underlyingTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), tickerParser.getTypeName());
final String name = BBG_PREFIX + PRICE + tickerParser.getSymbol() + "_" + security.getCurrency().getCode() + "_" + InstrumentTypeProperties.IR_FUTURE_PRICE;
if (!_knownCurveSpecNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveSpecification \"{}\"", name);
final BloombergIRFuturePriceCurveInstrumentProvider curveInstrumentProvider = new BloombergIRFuturePriceCurveInstrumentProvider(tickerParser.getSymbol(), tickerParser.getTypeName(),
FIELD_NAME_PRICE);
createFuturePriceCurveSpecification(security.getCurrency(), name, curveInstrumentProvider);
}
createFuturePriceCurveDefinition(underlyingTicker, name, security.getCurrency());
return null;
}
@Override
public Object visitEquityIndexOptionSecurity(final EquityIndexOptionSecurity security) {
return null;
}
@Override
public Object visitEquityOptionSecurity(final EquityOptionSecurity security) {
if (TimeCalculator.getTimeBetween(ZonedDateTime.now(OpenGammaClock.getInstance()), security.getExpiry().getExpiry()) < 0) {
return null;
}
final String ticker = security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER);
final BloombergTickerParserEQVanillaOption tickerParser = new BloombergTickerParserEQVanillaOption(ticker);
String underlyingOptChainTicker = getUnderlyingTicker(ticker, security.getUnderlyingId(), "Equity");
final String name = BBG_PREFIX + tickerParser.getSymbol() + "_" + tickerParser.getExchangeCode() + "_" + InstrumentTypeProperties.EQUITY_FUTURE_PRICE;
if (!_knownCurveSpecNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveSpecification \"{}\"", name);
// use future chain to get prefix, exchange and postfix.
final Collection<ExternalId> futChain = BloombergDataUtils.getFuturechain(_referenceDataProvider, underlyingOptChainTicker);
if (futChain == null || futChain.isEmpty()) {
throw new OpenGammaRuntimeException("Can't get future chain for " + ticker);
}
final String[] tickerParts = futChain.iterator().next().getValue().split("\\s+"); // e.g. [AAPL=G3, OC, Equity]
if (tickerParts == null || tickerParts.length != 3 || tickerParts[0].length() < 3) {
throw new OpenGammaRuntimeException("Can't get prefix, exchange and postfix from " + futChain.iterator().next());
}
final String prefix = tickerParts[0].substring(0, tickerParts[0].length() - 2); // AAPL=G3 -> AAPL=
final String exchange = tickerParts[1];
final String postfix = tickerParts[2];
final BloombergEquityFuturePriceCurveInstrumentProvider curveInstrumentProvider =
new BloombergEquityFuturePriceCurveInstrumentProvider(prefix, postfix, FIELD_NAME_PRICE, exchange);
createFuturePriceCurveSpecification(UniqueId.of(ExternalSchemes.BLOOMBERG_TICKER_WEAK.getName(), underlyingOptChainTicker), name, curveInstrumentProvider);
}
createFuturePriceCurveDefinition(Lists.newArrayList(1., 2., 3., 4.), name, security.getCurrency()); // hardcoded to 4 currently
return null;
}
// ------ FX securities handled by a different tool ------
@Override
public Object visitFXOptionSecurity(final FXOptionSecurity security) {
return null;
}
@Override
public Object visitFXBarrierOptionSecurity(final FXBarrierOptionSecurity security) {
return null;
}
@Override
public Object visitFXDigitalOptionSecurity(final FXDigitalOptionSecurity security) {
return null;
}
@Override
public Object visitNonDeliverableFXOptionSecurity(final NonDeliverableFXOptionSecurity security) {
return null;
}
@Override
public Object visitNonDeliverableFXDigitalOptionSecurity(final NonDeliverableFXDigitalOptionSecurity security) {
return null;
}
// ------ Non option securities -------
@Override
public Object visitEquitySecurity(final EquitySecurity security) {
return null;
}
@Override
public Object visitEquityFutureSecurity(final EquityFutureSecurity security) {
return null;
}
@Override
public Object visitBondFutureSecurity(final BondFutureSecurity security) {
return null;
}
@Override
public Object visitInterestRateFutureSecurity(final InterestRateFutureSecurity security) {
return null;
}
@Override
public Object visitEnergyFutureSecurity(final EnergyFutureSecurity security) {
return null;
}
@Override
public Object visitMetalFutureSecurity(final MetalFutureSecurity security) {
return null;
}
@Override
public Object visitAgricultureFutureSecurity(final AgricultureFutureSecurity security) {
return null;
}
@Override
public Object visitGovernmentBondSecurity(final GovernmentBondSecurity security) {
return null;
}
@Override
public Object visitSwapSecurity(final SwapSecurity security) {
return null;
}
@Override
public Object visitSwaptionSecurity(final SwaptionSecurity security) {
return null;
}
private void createFuturePriceCurveDefinition(final String underlyingTicker, final String name, final UniqueIdentifiable target) {
if (!_knownCurveDefNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveDefinition \"{}\"", name);
final Set<ExternalId> options = BloombergDataUtils.getOptionChain(_referenceDataProvider, underlyingTicker);
final ObjectsPair<ImmutableList<Double>, ImmutableList<Double>> axes = determineAxes(options);
createFuturePriceCurveDefinition(axes.getFirst(), name, target);
}
}
private void createFuturePriceCurveDefinition(final Collection<Double> xAxis, final String name, final UniqueIdentifiable target) {
if (!_knownCurveDefNames.contains(name)) {
s_logger.info("Creating FuturePriceCurveDefinition \"{}\"", name);
final FuturePriceCurveDefinition<Double> futureCurveDefinition = new FuturePriceCurveDefinition<>(name, target, xAxis.toArray(new Double[0]));
final ConfigItem<FuturePriceCurveDefinition<Double>> futureCurveDefinitionConfig = ConfigItem.of(futureCurveDefinition, futureCurveDefinition.getName(), FuturePriceCurveDefinition.class);
if (!_dryRun) {
ConfigMasterUtils.storeByName(_configMaster, futureCurveDefinitionConfig);
}
_knownCurveDefNames.add(name);
}
}
private void createFuturePriceCurveSpecification(final UniqueIdentifiable target, final String name, final FuturePriceCurveInstrumentProvider<?> curveInstrumentProvider) {
final FuturePriceCurveSpecification priceCurveSpec = new FuturePriceCurveSpecification(name, target, curveInstrumentProvider);
final ConfigItem<FuturePriceCurveSpecification> volSpecConfig = ConfigItem.of(priceCurveSpec, priceCurveSpec.getName(), FuturePriceCurveSpecification.class);
if (!_dryRun) {
ConfigMasterUtils.storeByName(_configMaster, volSpecConfig);
}
_knownCurveSpecNames.add(name);
}
/**
* From the available options determine axes for a volatility surface.
* @param options the available options as given by OPT_CHAIN (must be tickers)
* @return x and y axes
*/
private ObjectsPair<ImmutableList<Double>, ImmutableList<Double>> determineAxes(Collection<ExternalId> options) {
Set<Double> strikes = new TreeSet<>();
Pattern strikePattern = Pattern.compile(STRIKE_REGEXP);
for (ExternalId option : options) {
String name = option.getValue();
Matcher matcher = strikePattern.matcher(name);
if (!matcher.find()) {
s_logger.error("Cant calculate strike for {}", name);
continue;
}
strikes.add(Double.valueOf(matcher.group(1)));
}
if (strikes.isEmpty()) {
throw new OpenGammaRuntimeException("Could not get any strikes");
}
// assume all strikes exist for all exercise dates
int numX = options.size() / strikes.size();
// Can get quite low numbers (OPT_CHAIN truncated?) so ensure a minimum
//TODO: Check why numbers can be so low.
if (numX < 12) {
numX = 12;
}
List<Double> xAxis = new ArrayList<>();
for (int i = 1; i < numX + 1; i++) {
xAxis.add(Double.valueOf(i));
}
return ObjectsPair.of(ImmutableList.copyOf(xAxis), ImmutableList.copyOf(strikes));
}
private String getUnderlyingTicker(final String ticker, final ExternalId underlyingId, final String postfix) {
if (underlyingId.isScheme(ExternalSchemes.BLOOMBERG_TICKER)) {
return underlyingId.getValue();
}
// underlying id is not a ticker - have to lookup
//TODO: check if there is a better buid -> ticker lookup function
String underlyingTicker = _referenceDataProvider.getReferenceData(Collections.singleton(ticker), Collections.singleton(BloombergConstants.FIELD_OPT_UNDL_TICKER))
.get(ticker)
.getString(BloombergConstants.FIELD_OPT_UNDL_TICKER) + " " + BloombergDataUtils.splitTickerAtMarketSector(ticker).getSecond();
if (!underlyingTicker.endsWith(postfix)) {
underlyingTicker = underlyingTicker + " " + postfix;
}
return underlyingTicker;
}
}
@Override
protected Options createOptions(boolean mandatoryConfig) {
Options options = super.createOptions(mandatoryConfig);
options.addOption(createSearchOption());
options.addOption(createDoNotPersistOption());
options.addOption(createSkipExistingOption());
return options;
}
@SuppressWarnings("static-access")
private Option createSearchOption() {
return OptionBuilder.isRequired(false)
.hasArgs()
.withArgName("name search string")
.withDescription("The name(s) you want to search for (globbing available) - default all")
.withLongOpt("name")
.create("n");
}
@SuppressWarnings("static-access")
private Option createDoNotPersistOption() {
return OptionBuilder.isRequired(false)
.hasArg(false)
.withDescription("Simulate writing rather than actually writing to DB")
.withLongOpt("do-not-persist")
.create("d");
}
@SuppressWarnings("static-access")
private Option createSkipExistingOption() {
return OptionBuilder.isRequired(false)
.hasArg(false)
.withDescription("Skip surfaces that already exist - do not overwrite")
.withLongOpt("skip")
.create("s");
}
@Override
protected void usage(Options options) {
HelpFormatter formatter = new HelpFormatter();
formatter.setWidth(120);
formatter.printHelp("future-price-curve-creator.sh", options, true);
}
}