ChENGINEER SPACE

This is the sec­ond part of our text “Sim­u­lat­ing a dynamic tank in EMSO”. The first part shows the basic the­ory about EMSO mod­el­ing lan­guage applied to model a dynamic tank. The code to a sin­gle tank was imple­mented and expanded to a set of tanks in series.

Fig. 1. Dynamic tanks in series.

Last post did the expan­sion of a sin­gle tank to series using codes how­ever, in bigger/more com­plex sys­tems, it could be hard build­ing. In this sense, it should be more inter­est­ing if there is a GUI where a flow­sheet (dia­gram) can be built con­nect­ing blocks in a work­space such as in sequen­tial mod­u­lar sim­u­la­tors (Aspen Plus, HYSYS, etc.)

In EMSO we can attribute an image/icon to a Model adding a new sec­tion calls ATTRIBUTES. The reserved key­words in and out are required to pro­mote the input and out­put data from a model those are phys­i­cally rep­re­sented by the inlet and out­let flows (streams). How­ever, in order to take the block con­nec­tions actived the inlet and out­let flows must be com­pat­i­ble and defined by their own Model. For this pur­pose the “tank_flow” model was cre­ated (lines 3–6).

Thus all con­nec­tions are com­pat­i­ble but the inter­face design dia­gram does not admit a sin­gle block for sim­u­la­tion. One block needs at least one input block. For this a block calls “tank_source_test” (lines 8–15) was cre­ated using the “tank_flow” model. So it rep­re­sents a source block that gets the flow­sheet started.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using "types";
 
Model tank_flow
    VARIABLES
    F as flow_vol (Brief="Flow");
end
 
Model tank_source_test
    ATTRIBUTES
    Pallete = true;
    Icon = "source_icon";
 
    VARIABLES
out Outlet as tank_flow (Brief="Inlet stream", PosX=1, PosY=0.65);
end
 
Model simple_tank_test
    ATTRIBUTES
    Pallete = true;
    Icon = "tank_icon";
 
    PARAMETERS
    k as Real (Brief="Valve constant", Default=4, Unit='m^2.5/h');
    A as area (Brief="Tank area", Default=2);
 
    VARIABLES
in  Inlet  as tank_flow (Brief="Input flow", PosX=0, PosY=0.17);
out Outlet as tank_flow	(Brief="Output flow", PosX=1, PosY=0.94);
    h      as length	(Brief="Tank level");
 
    EQUATIONS
    "Material balance"
    diff(A*h) = Inlet.F - Outlet.F;
 
    "Valve equation"
    Outlet.F = k*sqrt(h);
end

There­fore “tank_source_test” (lines 8–15) and “simple_tank_test” (lines 17–37) define the blocks that would be load­ing on the pal­lete in Model tab accord­ing to their ATTRIBUTES sec­tions. Icon gives the icon as a PNG image (source_icon.png, tank_icon.png) so that Pal­lete set as true means that the related icon is loaded on the EMSO pal­lete (Model tab). PosX and PosY guide the posi­tions for point con­nec­tions.
Adding our work folder to EMSO library (Con­fig > Libraries > Add Library) and restart­ing it, we will be the new blocks loaded on the EMSO pal­lete of equip­ments.
Now let us build the flow­sheet of 2 tanks as in last post. Firstly cre­ate a new file of type “Dia­gram” so that a “Dia­gram setup” win­dow will open to edit­ing prop­er­ties. Go to “Options” tab and set start time, end time, and step time respec­tively as 0, 2, 0.1 hours. Here­after it already pos­si­ble to build the flow­sheet using the blocks and con­nec­tions. After that you will be some­thing like Fig. 2.

Fig. 2. Flow­sheet diagram

Dou­ble clicks on blocks in the dia­gram open the edit­ing prop­er­ties. For this case you must spec­ify the inlet flowrate and the ini­tial level for the 2 tanks.

For “tank_source”, the vari­able Outlet.F is spec­i­fied as 10 m³/h. For “tank_1” and “tank_2”, the vari­ables h are ini­tial­ized both as 1 m.

Check­ing the con­sis­tency of prob­lem and run­ning the plot results for the out­let tank flowrates will be as shown in Fig. 3.

Fig. 3. Plot results

This post starts to our sec­tion of HOW-TO texts. My obje­tive with this spe­cific post is to intro­duce using some free tools to dif­fer­ent applications.

A clas­sic prob­lem in process engi­neer­ing is the case of a dynamic tank where the out­put flow is pro­por­tional to its level (Fig. 1). This exam­ple is part of EMSO tuto­r­ial so that more details would be to con­sult in the EMSO man­ual.

Fig. 1. Dynamic tank.

In this approach­ing, the prob­lem of dynamic tank involves 3 vari­ables and 2 para­me­ters such below:

Vari­ables:

• Fⁱⁿ: Input flow (m³/h)
• F^out: Out­put flow (m³/h)
• h: Tank level (m)

Para­me­ters:

• A: Tank area (m²)
• k: Valve con­stant (m^2.5/h)

This sys­tem is mod­eled as sim­ple mate­r­ial bal­ance given to:

where the pro­pri­eties are con­sid­ered con­stants so that, the vol­ume that goes into tank minus the vol­ume that goes out tank are equal to accu­mu­lated volume.

The out­put flow is given to valve equation:

where F^out is pro­por­tional to square root of the tank level h and a valve con­stant k.

EMSO mod­el­ing lan­guage is based on con­cepts of object-oriented pro­gram­ing. These kinds of appli­ca­tions get us pos­si­ble to rep­re­sent the prob­lem through a code. As a result, when we are read­ing the code we are also read­ing a descrip­tion of the prob­lem. EMSO mod­el­ing lan­guage presents 3 basic enti­ties: Model, DEVICES, and Flow­Sheet. An flow­sheet of process is rep­re­sented by the entity Flow­Sheet which is con­sti­tuted by a set of com­po­nents calls DEVICES. The DEVICES are equiv­a­lent to the true units of a process. In its turn, the math­e­mat­i­cal descrip­tion of each DEVICES is rep­re­sented by the entity Model.

The Model of a sin­gle tank is given below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using "types";
 
Model tank
    PARAMETERS
    k as Real (Brief="Valve constant", Default=4, Unit='m^2.5/h');
    A as area (Brief="Tank area", Default=2);
 
    VARIABLES
in  Fin  as flow_vol(Brief="Input flow");
out Fout as flow_vol(Brief="Output flow");
    h    as length(Brief="Tank level");
 
    EQUATIONS
    "Material balance"
    diff(A*h) = Fin - Fout;
 
    "Valve equation"
    Fout = k*sqrt(h);
end

The line 1 indi­cates that Model used a exter­nal file (“types”) where con­tains all use­ful def­i­n­i­tion of unit of mea­sure­ments such as area (line 6), flow_vol (lines 9–10), length (line 11), etc. In the line 4, the para­me­ters are declared. In the line 8, the vari­ables are declared. The in and out indi­cate that are input and out­put vari­ables respectively.

Since there is a struc­ture that rep­re­sents a sin­gle tank, we can eas­ily model a set of tanks in series (Fig. 2).

Fig. 2. Dynamic tanks in series.

That set of tanks in series can be rep­re­sented by Flow­Sheet below. This struc­ture requires 1 input spec­i­fi­ca­tion (line 32) and 2 ini­tial con­di­tions (line 35). The time of inte­gra­tion, step, and other spec­i­fi­ca­tions to solver are made in the sec­tion OPTIONS (line 39).

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

FlowSheet tanks
    VARIABLES
    Fin        as flow_vol;
 
    DEVICES
    tank1      as tank;
    tank2      as tank;
 
    CONNECTIONS
    Fin        to tank1.Fin;
    tank2.Fout to tank2.Fin;
 
    SPECIFY
    Fin = 10*'m^3/h';
 
    INITIAL
    tank1.h = 1*'m';
    tank2.h = 1*'m';
 
    OPTIONS
    TimeStep = 0.1;
    TimeEnd = 2;
    TimeUnit = 'h';
end

The solu­tion of prob­lem can be viewed in the own simulator’s GUI. Plots of vari­ables to an ana­lyze of the sys­tem dynam­ics are showed at Fig. 3–4.

Fig. 3. Tank input and out­put flows.

Fig. 4. Tank levels.

ASCEND is an open source mod­el­ling envi­ron­ment and solver for large or small sys­tems of non-linear equa­tions, for use in engi­neer­ing, ther­mo­dy­nam­ics, chem­istry, physics, math­e­mat­ics and biol­ogy. Solvers for both steady and dynamic (NLA & DAE) prob­lems, are pro­vided. It offers:

- An object-oriented model descrip­tion lan­guage for describ­ing your system,

- An inter­ac­tive user inter­face that allows you to solve your model and explore the effect of chang­ing the model para­me­ters, and

- A script­ing envi­ron­ment that allows you to auto­mate your more com­plex sim­u­la­tion problems.

ASCEND was orig­i­nally writ­ten at Carnegie Mel­lon Uni­ver­sity in the 1980s and includes pow­er­ful and reli­able solver rou­tines that analyse the struc­ture of your model and can solve thou­sands of simul­ta­ne­ous non­lin­ear equa­tions in a few sec­onds on every­day com­puter hard­ware. It is under active devel­op­ment and is licensed under the GNU Gen­eral Pub­lic License ensur­ing that it is free soft­ware and will remain free.

Project web­site:

• http://ascend.cheme.cmu.edu

Screen­shots:

PyGTK ASCEND GUI

Graphic plot­ting