Class ProcessLinearizer

java.lang.Object
neqsim.process.mpc.ProcessLinearizer
public class ProcessLinearizer extends Object
Computes linearized process models from NeqSim ProcessSystem using finite differences.

The ProcessLinearizer automatically calculates the Jacobian matrices (gain matrices) that describe how controlled variables respond to changes in manipulated variables around an operating point. These matrices are essential for linear MPC algorithms.

The linearization uses central finite differences for improved accuracy: 

∂CV[i]/∂MV[j] ≈ (CV[i](MV[j]+δ) - CV[i](MV[j]-δ)) / (2δ)

Example usage: 


// Create linearizer for a process
ProcessLinearizer linearizer = new ProcessLinearizer(processSystem);

// Define inputs and outputs
linearizer.addMV(new ManipulatedVariable("ValveOpening", valve, "opening"));
linearizer.addMV(new ManipulatedVariable("HeaterDuty", heater, "duty", "kW"));
linearizer.addCV(new ControlledVariable("Pressure", separator, "pressure", "bara"));
linearizer.addCV(new ControlledVariable("Temperature", outlet, "temperature", "C"));

// Compute linearization
LinearizationResult result = linearizer.linearize(0.01); // 1% perturbation

// Access gains
double[][] gains = result.getGainMatrix();
double dPressure_dValve = gains[0][0];
double dPressure_dHeater = gains[0][1];
Since:
3.0
Version:
1.0
Author:
Even Solbraa

  • Field Details

    • processSystem

      private final ProcessSystem processSystem
      The process system to linearize.

    • manipulatedVariables

      private final List<ManipulatedVariable> manipulatedVariables
      List of manipulated variables.

    • controlledVariables

      private final List<ControlledVariable> controlledVariables
      List of controlled variables.

    • disturbanceVariables

      private final List<DisturbanceVariable> disturbanceVariables
      List of disturbance variables.

    • defaultPerturbationSize

      private double defaultPerturbationSize
      Default perturbation size as fraction of variable range.

    • minimumAbsolutePerturbation

      private double minimumAbsolutePerturbation
      Minimum absolute perturbation to avoid numerical issues.

    • useCentralDifferences

      private boolean useCentralDifferences
      Whether to use central differences (more accurate) or forward differences (faster).

  • Constructor Details

    • ProcessLinearizer

      public ProcessLinearizer(ProcessSystem processSystem)
      Construct a linearizer for a ProcessSystem.
      Parameters:
      processSystem - the NeqSim process to linearize

  • Method Details

    • addMV

      public ProcessLinearizer addMV(ManipulatedVariable mv)
      Add a manipulated variable to the linearization.
      Parameters:
      mv - the manipulated variable
      Returns:
      this linearizer for method chaining

    • addCV

      public ProcessLinearizer addCV(ControlledVariable cv)
      Add a controlled variable to the linearization.
      Parameters:
      cv - the controlled variable
      Returns:
      this linearizer for method chaining

    • addDV

      public ProcessLinearizer addDV(DisturbanceVariable dv)
      Add a disturbance variable to the linearization.
      Parameters:
      dv - the disturbance variable
      Returns:
      this linearizer for method chaining

    • getManipulatedVariables

      public List<ManipulatedVariable> getManipulatedVariables()
      Get the list of manipulated variables.
      Returns:
      unmodifiable list of MVs

    • getControlledVariables

      public List<ControlledVariable> getControlledVariables()
      Get the list of controlled variables.
      Returns:
      unmodifiable list of CVs

    • getDisturbanceVariables

      public List<DisturbanceVariable> getDisturbanceVariables()
      Get the list of disturbance variables.
      Returns:
      unmodifiable list of DVs

    • setDefaultPerturbationSize

      public ProcessLinearizer setDefaultPerturbationSize(double perturbation)
      Set the default perturbation size.
      Parameters:
      perturbation - the perturbation as a fraction (0.01 = 1%)
      Returns:
      this linearizer for method chaining

    • setMinimumAbsolutePerturbation

      public ProcessLinearizer setMinimumAbsolutePerturbation(double minPerturbation)
      Set the minimum absolute perturbation.
      Parameters:
      minPerturbation - the minimum perturbation value
      Returns:
      this linearizer for method chaining

    • setUseCentralDifferences

      public ProcessLinearizer setUseCentralDifferences(boolean useCentral)
      Set whether to use central differences.
      Parameters:
      useCentral - true for central differences (more accurate), false for forward differences (faster)
      Returns:
      this linearizer for method chaining

    • clear

      public ProcessLinearizer clear()
      Clear all variable definitions.
      Returns:
      this linearizer for method chaining

    • linearize

      public LinearizationResult linearize()
      Perform linearization with the default perturbation size.
      Returns:
      the linearization result containing gain matrices

    • linearize

      public LinearizationResult linearize(double perturbationSize)
      Perform linearization with a specified perturbation size.

      The linearization process:

      1. Read baseline CV values at current operating point
      2. For each MV, perturb and run simulation to measure CV changes
      3. Calculate gain as ΔCV/ΔMV
      4. Restore MV to original value
      5. Repeat for all MV-CV pairs
      Parameters:
      perturbationSize - perturbation as fraction of variable range
      Returns:
      the linearization result

    • calculatePerturbation

      private double calculatePerturbation(ManipulatedVariable mv, double currentValue, double perturbationFraction)
      Calculate the perturbation delta for a variable.
      Parameters:
      mv - the manipulated variable
      currentValue - the current value
      perturbationFraction - the perturbation as a fraction
      Returns:
      the perturbation delta

    • readAllCVs

      private double[] readAllCVs()
      Read all CV values.
      Returns:
      array of current CV values

    • linearizeMultiplePoints

      public List<LinearizationResult> linearizeMultiplePoints(int numPoints, double perturbationSize)
      Perform linearization at multiple operating points for validation.
      Parameters:
      numPoints - number of operating points to test
      perturbationSize - perturbation for each linearization
      Returns:
      list of linearization results at different operating points

    • isApproximatelyLinear

      public boolean isApproximatelyLinear(double perturbationSize1, double perturbationSize2, double tolerance)
      Check if the process is approximately linear within a range.
      Parameters:
      perturbationSize1 - first perturbation size
      perturbationSize2 - second perturbation size (should be different)
      tolerance - acceptable relative difference in gains
      Returns:
      true if gains are consistent (linear behavior)