Manifolds

Documentation for manifold equipment that combines stream mixing and splitting in NeqSim.

Table of Contents

Overview

Location: neqsim.process.equipment.manifold

A manifold is a process equipment that combines the functionality of a mixer and a splitter. It can:

This is particularly useful for:

Class Description
Manifold Combined mixer/splitter unit

Manifold Class

The Manifold class extends ProcessEquipmentBaseClass and contains both a Mixer and a Splitter internally.

Class Hierarchy

ProcessEquipmentBaseClass
└── Manifold
    ├── contains: Mixer
    └── contains: Splitter

Key Features

Constructor

import neqsim.process.equipment.manifold.Manifold;

// Basic constructor
Manifold manifold = new Manifold("PM-101");

Methods

Method Description
addStream(Stream) Add an input stream to the manifold
getSplitStream(int index) Get a specific output stream by index
setSplitNumber(int n) Set number of output streams
setSplitFactors(double[]) Set split ratios for outputs
getMixer() Access the internal mixer
getSplitter() Access the internal splitter
run() Execute mixing then splitting

Usage Examples

Basic Manifold Operation

import neqsim.process.equipment.manifold.Manifold;
import neqsim.process.equipment.stream.Stream;
import neqsim.thermo.system.SystemSrkEos;

// Create input streams (e.g., from multiple wells)
SystemInterface well1Fluid = new SystemSrkEos(350.0, 100.0);
well1Fluid.addComponent("methane", 0.85);
well1Fluid.addComponent("ethane", 0.10);
well1Fluid.addComponent("propane", 0.05);
well1Fluid.setMixingRule("classic");

Stream well1Stream = new Stream("Well-1", well1Fluid);
well1Stream.setFlowRate(50000, "Sm3/day");

SystemInterface well2Fluid = new SystemSrkEos(340.0, 95.0);
well2Fluid.addComponent("methane", 0.82);
well2Fluid.addComponent("ethane", 0.12);
well2Fluid.addComponent("propane", 0.06);
well2Fluid.setMixingRule("classic");

Stream well2Stream = new Stream("Well-2", well2Fluid);
well2Stream.setFlowRate(75000, "Sm3/day");

// Run inlet streams
well1Stream.run();
well2Stream.run();

// Create manifold
Manifold productionManifold = new Manifold("PM-101");
productionManifold.addStream(well1Stream);
productionManifold.addStream(well2Stream);

// Configure splitting (2 outlet lines)
productionManifold.setSplitNumber(2);
productionManifold.setSplitFactors(new double[] {0.6, 0.4});

// Run manifold
productionManifold.run();

// Access output streams
Stream toSeparator1 = (Stream) productionManifold.getSplitStream(0);
Stream toSeparator2 = (Stream) productionManifold.getSplitStream(1);

System.out.println("Total inlet: " + (50000 + 75000) + " Sm3/day");
System.out.println("Outlet 1: " + toSeparator1.getFlowRate("Sm3/day") + " Sm3/day");
System.out.println("Outlet 2: " + toSeparator2.getFlowRate("Sm3/day") + " Sm3/day");

Production Manifold System

import neqsim.process.processmodel.ProcessSystem;

ProcessSystem facility = new ProcessSystem("Offshore Platform");

// Wells
Stream well1 = createWellStream("Well-1", 50000);
Stream well2 = createWellStream("Well-2", 45000);
Stream well3 = createWellStream("Well-3", 60000);
facility.add(well1);
facility.add(well2);
facility.add(well3);

// Production manifold
Manifold manifold = new Manifold("Production Manifold");
manifold.addStream(well1);
manifold.addStream(well2);
manifold.addStream(well3);
manifold.setSplitNumber(2);  // Two production trains
manifold.setSplitFactors(new double[] {0.5, 0.5});
facility.add(manifold);

// Train separators
Separator separator1 = new Separator("V-101");
separator1.setInletStream(manifold.getSplitStream(0));
facility.add(separator1);

Separator separator2 = new Separator("V-201");
separator2.setInletStream(manifold.getSplitStream(1));
facility.add(separator2);

// Run facility
facility.run();

Accessing Internal Components

Manifold manifold = new Manifold("PM-101");
manifold.addStream(stream1);
manifold.addStream(stream2);

// Access internal mixer for mixed stream properties
Mixer mixer = manifold.getMixer();
mixer.run();
Stream mixedStream = mixer.getOutletStream();
System.out.println("Mixed temperature: " + mixedStream.getTemperature("C") + " °C");
System.out.println("Mixed pressure: " + mixedStream.getPressure("bara") + " bara");

// Access internal splitter
Splitter splitter = manifold.getSplitter();

Integration Patterns

Well Gathering System

Well-1 ──┐
         │
Well-2 ──┼──► [Manifold] ──┬──► Train A
         │                 │
Well-3 ──┘                 └──► Train B

Load Balancing

// Distribute load evenly across processing trains
int numTrains = 3;
double[] splitFactors = new double[numTrains];
for (int i = 0; i < numTrains; i++) {
    splitFactors[i] = 1.0 / numTrains;
}
manifold.setSplitFactors(splitFactors);

Dynamic Rerouting

// Redirect all flow to Train A (e.g., Train B offline)
manifold.setSplitFactors(new double[] {1.0, 0.0});
manifold.run();

Design Considerations

Pressure Matching

Input streams should have similar pressures. If pressures differ significantly, use chokes or control valves upstream.

Temperature Mixing

The manifold performs adiabatic mixing. The outlet temperature is calculated from energy balance.

Composition

The mixed composition is the flow-weighted average of all inlet compositions.

Comparison with Mixer/Splitter

Aspect Manifold Mixer + Splitter
Construction Single equipment Two separate units
Modeling Combined unit Sequential execution
Use Case Production headers General mixing/splitting
Intermediate Access Via getMixer()/getSplitter() Direct access