Skip to content

Cycle steps ​

A Cycle is a list of steps. Each step opens the devices of one bed that it needs, found by their roles (see add_device!), and keeps the others closed. Pressures carry over from step to step: a step that changes the pressure starts where the step before left the bed, unless given from.

PressurisefeedPressurise, LPPlight productAdsorbproductfeedBlowdownproduct lineEvacuateextractPurgelight productextractEqualiselink, high to lowIdleall closed
The step types, with the ends of the bed each one opens by default. The bottom of each bed is its feed end.
StepOpensPressureDefault name
Pressurisethe feed device, or the light inlet with source = :light_productrises to to, by default the feed pressurepressurisation, or LPP
Adsorbthe feed device and the product device at the other endheld at pressure, by default the feed pressureadsorption
Blowdownan outlet at its through end, by default the product device at the topfalls to toblowdown
Evacuatean outlet at its through end, by default the extract device at the bottomfalls to toevacuation
Purgethe light inlet and the extract device at the other endheld at pressure, by default where the step before left itpurge
Equalisethe link between two bedsboth meet between their start pressuresequalisation A to B
Idlenothingunchangedidle

Pressures in steps are in Pa; Mocca.Units has bar, so 0.2bar is 20000 Pa. While the pressure changes, the pressure on the far side of the valve follows an exponential ramp (see Model equations).

Pressurise ​

Raises the bed from where the step before left it to the feed pressure, or to to, through the feed device. With source = :light_product it takes light product through the light inlet at the top instead: light product pressurisation (LPP), as in the wet flue gas process of Krishnamurthy et al. (2014).

julia
Pressurise(15.0)                                  # feed, to the feed pressure
Pressurise(20.0; source = :light_product)         # LPP
json
{"type": "pressurise", "duration": 15}
{"type": "pressurise", "duration": 20, "source": "light_product"}

Adsorb ​

Feeds the bed at constant flow, with the light product leaving the other end at the feed pressure, or at pressure. Give the flow as one of an interstitial velocity [m/s], a superficial_velocity [m/s] or a flow_rate [m³/s at the bed inlet].

julia
Adsorb(15.0; velocity = 1.0)
json
{"type": "adsorb", "duration": 15, "velocity": 1.0}

A bed without a feed device of its own is fed through a link from the bed before it, as in the dual-adsorbent process, and takes no flow setting.

Blowdown ​

Lowers the bed to to through an outlet: by default the product device at the top (co-current). With through = :bottom it goes through a waste or extract device at the bottom instead (counter-current).

julia
Blowdown(30.0; to = 0.2bar)
json
{"type": "blowdown", "duration": 30, "to": "0.2 bar"}

Evacuate ​

Lowers the bed to to through the extract (vacuum) device at the bottom, which takes the CO₂ product. Like blowdown, through picks the other end.

julia
Evacuate(40.0; to = 0.1bar)
json
{"type": "evacuate", "duration": 40, "to": "0.1 bar"}

Purge ​

Light product enters through the light inlet at a constant flow and leaves through the extract device at the other end, sweeping the CO₂ out. The flow is given as in Adsorb.

julia
Purge(20.0; velocity = 0.2)
json
{"type": "purge", "duration": 20, "velocity": 0.2}

Equalise ​

Opens the link between two beds, such as their tops, so that gas flows from the bed at the higher pressure into the other. The size of the link valve, its conductance, sets how far the pressures come together in the time given. Afterwards both beds are taken to be at the mean of their start pressures, where the next ramps start.

julia
Equalise(10.0; beds = (:A, :B), conductance = 1e-6)
json
{"type": "equalise", "duration": 10, "beds": ["A", "B"], "conductance": 1e-6}

The Two-bed VSA with pressure equalisation example builds a process with it.

Idle ​

Keeps every device of the bed closed, for example while another bed finishes its steps.

julia
Idle(10.0; bed = :B)
json
{"type": "idle", "duration": 10, "bed": "B"}

Several beds ​

With several beds, each step names its bed. Steps run one after the other; Concurrent runs steps on different beds at the same time, as one stage:

julia
Concurrent(Pressurise(15.0; bed = :A), Evacuate(15.0; bed = :B, to = 0.1bar))

Beds can also follow sequences of their own, side by side, each a list of steps with a label. A shorter sequence waits with its devices closed until the longest one ends:

julia
Cycle("silica gel" => [...], "13X" => [...])
json
{"sequences": [{"label": "silica gel", "steps": [...]}, {"label": "13X", "steps": [...]}]}

The Wet flue gas: dual-adsorbent, two-bed VSA example runs a cycle like this. New kinds of step can be added with register_step!; see Extending Mocca.