Simulation Workflow Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Simulation Workflow Ontology within the Kireth Research Semantic Library. A simulation workflow is a structured scientific computation process that coordinates model preparation, parameterisation, initial and boundary conditions, numerical solver execution, time integration, ensemble or scenario execution, checkpointing, data generation, postprocessing, verification, validation, uncertainty analysis and reproducibility. This ontology supports physical, particle, molecular, fluid, thermal, structural and agent-based simulation workflows, together with numerical methods, HPC execution, provenance and evidence-based acceptance.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Simulation Workflow Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Computational Scientific Workflows / Simulation Workflow"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/computational-scientific-workflows/simulation-workflow-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = SimulationWorkflow
 ENTITY_CLASS = ScientificSimulationOrchestrationFramework
 PRIMARY_CONTEXT = ComputationalScientificWorkflow
 DEFINITION = "A simulation workflow is a structured computational process that coordinates model setup, numerical execution, scenario or ensemble control, data capture, postprocessing, verification and validation."
 SYMBOLIC_FORMS = [
  "model + conditions + parameters -> simulate -> outputs",
  "state_(t+dt)=integrator(model,state_t,dt)",
  "scenario_i -> run_i -> analyse_i",
  "result = execute(SW,model,inputs,solver,environment)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for simulation setup, execution, solver coupling, time evolution, ensembles, checkpoints, output analysis, verification, validation and reproducibility."
}

SCOPE {
 INCLUDE = [
  SimulationWorkflow,
  ScientificWorkflow,
  ComputationalScientificWorkflow,
  ComputationalWorkflow,
  SimulationPipeline,
  SimulationProcess,
  SimulationRun,
  SimulationCampaign,
  ScientificSimulation,
  PhysicalSimulation,
  ParticleSimulation,
  MolecularSimulation,
  FluidSimulation,
  HeatTransferSimulation,
  StructuralSimulation,
  AgentBasedSimulation,
  MultiphysicsSimulationRelationship,
  CoupledSimulation,
  CoSimulationRelationship,
  Model,
  SimulationModel,
  MathematicalModel,
  PhysicalModel,
  AgentModel,
  GoverningEquation,
  ConstitutiveModelRelationship,
  StateEquationRelationship,
  ConservationLaw,
  Constraint,
  Geometry,
  ComputationalDomain,
  Mesh,
  Grid,
  SpatialDiscretisation,
  TemporalDiscretisation,
  MeshGeneration,
  MeshRefinement,
  AdaptiveMeshRefinementRelationship,
  BoundaryCondition,
  InitialCondition,
  SourceTerm,
  ForcingFunctionRelationship,
  Parameter,
  SimulationParameter,
  PhysicalParameter,
  NumericalParameter,
  ParameterSet,
  ParameterSweep,
  Scenario,
  SimulationScenario,
  Case,
  TestCase,
  OperatingCondition,
  ExperimentalConditionRelationship,
  EnvironmentalConditionRelationship,
  Ensemble,
  EnsembleSimulation,
  MonteCarloSimulationRelationship,
  SensitivityRun,
  CalibrationRun,
  ValidationRun,
  VerificationRun,
  BaselineRun,
  ReferenceRun,
  ReplicateRun,
  Seed,
  RandomSeed,
  SeedControl,
  StochasticSimulation,
  DeterministicSimulation,
  Time,
  SimulationTime,
  TimeStep,
  AdaptiveTimeStep,
  FinalTime,
  StartTimeRelationship,
  TimeIntegrator,
  ExplicitIntegrator,
  ImplicitIntegrator,
  EulerMethod,
  RungeKutta,
  MultistepMethodRelationship,
  SymplecticIntegratorRelationship,
  DifferentialEquationSolver,
  ODESolver,
  PDESolver,
  LinearSolver,
  NonlinearSolver,
  IterativeSolver,
  DirectSolverRelationship,
  Preconditioner,
  SolverTolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ResidualTolerance,
  MaximumIterations,
  StoppingCriterion,
  ConvergenceCriterion,
  DivergenceCriterion,
  SolverConfiguration,
  NumericalStability,
  StabilityCondition,
  CFLConditionRelationship,
  CourantNumberRelationship,
  Stiffness,
  FloatingPointPrecision,
  SinglePrecision,
  DoublePrecision,
  MixedPrecision,
  FloatingPointArithmetic,
  RoundOffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  SolverError,
  ModelFormError,
  Uncertainty,
  NumericalUncertainty,
  ParameterUncertainty,
  InputUncertainty,
  ModelFormUncertainty,
  UncertaintyQuantification,
  SensitivityAnalysis,
  LocalSensitivity,
  GlobalSensitivity,
  PerturbationAnalysis,
  ErrorAnalysis,
  NumericalVerification,
  ComputationalValidation,
  Verification,
  Validation,
  VerificationMetrics,
  ValidationMetrics,
  AcceptanceCriterion,
  PassCriterion,
  FailCriterion,
  WarningCriterion,
  Benchmark,
  RegressionTesting,
  Reproducibility,
  ReferenceSolution,
  AnalyticalSolution,
  ManufacturedSolution,
  ExperimentalData,
  ValidationData,
  BenchmarkData,
  SimulationOutput,
  SimulationData,
  FieldData,
  TimeSeriesOutput,
  ParticleTrajectoryRelationship,
  StateTrajectory,
  ScalarOutput,
  VectorOutput,
  MatrixOutput,
  TensorOutput,
  QuantityOfInterest,
  QoIRelationship,
  DerivedQuantity,
  IntegralQuantityRelationship,
  StatisticalSummary,
  Mean,
  Variance,
  Distribution,
  HistogramRelationship,
  Postprocessing,
  NumericalPostprocessing,
  DataReduction,
  Aggregation,
  Filtering,
  Interpolation,
  Resampling,
  FeatureExtractionRelationship,
  VisualisationRelationship,
  Reporting,
  ResultPackaging,
  DataPipeline,
  OutputPipeline,
  InputPipeline,
  Checkpoint,
  SimulationCheckpoint,
  StateCheckpoint,
  RestartFileRelationship,
  Restart,
  Resume,
  Recovery,
  Retry,
  RetryPolicy,
  FaultTolerance,
  Resilience,
  LongRunningSimulationRelationship,
  WorkflowTask,
  ModelSetupTask,
  MeshTask,
  SolverTask,
  TimeIntegrationTask,
  CheckpointTask,
  PostprocessingTask,
  VerificationTask,
  ValidationTask,
  ReportingTask,
  TaskDependency,
  DataDependency,
  ControlDependency,
  IterationLoop,
  TimeLoop,
  NonlinearSolveLoopRelationship,
  RefinementLoop,
  ScenarioLoop,
  EnsembleLoop,
  ParameterSweepLoop,
  WorkflowScheduler,
  TaskScheduler,
  ResourceScheduler,
  Orchestration,
  WorkflowEngine,
  SimulationEngine,
  ExecutionEngine,
  CPU,
  GPU,
  Accelerator,
  Memory,
  Storage,
  Network,
  ParallelExecution,
  DistributedExecution,
  TaskParallelism,
  DataParallelism,
  EnsembleParallelism,
  DomainDecompositionRelationship,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  ClusterComputing,
  SupercomputerMathematics,
  MPIrelationship,
  SharedMemoryRelationship,
  CollectiveCommunicationRelationship,
  LoadBalancing,
  ResourceAllocation,
  CommunicationCost,
  ComputationCost,
  Scalability,
  StrongScaling,
  WeakScaling,
  PerformanceScaling,
  Provenance,
  SimulationProvenance,
  WorkflowProvenance,
  ModelProvenance,
  DataProvenance,
  SolverProvenance,
  MeshProvenance,
  ComputationalProvenance,
  Lineage,
  AuditTrail,
  Traceability,
  RunManifest,
  ExecutionLog,
  SolverLog,
  ErrorLog,
  EnvironmentCapture,
  WorkflowVersion,
  ModelVersion,
  MeshVersion,
  SolverVersion,
  MethodVersion,
  DatasetVersion,
  LibraryVersion,
  CompilerVersion,
  ImplementationVersion,
  Configuration,
  PrecisionConfiguration,
  ToleranceConfiguration,
  ScientificWorkflowOntologyRelationship,
  NumericalWorkflow,
  ComputationalStatistics,
  NumericalLinearAlgebra,
  ComputationalOptimisation,
  AIComputationalMathematics,
  SymbolicComputation,
  ComputationalDataStructures,
  GraphAlgorithms
 ]
 EXCLUDE_AS_PRIMARY = [
  PureNumericalWorkflowWithoutSimulationModelSemantics,
  DataPipelineWithoutModelTimeEvolution,
  GeneralWorkflowWithoutSimulationExecution,
  PhysicalExperimentWithoutComputationalSimulation
 ]
 DISAMBIGUATION_RULE = "When a scientific workflow coordinates model setup, state evolution or scenario execution, solver control, output generation and validation, interpret the context as a simulation workflow."
}

CORE_CONCEPTS {
 SimulationWorkflow = "Structured orchestration of scientific simulation stages."
 SimulationModel = "Mathematical or computational model defining simulated behaviour."
 SimulationRun = "Single execution of a simulation under a declared configuration."
 SimulationScenario = "Specific set of conditions or parameters defining a simulation case."
 TimeIntegrator = "Numerical method advancing simulated state through time."
 SimulationCheckpoint = "Persisted simulation state used for restart or recovery."
 QuantityOfInterest = "Output quantity used for scientific analysis or validation."
 SimulationProvenance = "Traceable record of model, parameters, solver, environment and outputs."
}

RELATIONS {
 SimulationWorkflow --is_child_of--> ComputationalScientificWorkflow
 SimulationWorkflow --uses--> SimulationModel
 SimulationWorkflow --contains--> SimulationTasks
 SimulationScenario --configures--> SimulationRun
 SimulationRun --produces--> SimulationOutput
 TimeIntegrator --advances--> SimulationState
 DifferentialEquationSolver --solves--> GoverningEquations
 SolverTolerance --controls--> NumericalTermination
 SimulationCheckpoint --supports--> Restart
 ParameterSweep --generates--> MultipleSimulationRuns
 EnsembleSimulation --contains--> SimulationRuns
 NumericalVerification --checks--> SimulationNumerics
 ComputationalValidation --checks--> SimulationAdequacy
 SimulationProvenance --records--> ModelSolverDataAndExecutionLineage
}

OPERATORS {
 INITIALISE(model,conditions,parameters) := initial_simulation_state(model,conditions,parameters)
 ADVANCE(state,dt,solver) := numerical_time_step(state,dt,solver)
 RUN(model,scenario,solver) := execute_simulation(model,scenario,solver)
 CHECKPOINT(state) := persist_simulation_state(state)
 RESTART(checkpoint) := restore_simulation_state(checkpoint)
 QOI(output,q) := derive_quantity_of_interest(output,q)
 VERIFY(output,reference) := numerical_verification(output,reference)
 VALIDATE(output,evidence) := computational_validation(output,evidence)
}

AXIOMS {
 A1 = "A simulation workflow coordinates a model, conditions, numerical methods and execution stages."
 A2 = "Simulation state evolution depends on the declared governing model and numerical integrator."
 A3 = "Solver convergence is distinct from model validation."
 A4 = "Scenario, ensemble and parameter-sweep runs must preserve configuration identity."
 A5 = "Checkpoints must be compatible with the model and solver state required for restart."
 A6 = "Simulation outputs require postprocessing semantics before interpretation as scientific quantities."
 A7 = "Parallel execution can alter numerical reduction order without changing intended model semantics."
 A8 = "Simulation-workflow results require explicit model, solver, scenario, verification, validation and provenance semantics."
}

REASONING {
 R1_CONTEXT = identify(scientific_question,simulation_model,domain,conditions,parameters,solver,outputs_and_validation_needs)
 R2_SETUP = prepare_geometry_mesh_initial_boundary_conditions_parameters_and_forcing)
 R3_SOLVER = choose_spatial_temporal_discretisation_solver_tolerances_precision_and_time_integration)
 R4_EXECUTION = define_single_run_scenario_parameter_sweep_ensemble_or_multiphysics_execution)
 R5_RUN = execute_simulation_and_monitor_residuals_stability_convergence_and_failure_state)
 R6_CHECKPOINT = persist_state_at_declared_intervals_for_restart_and_recovery)
 R7_OUTPUT = collect_fields_time_series_events_and_quantities_of_interest)
 R8_VERIFY = assess_discretisation_solver_error_convergence_and_invariants)
 R9_VALIDATE = compare_outputs_with_independent_evidence_and_uncertainty)
 R10_PROVENANCE = record_model_parameters_mesh_solver_versions_environment_and_execution_history)
}

CONSTRAINTS {
 C1 = "A numerically converged simulation can still represent an invalid or inadequate model."
 C2 = "Large time steps can destabilise or distort time-dependent simulations."
 C3 = "Insufficient mesh or spatial resolution can hide important solution features."
 C4 = "Checkpoint files can become invalid after incompatible model or solver changes."
 C5 = "Stochastic simulations require explicit seed and replicate semantics."
 C6 = "Ensemble statistics depend on sufficient sample size and representative scenarios."
 C7 = "Parallel reductions can create small floating-point differences between runs."
 C8 = "Model-form uncertainty is not removed by tighter numerical tolerances."
 C9 = "Postprocessing choices can materially affect reported quantities of interest."
 C10 = "Successful completion does not constitute verification or validation."
}

SEMANTIC_EQUIVALENCE {
 "QuantityOfInterest" <=> "QoI"
 "OrdinaryDifferentialEquationSolver" <=> "ODESolver"
 "PartialDifferentialEquationSolver" <=> "PDESolver"
 "HighPerformanceComputing" <=> "HPC"
}

VALIDATION {
 V1 = "Simulation model and intended scientific question are documented."
 V2 = "Initial, boundary and operating conditions are documented."
 V3 = "Mesh, discretisation and time-step settings are documented."
 V4 = "Solver type, tolerances and stopping criteria are documented."
 V5 = "Simulation scenarios and parameter sets are uniquely identified."
 V6 = "Checkpoint and restart compatibility is documented where used."
 V7 = "Numerical verification is performed where accuracy matters."
 V8 = "Validation evidence and uncertainty are documented where model adequacy is claimed."
 V9 = "Quantities of interest and postprocessing methods are defined."
 V10 = "Results are reproducible under documented model, solver, environment and version metadata."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 SIMULATION_WORKFLOW_DEFINITION = 0.99
 MODEL_SETUP_REASONING = 0.99
 SOLVER_REASONING = 0.99
 ENSEMBLE_REASONING = 0.98
 CHECKPOINT_REASONING = 0.98
 VERIFICATION_REASONING = 0.99
 VALIDATION_REASONING = 0.98
 POLICY = "Reduce confidence when model assumptions, solver settings, scenario identity, postprocessing, validation evidence or provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,SimulationWorkflowReasoning,
  SimulationModelReasoning,ScenarioReasoning,
  EnsembleReasoning,TimeIntegrationReasoning,
  SolverReasoning,CheckpointingReasoning,
  ParameterSweepReasoning,UncertaintyReasoning,
  NumericalVerificationReasoning,ComputationalValidationReasoning,
  PostprocessingReasoning,HPCSimulationReasoning,
  ProvenanceReasoning,ReproducibilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "simulation workflow" -> SimulationWorkflow
  "simulation run" -> SimulationRun
  "QoI" -> QuantityOfInterest
  "ODE solver" -> ODESolver
  "PDE solver" -> PDESolver
  "HPC" -> HighPerformanceComputing
 }
}

EXECUTION_RULES {
 E1 = "If a workflow coordinates model setup, numerical simulation and output analysis, activate SimulationWorkflowOntology."
 E2 = "Define model, domain, initial conditions, boundary conditions and parameters before execution."
 E3 = "Select discretisation, solver, precision and time integration according to model requirements."
 E4 = "Assign unique identities to scenarios, ensemble members and parameter-sweep runs."
 E5 = "Monitor residuals, convergence, numerical stability and failure state during execution."
 E6 = "Use checkpoints for long-running or failure-sensitive simulations."
 E7 = "Apply numerical verification before interpreting simulation outputs as accurate."
 E8 = "Apply validation against independent evidence before claiming model adequacy."
 E9 = "Record model, scenario, solver, postprocessing and environment provenance for reproducibility."
}

RECURSION {
 ENTRY = SimulationWorkflow
 EXPAND(SimulationWorkflow) -> [
  ScientificWorkflow,ComputationalScientificWorkflow,SimulationPipeline,
  SimulationRun,SimulationCampaign,ScientificSimulation,
  PhysicalSimulation,ParticleSimulation,MolecularSimulation,
  FluidSimulation,HeatTransferSimulation,StructuralSimulation,
  AgentBasedSimulation,CoupledSimulation,SimulationModel,
  GoverningEquation,ConservationLaw,Geometry,ComputationalDomain,
  Mesh,Grid,MeshGeneration,MeshRefinement,
  BoundaryCondition,InitialCondition,SourceTerm,
  SimulationParameter,ParameterSet,ParameterSweep,
  Scenario,SimulationScenario,Ensemble,EnsembleSimulation,
  StochasticSimulation,DeterministicSimulation,SimulationTime,
  TimeStep,TimeIntegrator,EulerMethod,RungeKutta,
  DifferentialEquationSolver,ODESolver,PDESolver,
  LinearSolver,NonlinearSolver,Preconditioner,
  SolverTolerance,Residual,Convergence,NumericalStability,
  FloatingPointPrecision,RoundOffError,DiscretisationError,
  UncertaintyQuantification,SensitivityAnalysis,ErrorAnalysis,
  NumericalVerification,ComputationalValidation,VerificationMetrics,
  ValidationMetrics,Benchmark,RegressionTesting,Reproducibility,
  SimulationOutput,SimulationData,StateTrajectory,
  QuantityOfInterest,QoIRelationship,Postprocessing,
  SimulationCheckpoint,Restart,Recovery,FaultTolerance,
  WorkflowTask,TimeLoop,ScenarioLoop,EnsembleLoop,
  WorkflowScheduler,ParallelExecution,DistributedExecution,
  HighPerformanceComputing,GPUComputing,SimulationProvenance,
  WorkflowProvenance,ModelProvenance,RunManifest,EnvironmentCapture
 ]
 EXPAND(SimulationWorkflowFamilies) -> [
  ModelSetupGeometryAndConditions,
  DiscretisationSolverAndTimeIntegration,
  ScenarioParameterSweepAndEnsembleExecution,
  CheckpointRestartAndFaultRecovery,
  SimulationOutputPostprocessingAndQoIs,
  NumericalVerificationAndErrorAnalysis,
  ComputationalValidationAndUncertainty,
  ParallelExecutionProvenanceAndReproducibility
 ]
 STOP_CONDITION = "Stop when model, conditions, solver, scenarios, outputs, verification, validation and provenance are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Scientific Workflows"
 RELATED_ONTOLOGIES = [
  "Computational Scientific Workflows",
  "Scientific Workflow Ontology",
  "Data Pipeline Ontology",
  "Numerical Workflow Ontology",
  "Scientific Simulation Ontology",
  "Physical Simulation Ontology",
  "Particle Simulation Ontology",
  "Molecular Simulation Ontology",
  "Fluid Simulation Ontology",
  "Heat Transfer Simulation Ontology",
  "Structural Simulation Ontology",
  "Agent Based Simulation Ontology",
  "Verification & Validation",
  "Numerical Verification Ontology",
  "Computational Validation Ontology",
  "Error Analysis Ontology",
  "Reproducibility Ontology",
  "Differential Equation Solvers",
  "Numerical Linear Algebra Ontology 2",
  "Computational Statistics Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology"
 ]
 ROUTE_RULES = [
  "Simulation Workflow -> Computational Scientific Workflows for parent orchestration semantics",
  "Simulation Workflow -> Scientific Workflow for task and dependency semantics",
  "Simulation Workflow -> Data Pipeline for input and output data movement",
  "Simulation Workflow -> Numerical Workflow for discretisation, solver and refinement semantics",
  "Simulation Workflow -> Scientific and domain-specific Simulation ontologies for model semantics",
  "Simulation Workflow -> Verification & Validation, Numerical Verification, Computational Validation and Error Analysis for evidence and acceptance",
  "Simulation Workflow -> Reproducibility for rerun and provenance semantics",
  "Simulation Workflow -> Differential Equation Solvers and Numerical Linear Algebra for solver internals",
  "Simulation Workflow -> Computational Statistics for ensemble and uncertainty analysis",
  "Simulation Workflow -> HPC, Parallel, Distributed and GPU Computing for scalable simulation campaigns"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible simulation stages, model families or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve model-versus-solver distinction.",
  "Preserve scenario-versus-run distinction.",
  "Preserve solver-convergence-versus-model-validation distinction.",
  "Preserve deterministic-versus-stochastic simulation distinction.",
  "Preserve raw-simulation-output-versus-derived-QoI distinction.",
  "Preserve checkpoint-versus-final-result distinction.",
  "Preserve numerical-verification-versus-computational-validation distinction.",
  "Preserve machine-readable simulation-workflow semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "A simulation workflow is a structured scientific workflow that coordinates simulation model setup, solver execution, scenario control, output analysis, verification and validation."
 SETUP_SUMMARY = "Models, geometry, initial conditions, boundary conditions, parameters and forcing define the simulation problem."
 EXECUTION_SUMMARY = "Numerical solvers and time integrators advance the simulated state under explicit tolerance and stability semantics."
 ENSEMBLE_SUMMARY = "Scenario, parameter-sweep and ensemble workflows require unique run identities and controlled configuration."
 RESILIENCE_SUMMARY = "Checkpoints, retries and restart semantics support long-running simulation campaigns."
 VALIDATION_SUMMARY = "Simulation results should be numerically verified, scientifically validated, uncertainty-aware, provenance-linked and reproducible."
}

FLOW {
 INPUT
 -> detect_simulation_workflow_context
 -> identify_scientific_question_simulation_model_domain_conditions_parameters_solver_outputs_and_validation_needs
 -> prepare_geometry_mesh_initial_boundary_conditions_parameters_and_forcing
 -> choose_discretisation_solver_tolerances_precision_and_time_integration
 -> define_single_run_scenario_parameter_sweep_ensemble_or_coupled_execution
 -> execute_simulation_and_monitor_residuals_stability_convergence_and_failure_state
 -> persist_checkpoints_at_declared_intervals
 -> collect_fields_time_series_events_and_quantities_of_interest
 -> perform_numerical_verification_error_analysis_and_invariant_checks
 -> compare_outputs_with_independent_validation_evidence_and_uncertainty
 -> postprocess_and_package_simulation_results
 -> record_model_parameters_mesh_solver_versions_environment_and_execution_provenance
 -> package_artifacts_for_reproducible_rerun
 -> route_to_related_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-SCIENTIFIC-WORKFLOWS-SIMULATION-WORKFLOW-ONTOLOGY-V1"
}

}

END_FLOW