NeqSim Future Infrastructure Overview

This document provides an overview of the foundational infrastructure added to NeqSim to support the future of process simulation.

Vision

The future of process simulation involves:

  1. Living Digital Twins - Models that evolve with assets from concept to decommissioning
  2. Real-Time Advisory - Predictive simulations supporting operations
  3. AI + Physics Integration - ML efficiency with thermodynamic rigor
  4. Safety Analysis - Automated what-if scenario generation
  5. Rapid Screening - Cloud-scale concept evaluation
  6. Sustainability - Emissions tracking and reporting
  7. Composable Architecture - Modular, extensible design
  8. Engineer Empowerment - High-level APIs for non-programmers

Module Overview

neqsim/process/
├── processmodel/
│   └── lifecycle/           # Living Digital Twins
│       ├── ProcessSystemState.java
│       └── ModelMetadata.java
├── advisory/                # Real-Time Advisory
│   └── PredictionResult.java
├── ml/
│   └── surrogate/          # AI + Physics Integration
│       ├── SurrogateModelRegistry.java
│       └── PhysicsConstraintValidator.java
├── safety/
│   └── scenario/           # Safety Analysis
│       └── AutomaticScenarioGenerator.java
├── sustainability/         # Emissions Tracking
│   └── EmissionsTracker.java
└── util/
    └── optimization/       # Rapid Screening
        └── BatchStudy.java

Quick Start

Lifecycle Management

// Export model state for version control
ProcessSystemState state = process.exportState();
state.setVersion("1.0.0");
state.saveToFile("model_v1.0.0.json");

// Track model lifecycle
ModelMetadata metadata = state.getMetadata();
metadata.setLifecyclePhase(LifecyclePhase.OPERATION);
metadata.recordValidation("Matched field data", "TEST-001");

Emissions Tracking

// Calculate emissions (includes Expander power generation)
EmissionsReport report = process.getEmissions();
System.out.println(report.getSummary());

// With location-specific grid factor
EmissionsReport norwayReport = process.getEmissions(0.05);

// Export to JSON for external tools
report.exportToJSON("emissions.json");
String json = report.toJson();

Safety Scenarios

// Generate what-if scenarios
AutomaticScenarioGenerator generator = new AutomaticScenarioGenerator(process);
generator.addFailureModes(FailureMode.COOLING_LOSS, FailureMode.COMPRESSOR_TRIP);

// Run all scenarios automatically
List<ScenarioRunResult> results = generator.runAllSingleFailures();

// Get execution summary
String summary = generator.summarizeResults(results);
System.out.println(summary);

// Or run manually
List<ProcessSafetyScenario> scenarios = generator.generateSingleFailures();
for (ProcessSafetyScenario scenario : scenarios) {
    ProcessSystem copy = process.copy();
    scenario.applyTo(copy);
    copy.run();
    // Analyze...
}

Batch Studies

// Run parameter study with extended parameter paths
BatchStudy study = BatchStudy.builder(process)
    .vary("compressor.outletPressure", 30.0, 80.0, 6)
    .vary("heater.outletTemperature", 50.0, 150.0, 5)
    .addObjective("power", Objective.MINIMIZE, p -> p.getTotalPower())
    .addObjective("emissions", Objective.MINIMIZE, p -> p.getTotalCO2Emissions())
    .parallelism(8)
    .build();

BatchStudyResult result = study.run();

// Export results
result.exportToCSV("results.csv");
result.exportToJSON("results.json");

// Pareto front analysis
List<CaseResult> paretoFront = result.getParetoFront("power", "emissions");

ML Integration

// Register surrogate model
SurrogateModelRegistry.getInstance()
    .register("flash-calc", myNeuralNetwork);

// Validate AI actions
PhysicsConstraintValidator validator = new PhysicsConstraintValidator(process);
ValidationResult check = validator.validate(aiProposedAction);
if (!check.isValid()) {
    System.out.println("Rejected: " + check.getRejectionReason());
}

Advisory Systems

// Create prediction result
PredictionResult prediction = new PredictionResult(Duration.ofHours(2));
prediction.addPredictedValue("pressure", new PredictedValue(50.0, 2.5, "bara"));

if (prediction.hasViolations()) {
    System.out.println(prediction.getAdvisoryRecommendation());
}

Documentation

Detailed documentation for each module:

Module Documentation
Lifecycle Management lifecycle/README.md
Sustainability sustainability/README.md
Advisory Systems advisory/README.md
ML Integration ml/README.md
Safety Scenarios safety/README.md
Batch Studies optimization/README.md

Architecture Principles

1. Backward Compatibility

All new features are additive. Existing code continues to work unchanged.

2. Progressive Enhancement

Start with simple APIs, access advanced features when needed.

3. Physics First

ML models include automatic fallback to physics calculations.

4. Safety by Design

All AI actions are validated against physical constraints.

5. Sustainability Built-In

Emissions tracking is first-class, not an afterthought.

Integration Points

External ML Platforms

Real-Time Systems

Cloud Platforms

Future Roadmap

Phase 1 ✅

Phase 2 (Current) ✅

Phase 3 (Planned)

Phase 4 (Vision)

Contributing

When extending these modules:

  1. Follow existing patterns for consistency
  2. Include comprehensive JavaDoc
  3. Add unit tests for new functionality
  4. Update documentation