Examples of com.opengamma.engine.view.ViewCalculationConfiguration

com.opengamma.engine.view.ViewCalculationConfiguration
The configuration for one set of calculations on a particular view.

    assertEquals(res2.getProperty("Currency"), "USD");
  }


  public void testTradeSpecificOverride() {
    final DependencyGraphBuilder builder = createBuilder();
    final ViewCalculationConfiguration config = builder.getCompilationContext().getViewCalculationConfiguration();
    final PositionSource positions = builder.getCompilationContext().getPortfolioStructure().getPositionSource();
    final Trade trade1 = getTrade(positions, "TradeAttr");
    config.setDefaultProperties(ValueProperties.with("TRADE.Present Value.DEFAULT_ForwardCurve", "GenericForward").with("TRADE.*.DEFAULT_FundingCurve", "GenericFunding")
        .with("TRADE.*.DEFAULT_ForwardCurve." + trade1.getUniqueId(), "BarForward").with("TRADE.Present Value.DEFAULT_FundingCurve." + trade1.getUniqueId(), "BarFunding").get());
    final ValueRequirement req1 = createValueRequirement(ComputationTargetSpecification.of(trade1), ValueProperties.none());
    final ValueRequirement req2 = createValueRequirement(ComputationTargetSpecification.of(getTrade(positions, "Trade")), ValueProperties.none());
    builder.addTarget(req1);
    builder.addTarget(req2);

View Full Code Here

      super(context);
    }


    @Override
    protected void compile(final DependencyGraphBuilder builder) {
      final ViewCalculationConfiguration config = getContext().getViewDefinition().getCalculationConfiguration(builder.getCalculationConfigurationName());
      addSpecificRequirements(builder, getContext().getViewDefinition().getResultModelDefinition(), config);
      addPortfolioRequirements(builder, getContext(), config, null, null);
    }

View Full Code Here

    }


    @SuppressWarnings("unchecked")
    @Override
    protected void compile(final DependencyGraphBuilder builder) {
      final ViewCalculationConfiguration calcConfig = getContext().getViewDefinition().getCalculationConfiguration(builder.getCalculationConfigurationName());
      final Pair<DependencyGraph, Set<ValueRequirement>> graphPair = _previousGraphs.remove(builder.getCalculationConfigurationName());
      if (graphPair != null) {
        final DependencyGraph graph = graphPair.getFirst();
        if (builder.getCompilationContext().getPortfolio() != null) {
          // Remove any invalid terminal outputs from the graph
          final PortfolioIdentifierGatherer gatherer = new PortfolioIdentifierGatherer();
          PortfolioNodeTraverser.parallel(gatherer, getContext().getServices().getExecutorService()).traverse(builder.getCompilationContext().getPortfolio().getRootNode());
          final Set<UniqueId> identifiers = gatherer.getIdentifiers();
          final Set<ValueRequirement> specifics = calcConfig.getSpecificRequirements();
          final Map<ValueSpecification, Set<ValueRequirement>> terminalOutputs = graph.getTerminalOutputs();
          ValueSpecification[] removeValueSpec = null;
          Set<ValueRequirement>[] removeValueReq = null;
          int i = 0;
          for (Map.Entry<ValueSpecification, Set<ValueRequirement>> terminal : terminalOutputs.entrySet()) {

View Full Code Here

    ValueProperties allConstraints = ValueProperties.all();
    ValueProperties noConstraints = ValueProperties.none();
    ValueProperties nearlyAllConstraints = ValueProperties.all().withoutAny("SomePropName");


    final ViewDefinition viewDefinition = new ViewDefinition(TEST_VIEW_DEFINITION_NAME, TEST_PORTFOLIO_ID, TEST_USER, new ResultModelDefinition());
    final ViewCalculationConfiguration calcConfig1 = new ViewCalculationConfiguration(viewDefinition, "1");
    calcConfig1.addSpecificRequirement(new ValueRequirement("Value1", ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Foo")));
    calcConfig1.addSpecificRequirement(new ValueRequirement("Value1", ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Bar"), constraints));
    calcConfig1.setDefaultProperties(ValueProperties.with(ValuePropertyNames.CURRENCY, "GBP").get());
    calcConfig1.addPortfolioRequirement("SomeSecType", "SomeOutput", constraints);
    calcConfig1.addPortfolioRequirement("SomeSecType", "SomeOtherOutput", allConstraints);
    calcConfig1.addPortfolioRequirement("SomeSecType", "SomeOtherOutput", allConstraints);
    calcConfig1.addPortfolioRequirement("SomeSecType", "YetAnotherOutput", noConstraints);
    calcConfig1.addPortfolioRequirement("SomeOtherSecType", "YetAnotherOutput", nearlyAllConstraints);
    calcConfig1.setScenarioId(UniqueId.of("ScenarioDefinition", "sd1"));


    final ViewCalculationConfiguration calcConfig2 = new ViewCalculationConfiguration(viewDefinition, "2");
    calcConfig2.addSpecificRequirement(new ValueRequirement("Value2", ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Foo")));
    calcConfig2.addSpecificRequirement(new ValueRequirement("Value2", ComputationTargetType.PRIMITIVE, UniqueId.of("Test", "Bar")));
    final SimpleResolutionRuleTransform transform = new SimpleResolutionRuleTransform();
    transform.suppressRule("Foo");
    calcConfig2.setResolutionRuleTransform(transform);


    viewDefinition.setDefaultCurrency(Currency.USD);
    viewDefinition.addViewCalculationConfiguration(calcConfig1);
    viewDefinition.addViewCalculationConfiguration(calcConfig2);

View Full Code Here

    _viewDefinition = viewDefinition;
  }


  private ViewDefinition generateViewDefinition() {
    final ViewDefinition testDefinition = new ViewDefinition(UniqueId.of("boo", "far"), TEST_VIEW_DEFINITION_NAME, TEST_USER);
    final ViewCalculationConfiguration calcConfig = new ViewCalculationConfiguration(testDefinition, TEST_CALC_CONFIG_NAME);
    calcConfig.addSpecificRequirement(getPrimitive1());
    calcConfig.addSpecificRequirement(getPrimitive2());
    testDefinition.addViewCalculationConfiguration(calcConfig);


    setViewDefinition(testDefinition);
    return testDefinition;
  }

View Full Code Here

    }
    
    List<FudgeField> calcConfigs = message.getAllByName(CALCULATION_CONFIGURATION_FIELD);
    for (FudgeField calcConfigField : calcConfigs) {
      FudgeMsg calcConfigMsg = message.getFieldValue(FudgeMsg.class, calcConfigField);
      final ViewCalculationConfiguration calcConfig = new ViewCalculationConfiguration(viewDefinition, message.getFieldValue(String.class, calcConfigMsg.getByName(NAME_FIELD)));
      for (FudgeField securityTypeRequirementsField : calcConfigMsg.getAllByName(PORTFOLIO_REQUIREMENTS_BY_SECURITY_TYPE_FIELD)) {
        FudgeMsg securityTypeRequirementsMsg = (FudgeMsg) securityTypeRequirementsField.getValue();
        String securityType = securityTypeRequirementsMsg.getString(SECURITY_TYPE_FIELD);
        Set<Pair<String, ValueProperties>> requirements = Sets.newLinkedHashSet();
        for (FudgeField requirement : securityTypeRequirementsMsg.getAllByName(PORTFOLIO_REQUIREMENT_FIELD)) {
          FudgeMsg reqMsg = (FudgeMsg) requirement.getValue();
          String requiredOutput = reqMsg.getString(PORTFOLIO_REQUIREMENT_REQUIRED_OUTPUT_FIELD);
          ValueProperties constraints = deserializer.fieldValueToObject(ValueProperties.class, reqMsg.getByName(PORTFOLIO_REQUIREMENT_CONSTRAINTS_FIELD));
          requirements.add(Pair.of(requiredOutput, constraints));
        }
        calcConfig.addPortfolioRequirements(securityType, requirements);
      }
      for (FudgeField specificRequirementField : calcConfigMsg.getAllByName(SPECIFIC_REQUIREMENT_FIELD)) {
        calcConfig.addSpecificRequirement(plat2286Translate(deserializer.fieldValueToObject(ValueRequirement.class, specificRequirementField)));
      }
      if (calcConfigMsg.hasField(DELTA_DEFINITION_FIELD)) {
        calcConfig.setDeltaDefinition(deserializer.fieldValueToObject(DeltaDefinition.class, calcConfigMsg.getByName(DELTA_DEFINITION_FIELD)));
      }
      if (calcConfigMsg.hasField(DEFAULT_PROPERTIES_FIELD)) {
        calcConfig.setDefaultProperties(deserializer.fieldValueToObject(ValueProperties.class,
                                                                        calcConfigMsg.getByName(DEFAULT_PROPERTIES_FIELD)));
      }
      if (calcConfigMsg.hasField(RESOLUTION_RULE_TRANSFORM_FIELD)) {
        calcConfig.setResolutionRuleTransform(deserializer.fieldValueToObject(ResolutionRuleTransform.class,
                                                                              calcConfigMsg.getByName(
                                                                                  RESOLUTION_RULE_TRANSFORM_FIELD)));
      }
      if (calcConfigMsg.hasField(SCENARIO_ID_FIELD)) {
        calcConfig.setScenarioId(deserializer.fieldValueToObject(UniqueId.class,
                                                                 calcConfigMsg.getByName(SCENARIO_ID_FIELD)));
      }
      if (calcConfigMsg.hasField(SCENARIO_PARAMETERS_ID_FIELD)) {
        calcConfig.setScenarioParametersId(deserializer.fieldValueToObject(UniqueId.class,
                                                                 calcConfigMsg.getByName(SCENARIO_PARAMETERS_ID_FIELD)));
      }
      List<ViewCalculationConfiguration.Column> columns = Lists.newArrayList();
      if (calcConfigMsg.hasField(COLUMNS_FIELD)) {
        FudgeField columnsField = calcConfigMsg.getByName(COLUMNS_FIELD);
        FudgeMsg columnsMsg = (FudgeMsg) columnsField.getValue();
        for (FudgeField field : columnsMsg.getAllFields()) {
          FudgeMsg columnMsg = (FudgeMsg) field.getValue();
          String header = deserializer.fieldValueToObject(String.class, columnMsg.getByName(HEADER_FIELD));
          String valueName = deserializer.fieldValueToObject(String.class, columnMsg.getByName(VALUE_NAME_FIELD));
          ValueProperties properties = deserializer.fieldValueToObject(ValueProperties.class, columnMsg.getByName(PORTFOLIO_REQUIREMENT_CONSTRAINTS_FIELD));
          columns.add(new ViewCalculationConfiguration.Column(header, valueName, properties));
        }
      }
      calcConfig.setColumns(columns);
      viewDefinition.addViewCalculationConfiguration(calcConfig);
    }
    FudgeField uniqueId = message.getByName("uniqueId");
    if (uniqueId != null) {
      viewDefinition.setUniqueId(deserializer.fieldValueToObject(UniqueId.class, uniqueId));

View Full Code Here

  
  public void processResult() {
    try {
      ViewDefinition viewDefinition = _compiledViewDef.getViewDefinition();
      for (final String calcConfigName : viewDefinition.getAllCalculationConfigurationNames()) {
        ViewCalculationConfiguration calcConfig = viewDefinition.getCalculationConfiguration(calcConfigName);
        final ValueMappings valueMappings = new ValueMappings(_compiledViewDef);
        final ViewCalculationResultModel calculationResult = _viewComputationResultModel.getCalculationResult(calcConfigName);
        final Map<String, Set<Pair<String, ValueProperties>>> portfolioRequirementsBySecurityType = calcConfig.getPortfolioRequirementsBySecurityType();
        Portfolio portfolio = _compiledViewDef.getPortfolio();
        PortfolioNodeTraverser traverser = new DepthFirstPortfolioNodeTraverser(new PortfolioNodeTraversalCallback() {
          
          @Override
          public void preOrderOperation(PortfolioNode parentNode, Position position) {

View Full Code Here

    functionRepository.addFunction(fn2);


    env.setFunctionRepository(functionRepository);


    final ViewDefinition vd = new ViewDefinition(UniqueId.of("test", "vd1"), "Test view", UserPrincipal.getLocalUser());
    final ViewCalculationConfiguration calcConfig = new ViewCalculationConfiguration(vd, "Default");
    calcConfig.addSpecificRequirement(requirement2);
    vd.addViewCalculationConfiguration(calcConfig);
    vd.setMinFullCalculationPeriod(Long.MAX_VALUE); // Never force a full calculation
    vd.setMaxFullCalculationPeriod(Long.MAX_VALUE); // Never force a full calculation
    env.setViewDefinition(vd);


    env.init();


    final ViewProcessorImpl vp = env.getViewProcessor();
    vp.start();


    final ViewClient client = vp.createViewClient(ViewProcessorTestEnvironment.TEST_USER);
    final TestViewResultListener resultListener = new TestViewResultListener();
    client.setResultListener(resultListener);


    client.attachToViewProcess(env.getViewDefinition().getUniqueId(), ExecutionOptions.infinite(MarketData.live(), ExecutionFlags.none().get()));


    resultListener.assertViewDefinitionCompiled(TIMEOUT);
    final ViewComputationResultModel result1 = resultListener.getCycleCompleted(TIMEOUT).getFullResult();
    assertEquals(0, resultListener.getQueueSize());


    assertEquals(1, result1.getAllResults().size());
    final ComputedValueResult result1Value = Iterables.getOnlyElement(result1.getAllResults()).getComputedValue();
    assertEquals("result2", result1Value.getValue());


    final AggregatedExecutionLog log1 = result1Value.getAggregatedExecutionLog();
    assertNotNull(log1);
    assertTrue(log1.getLogLevels().contains(LogLevel.ERROR));
    assertTrue(log1.getLogLevels().contains(LogLevel.WARN));
    assertFalse(log1.getLogLevels().contains(LogLevel.INFO));
    assertNull(log1.getLogs());


    final Pair<String, ValueSpecification> resultSpec = Pair.of(calcConfig.getName(), Iterables.getOnlyElement(client.getLatestCompiledViewDefinition().getTerminalValuesRequirements().keySet()));
    client.setMinimumLogMode(ExecutionLogMode.FULL, ImmutableSet.of(resultSpec));


    final ViewProcessImpl viewProcess = env.getViewProcess(vp, client.getUniqueId());
    final ViewProcessWorker worker = env.getCurrentWorker(viewProcess);
    worker.triggerCycle();

View Full Code Here

  }


  private CompiledViewDefinitionWithGraphs createCompiledViewDefinitionWithGraphs() {
    final Portfolio portfolio = createPortfolio();
    final ViewDefinition viewDefinition = createViewDefinition();
    final ViewCalculationConfiguration calcConfig = new ViewCalculationConfiguration(viewDefinition, "Default");
    viewDefinition.addViewCalculationConfiguration(calcConfig);
    final DependencyGraph graph = createDependencyGraph();
    final Collection<DependencyGraph> graphs = Collections.singleton(graph);
    final Map<ComputationTargetReference, UniqueId> resolutions = ImmutableMap.<ComputationTargetReference, UniqueId>of(
        new ComputationTargetRequirement(ComputationTargetType.SECURITY, ExternalId.of("Security", "Foo")), UniqueId.of("Sec", "0"));

View Full Code Here

    ViewDefinition viewDef = new ViewDefinition("Test View", UniqueId.of("Test Scheme", "Port1"), "someuser");
    viewDef.setMaxDeltaCalculationPeriod(1000L);
    viewDef.setMaxFullCalculationPeriod(60000L);
    viewDef.getResultModelDefinition().setAggregatePositionOutputMode(ResultOutputMode.TERMINAL_OUTPUTS);
    
    ViewCalculationConfiguration calcConfig = new ViewCalculationConfiguration(viewDef, "Test config");
    calcConfig.addPortfolioRequirementName("SecType", "Req1");
    calcConfig.addPortfolioRequirementName("SecType", "Req2");
    calcConfig.addPortfolioRequirementName("SecType2", "Req1");
    calcConfig.addSpecificRequirement(new ValueRequirement("Req3", ComputationTargetType.PRIMITIVE, UniqueId.of("Scheme2", "USD")));
    calcConfig.getDeltaDefinition().setNumberComparer(new NumberDeltaComparer(2));
    viewDef.addViewCalculationConfiguration(calcConfig);
    
    FudgeMsgEnvelope viewDefMsg = _fudgeContext.toFudgeMsg(viewDef);
    ViewDefinition deserializedViewDef = _fudgeContext.fromFudgeMsg(ViewDefinition.class, viewDefMsg.getMessage());

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of com.opengamma.engine.view.ViewCalculationConfiguration

com.opengamma.engine.exec.CancelExecutionTest

com.opengamma.engine.fudgemsg.ViewDefinitionFudgeBuilder

com.opengamma.engine.management.ViewProcessStatsProcessor

com.opengamma.engine.test.TestViewDefinitionProvider

com.opengamma.engine.test.ViewProcessorTestEnvironment

com.opengamma.engine.view.client.ViewClientTest

com.opengamma.engine.view.compilation.ViewDefinitionCompiler$FullCompilationTask

com.opengamma.engine.view.compilation.ViewDefinitionCompiler$IncrementalCompilationTask

com.opengamma.engine.view.compilation.ViewDefinitionCompilerTest

com.opengamma.engine.view.server.ViewDefinitionBuilderTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.