Internal Service Layer

These modules are contributor implementation owners. Process-engineer code uses OpenPinch.PinchProblem or OpenPinch.PinchWorkspace. The service layer is the boundary between validated input data and the prepared/solved in-memory model. It is the right integration surface when you want more control than PinchProblem provides but do not want to invoke individual low-level algorithms directly.

Layering

The service stack is designed in three steps:

validate or receive typed request data
prepare the inputs into a Zone hierarchy
dispatch direct, indirect, HPR, exergy, cogeneration, or area/cost targeting

Use Cases

Use the service layer when you need to:

develop repository applications that need more control than the supported request/response boundary
prepare a zone hierarchy once and run multiple advanced studies against it
inspect the prepared model before solving
mutate a live prepared model with process components before rerunning targets
bypass file handling entirely and work with typed inputs
apply exergy or cogeneration as post-processing on already solved targets

Main Service Surface

Deterministic engineering analyses and specialist calculations.

Preparation Entry Point

The preparation stage is the key boundary between external inputs and the internal model. It validates configuration choices, builds the zone tree, applies dt_cont multipliers, instantiates process and utility streams, and produces the Zone object consumed by the solver stack.

Period-valued inputs remain period-aware after preparation, but period selection does not happen inside prepare_problem(...). Instead, the selected period is applied later through the targeting-service args dictionaries or the higher level problem.target.*(..., period_id=...) wrappers.

OpenPinch.application._problem.input.construction.prepare_problem(streams=None, utilities=None, options=None, project_name='Site', zone_tree=None)[source]

Build the top-level zone hierarchy for analysis.

Parameters:

streams (List[StreamSchema] | None)
utilities (List[UtilitySchema] | None)
options (Dict[str, Any] | None)
project_name (str)
zone_tree (ZoneTreeSchema)

Return type:

Zone

Heat Exchanger Network Synthesis Entry

Heat exchanger network synthesis is problem-rooted. User code should normally enter through PinchProblem.design:

problem.design.enhanced_heat_exchanger_network(quality_tier=2)
problem.design.open_hens()
problem.design.heat_exchanger_network()
problem.design.multiperiod_heat_exchanger_network()
problem.design.network_evolution((existing_network,))

The internal service entry point owns method dispatch and final result caching. It dispatches to the same direct services exposed by the design accessor. Each named method selects one workflow without a method-name string.

Service entry and dispatch for heat exchanger network synthesis.

OpenPinch.analysis.heat_exchanger_networks.service.heat_exchanger_network_evolution_method_service(problem, *, initial_networks=None, options=None, workspace_variant=None, executor=None)[source]

Run only seeded network evolution and update the problem cache.

Parameters:

problem (PinchProblem)
initial_networks (HeatExchangerNetwork | Sequence[HeatExchangerNetwork] | None)
options (dict[str, Any] | None)
workspace_variant (str | None)
executor (SynthesisExecutor | None)

Return type: