Has anyone tried to simulate a Multi Stage Flash evaporation process in tespy?

[evaporr]

Hello, I would like to simulate a Multi Stage Flash Evaporator (MSFE) system in tespy. Unfortunately, I have not found any existing source on the internet about this topic. Has anyone tried to program such a system and is willing to share the code? Is it even possible to simulate such a system (e.g. a 3-stage MSFE with the usual components) in tespy?

I would also appreciate if someone could provide a source of a similar process to help me get started with programming an MSFE process.

Many thanks!

[fwitte]

@evaporr, thank you for reaching out. I do think that what you are trying to do is possible. It would be very helpful if you could at minimum

• provide a flowsheet of the specific plant you are trying to model, so something like this: https://commons.wikimedia.org/wiki/File:Process_scheme_of_a_3-stage_flash_evaporator_plant_with_brine_recirculation.jpg and
• provide a sketch of the logp h diagram of your process.

Both, in case you have something specific in mind

Otherwise all I can say at this moment is this:

Basically, you have a throttling valve which causes a saturated liquid to undergo partial evaporation and then separate the gas from the remaining liquid phase. The remaining liquid phase can be recycled and undergo another flash at lower pressure level and so on. Depending on the temperature level you need the gas phase to be at, compressors might be needed, or you could instead of reducing the pressure level for the next flash pump the liquid back to the original pressure, but then you would need to add some heat to the process, to bring the liquid back into saturated state...

I do not know too much about this specific process, because I have never worked with it. To model it in TESPy, you will need the DropletSeparator, Valve, Compressor and/or Pump, Source and Sink, maybe HeatExchangerSimple components.

Best

Francesco

[fwitte]

Hi @evaporr,

sorry, I have never come back to this. It got drowend in a pile of work... Does the issue still persist?

[quentin1337]

Hi,

I am currently working on the same project and just saw this thread. I was just curious if you could find a reasonable solution for your multi-stage-flash plant. Right now I am struggling a bit with the flash evaporation, because I thought the calculation using the Valve component wouldnt be as precise as an actual flash evaporation calculation. Do you have any finished code, that you could provide? That would be so helpful.

Best regards
Quentin

[fwitte]

@quentin1337 hi!

I do not have a complete code, but we could meet at the next user meeting (January 15, 17:00 CET) if you want to discuss this.

In the meantime, could you give me a little bit more context or a minimum example (with flow sheet) indicating,

• what the issue is exaclty and importantly,
• what physical/mathematical relationship you want to model exaclty (the respective equations, so I can understand, how to port that into tespy.

Thanks!

Best

Francesco

[fwitte]

This is an idea for the optimization of brine mass flow given constant power input (for heater and pump)

from tespy.components import Pump, Sink, HeatExchanger, Valve, Condenser, DropletSeparator, Source, Merge, SolarCollector, SimpleHeatExchanger

from tespy.connections import Connection, Bus
from tespy.networks import Network
# from fluprodia import FluidPropertyDiagram
import matplotlib.pyplot as plt
# import networkx as nx
import pandas as pd
import numpy as np

# brineheater_valve1.set_attr(T=None)
# for p in [1.1, 1.2, 1.3, 1.4]:
#     brineheater_valve1.set_attr(p=p)
#     for dT in [-30, -20, -10, -5, -0.01]:
#         brineheater_valve1.set_attr(Td_bp=dT)
#         nw.solve("design")
#         print(source_pump.m.val_SI - droplet3_sink_brine.m.val_SI)

class MSFplant:

    def __init__(self):

        # Netzwerk erstellen
        # Festlegen von Wasser als Fluid, sowie die Einheiten
        nw = Network(T_unit='C', p_unit='bar', h_unit='kJ / kg', m_unit='kg / s')
        # Komponenten erstellen
        # solar = SolarCollector('solar')
        source = Source('source')
        pump = Pump('pump')
        condenser3 = Condenser('condenser3')
        condenser2 = Condenser('condenser2')
        condenser1 = Condenser('condenser1')
        brineheater = SimpleHeatExchanger('brineheater')
        droplet1 = DropletSeparator('droplet1')
        droplet2 = DropletSeparator('droplet2')
        droplet3 = DropletSeparator('droplet3')
        valve1 = Valve('valve1')
        valve2 = Valve('valve2')
        valve3 = Valve('valve3')
        sink_water1 = Sink('sink_water1')
        sink_water2 = Sink('sink_water2')
        sink_water3 = Sink('sink_water3')
        sink_brine = Sink('sink_brine')

        # Verbindungen erstellen
        #von der Seewasserquelle bis zum Brine Heater
        source_pump = Connection(source, 'out1', pump, 'in1')
        pump_condenser3 = Connection(pump, 'out1', condenser3, 'in2')
        condenser3_condenser2 = Connection(condenser3, 'out2', condenser2, 'in2')
        condenser2_condenser1 = Connection(condenser2, 'out2', condenser1, 'in2')
        condenser1_brineheater = Connection(condenser1, 'out2', brineheater, 'in1')
        #1. Flashkammer mit Auffangbecken1
        brineheater_valve1 = Connection(brineheater, 'out1', valve1, 'in1', label="T_approach")
        valve1_droplet1 = Connection(valve1, 'out1', droplet1, 'in1')
        droplet1_condenser1 = Connection(droplet1, 'out2', condenser1, 'in1')
        condenser1_sink_water1 = Connection(condenser1, 'out1', sink_water1, 'in1')
        #2. Flashkammer mit Auffangbecken2
        droplet1_valve2 = Connection(droplet1, 'out1', valve2, 'in1')
        valve2_droplet2 = Connection(valve2, 'out1', droplet2, 'in1')
        droplet2_condenser2 = Connection(droplet2, 'out2', condenser2, 'in1')
        condenser2_sink_water2 = Connection(condenser2, 'out1', sink_water2, 'in1')
        #3. Flashkammer mit Auffangbecken3
        droplet2_valve3 = Connection(droplet2, 'out1', valve3, 'in1')
        valve3_droplet3 = Connection(valve3, 'out1', droplet3, 'in1')
        droplet3_condenser3 = Connection(droplet3, 'out2', condenser3, 'in1')
        condenser3_sink_water3 = Connection(condenser3, 'out1', sink_water3, 'in1')
        #Salzlake
        droplet3_sink_brine = Connection(droplet3, 'out1', sink_brine, 'in1', label="brinemassflow")

        # Verbindungen zum Netzwerk hinzufügen
        nw.add_conns(source_pump,
        pump_condenser3,
        condenser3_condenser2,
        condenser2_condenser1,
        condenser1_brineheater,
        brineheater_valve1,
        valve1_droplet1,
        droplet1_condenser1,
        condenser1_sink_water1,
        droplet1_valve2,
        valve2_droplet2,
        droplet2_condenser2,
        condenser2_sink_water2,
        droplet2_valve3,
        valve3_droplet3,
        droplet3_condenser3,
        condenser3_sink_water3,
        droplet3_sink_brine
        )

        # Parametrisierung der Verbindungen
        source_pump.set_attr(fluid={'water': 1}, T=20, p=1, m=1)
        brineheater_valve1.set_attr(T=80)  # Stellschraube 2
        valve1_droplet1.set_attr(p=0.4)
        valve2_droplet2.set_attr(p=0.12)
        valve3_droplet3.set_attr(p=0.09)  # Stellschraube 3
        # Parametrisierung der Komponenten
        pump.set_attr(eta_s=0.7) # Wirkungsgrad und Leistung der Pumpe
        brineheater.set_attr(pr=1) # Wärmeübertragung im Brine Heater
        brineheater_valve1.set_attr(p=1.2) # Stellschraube 1
        condenser1.set_attr(pr1=1, pr2=1) # Wärmeabfuhr im Kondensator 1
        condenser2.set_attr(pr1=1, pr2=1) # Wärmeabfuhr im Kondensator 2
        condenser3.set_attr(pr1=1, pr2=1) # Wärmeabfuhr im Kondensator 3
        #pr1 ist die Seewasserseite, pr2 die Kondensatseite
        # Ausführung der Simulation
        nw.set_attr(iterinfo=False)
        nw.solve('design')
        valve1_droplet1.set_attr(p=None)
        condenser1.set_attr(ttd_u=5)
        valve2_droplet2.set_attr(p=None)
        condenser2.set_attr(ttd_u=5)
        valve3_droplet3.set_attr(p=None)
        condenser3.set_attr(ttd_u=5)
        nw.solve("design")
        nw.print_results()

        power_input_bus = Bus("power input", P=80e3)
        power_input_bus.add_comps(
            {"comp": brineheater, "base": "bus", "char": 0.98},
            {"comp": pump, "base": "bus", "char": 0.98}
        )

        nw.add_busses(power_input_bus)

        source_pump.set_attr(m=None)

        nw.solve("design")
        self.stable = "stable_design"
        nw.save(self.stable)
        brineheater_valve1.set_attr(T=None)
        nw.print_results()
        self.nw = nw
        self.solved = True

    def get_param(self, obj, label, parameter):
        """Get the value of a parameter in the network"s unit system.

        Parameters
        ----------
        obj : str
            Object to get parameter for (Components/Connections).

        label : str
            Label of the object in the TESPy model.

        parameter : str
            Name of the parameter of the object.

        Returns
        -------
        value : float
            Value of the parameter.
        """
        if obj == "Components":
            return self.nw.get_comp(label).get_attr(parameter).val
        elif obj == "Connections":
            return self.nw.get_conn(label).get_attr(parameter).val

    def set_params(self, **kwargs):

        if "Connections" in kwargs:
            for c, params in kwargs["Connections"].items():
                self.nw.get_conn(c).set_attr(**params)

        if "Components" in kwargs:
            for c, params in kwargs["Components"].items():
                self.nw.get_comp(c).set_attr(**params)

    def solve_model(self, **kwargs):
        """
        Solve the TESPy model given the the input parameters
        """
        self.set_params(**kwargs)

        self.solved = False
        try:
            self.nw.solve("design")
            if not self.nw.converged:
                self.nw.solve("design", init_only=True, init_path=self.stable)
            else:
                self.solved = True
        except ValueError as e:
            self.nw.lin_dep = True
            self.nw.solve("design", init_only=True, init_path=self.stable)

    def get_objective(self, objective=None):
        """
        Get the current objective alion evaluation.

        Parameters
        ----------
        objective : str
            Name of the objective function.

        Returns
        -------
        objective_value : float
            Evaluation of the objective function.
        """
        if self.solved:
            return self.nw.get_conn("brinemassflow").m.val_SI
        else:
            return np.nan


plant = MSFplant()
plant.get_objective()
variables = {
    "Connections": {
        "T_approach": {
            "p": {"min": 1.1, "max": 10},
            "Td_bp": {"min": -30, "max": -0.01}
        }
    }
}

from tespy.tools.optimization import OptimizationProblem
import pygmo as pg

optimize = OptimizationProblem(
    plant, variables, {}, objective="brine mass flow"
)

num_ind = 10
num_gen = 20

# for algorithm selection and parametrization please consider the pygmo
# documentation! The number of generations indicated in the algorithm is
# the number of evolutions we undertake within each generation defined in
# num_gen
algo = pg.algorithm(pg.pso(seed=42))
# create starting population
pop = pg.population(pg.problem(optimize), size=num_ind, seed=42)

optimize.run(algo, pop, num_ind, num_gen)