Process Logic Framework Implementation Summary

What Was Implemented

A comprehensive Process Logic Framework for NeqSim that enables coordinated, multi-step automation sequences for ESD, startup, shutdown, and general process control.

Core Components Created

1. Base Framework (neqsim.process.logic)

• ProcessLogic.java - Interface for all process logic
• LogicState.java - Enum for logic execution states (IDLE, RUNNING, PAUSED, COMPLETED, FAILED, WAITING_PERMISSIVES)
• LogicAction.java - Interface for actions on equipment

2. Action Implementations (neqsim.process.logic.action)

• TripValveAction.java - De-energize ESD valve
• ActivateBlowdownAction.java - Open blowdown valve
• SetSplitterAction.java - Configure splitter split factors

3. ESD Logic (neqsim.process.logic.esd)

• ESDLogic.java - Simplified ESD sequence executor with timed actions

4. Enhanced PushButton

• Updated PushButton.java to support multiple logic targets via linkToLogic(ProcessLogic)
• Maintains backward compatibility with direct BlowdownValve linking
• Single button can now trigger multiple coordinated actions

5. Example

• ESDLogicExample.java - Demonstrates coordinated 3-step ESD sequence

Key Benefits

1. Single Trigger, Multiple Actions

ESDLogic esdLogic = new ESDLogic("ESD Level 1");
esdLogic.addAction(new TripValveAction(esdValve), 0.0);      // Immediate
esdLogic.addAction(new ActivateBlowdownAction(bdValve), 0.5); // After 0.5s
esdLogic.addAction(new SetSplitterAction(splitter, factors), 0.0);

PushButton button = new PushButton("ESD-PB-101");
button.linkToLogic(esdLogic); // One button, three coordinated actions!

2. Reusable Logic Sequences

Define once, use across multiple simulations:

// Create standard startup sequence
StartupLogic standardStartup = createStandardStartup();

// Use in multiple simulations
processSystem1.addLogic(standardStartup);
processSystem2.addLogic(standardStartup.clone());

3. Clear Separation of Concerns

• Equipment: Knows how to operate (valves open/close, pumps start/stop)
• Logic: Knows when and in what order to operate equipment
• Triggers: Knows what conditions activate logic (manual, pressure, level, etc.)

4. Configurable Timing

esdLogic.addAction(action1, 0.0);   // Execute immediately
esdLogic.addAction(action2, 2.0);   // Wait 2 seconds
esdLogic.addAction(action3, 0.5);   // Wait additional 0.5 seconds

5. Future Extensibility

Easy to add:

• Startup logic with permissive checks
• Shutdown sequences with ramp-down
• Batch operations
• Conditional branching
• Parallel action execution
• Voting logic (1oo2, 2oo3)

Usage Pattern

Basic ESD Sequence

// 1. Create equipment
ESDValve esdValve = new ESDValve("ESD-XV-101", stream);
BlowdownValve bdValve = new BlowdownValve("BD-101", stream);
Splitter splitter = new Splitter("Splitter", stream, 2);

// 2. Create logic sequence
ESDLogic esdLogic = new ESDLogic("ESD Level 1");
esdLogic.addAction(new TripValveAction(esdValve), 0.0);
esdLogic.addAction(new ActivateBlowdownAction(bdValve), 0.5);
esdLogic.addAction(new SetSplitterAction(splitter, new double[]{0.0, 1.0}), 0.0);

// 3. Link to trigger
PushButton esdButton = new PushButton("ESD-PB-101");
esdButton.linkToLogic(esdLogic);

// 4. Execute in simulation
esdButton.push(); // Activates logic

while (!esdLogic.isComplete()) {
  esdLogic.execute(timeStep);
  equipment.runTransient(timeStep, id);
}

Architecture Diagram

┌─────────────────┐
│  Push Button    │ ──triggers──┐
└─────────────────┘             │
                                ▼
┌─────────────────────────────────────────┐
│         ProcessLogic (ESDLogic)         │
│  ┌────────────────────────────────────┐ │
│  │ Step 1: Trip ESD Valve (delay 0s) │ │──executes──▶ ESDValve.trip()
│  └────────────────────────────────────┘ │
│  ┌─────────────────────────────────────┐│
│  │ Step 2: Open BD Valve (delay 0.5s) ││──executes──▶ BlowdownValve.activate()
│  └─────────────────────────────────────┘│
│  ┌─────────────────────────────────────┐│
│  │ Step 3: Set Splitter (delay 0.0s)  ││──executes──▶ Splitter.setSplitFactors()
│  └─────────────────────────────────────┘│
└─────────────────────────────────────────┘

Future Enhancements

Phase 1: Conditions (Next Priority)

public interface LogicCondition {
  boolean evaluate();
  String getDescription();
}

// Example usage:
startupLogic.addStep("Open valve")
    .addAction(new OpenValveAction(valve))
    .addPrecondition(new PressureCondition(separator, "<", 5.0, "bara"))
    .addCompletionCondition(new ValvePositionCondition(valve, ">", 95.0));

Phase 2: Startup/Shutdown Logic

StartupLogic startup = new StartupLogic("Separator Train Startup");
startup.addStep("Pre-checks").addPermissive(/* ... */);
startup.addStep("Open isolation").addAction(/* ... */);
startup.addStep("Ramp up flow").addAction(/* ... */);
startup.enableAutoProgression(); // Automatic step advancement

Phase 3: Advanced Features

• Parallel action execution
• Conditional branching (if-then-else)
• Voting logic for redundant sensors
• Override management
• Visual logic editor

Comparison: Before vs After

Before (Manual Coordination)

esdButton.push();           // Activates BD valve only
esdValve.trip();           // Manual call
gasSplitter.setSplitFactors(new double[]{0.0, 1.0}); // Manual call
// Timing not coordinated, easy to forget steps

After (Logic Framework)

esdButton.push();  // Activates entire coordinated sequence
// All steps executed in correct order with proper timing
// Nothing forgotten, fully documented in logic sequence

Industry Standards Alignment

IEC 61511 (Functional Safety)

• Separation of logic from execution ✓
• Clear cause-and-effect relationships ✓
• Voting and redundancy support (future) ✓

IEC 61131-3 (PLC Programming)

• Sequential Function Chart (SFC) patterns ✓
• Function block structure ✓
• Reusable logic modules ✓

ISA-88 (Batch Control)

• Recipe-driven operations (future)
• Phase/operation/unit procedure hierarchy (future)

Files Created

Core Framework

• src/main/java/neqsim/process/logic/ProcessLogic.java
• src/main/java/neqsim/process/logic/LogicState.java
• src/main/java/neqsim/process/logic/LogicAction.java

Actions

• src/main/java/neqsim/process/logic/action/TripValveAction.java
• src/main/java/neqsim/process/logic/action/ActivateBlowdownAction.java
• src/main/java/neqsim/process/logic/action/SetSplitterAction.java

ESD Implementation

• src/main/java/neqsim/process/logic/esd/ESDLogic.java

Examples

• src/main/java/neqsim/process/util/example/ESDLogicExample.java

Documentation

• docs/process_logic_framework.md - Comprehensive design document

Modified Files

• src/main/java/neqsim/process/measurementdevice/PushButton.java - Added logic linking

Testing Recommendations

1. Unit Tests for Actions
   • Test each action independently
   • Mock equipment for isolation
2. Integration Tests for Logic
   • Test complete ESD sequences
   • Verify timing accuracy
   • Test failure modes
3. Example Tests
   • Run ESDLogicExample and verify output
   • Compare with manual coordination
   • Performance benchmarking

Conclusion

The Process Logic Framework provides a powerful, extensible foundation for implementing complex automation in NeqSim. It:

1. Simplifies complex multi-step operations
2. Coordinates timing between equipment actions
3. Documents operational sequences clearly
4. Reuses logic across simulations
5. Extends easily to new use cases (startup, batch, etc.)

The framework follows industry standards and best practices while maintaining NeqSim’s existing architecture and design patterns.