trunk/models/dyn_column.a4l

REQUIRE "dyn_flash.a4l";
(* => dyn_flash.a4l, splitter.a4l, stream_holdup.a4l thermodynamics.a4l,
 *    components.a4l, phases.a4l, atoms.a4l, measures.a4l, system.a4l,
 *    basemodel.a4l *)
PROVIDE "dyn_column.a4l";

(*
 *  dyn_colunm.a4l
 *  by Duncan Coffey
 *  Part of the ASCEND Library
 *  $Date: 1998/06/17 19:01:29 $
 *  $Revision: 1.2 $
 *  $Author: mthomas $
 *  $Source: /afs/cs.cmu.edu/project/ascend/Repository/models/dyn_column.a4l,v $
 *
 *  This file is part of the ASCEND Modeling Library.
 *
 *  Copyright (C) 1998 Duncan Coffey
 *
 *  The ASCEND Modeling Library is free software; you can redistribute
 *  it and/or modify it under the terms of the GNU General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  The ASCEND Modeling Library is distributed in hope that it
 *  will be useful, but WITHOUT ANY WARRANTY; without even the implied
 *  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *  See the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check
 *  the file named COPYING.
 *)


(*********************************************************************
 *  Requires an empty ascend system.
 *********************************************************************)


(* ***********************************+************************************ *)
(* ********************           Reactor             ********************* *)
(* ***********************************+************************************ *)

MODEL tray_stack(
    ntrays WILL_BE integer_constant;
    vapin WILL_BE stream;
    liqin WILL_BE stream;
    vapout WILL_BE stream;
    liqout WILL_BE stream;
    t WILL_BE solver_var;
    dynamic WILL_BE boolean;
    ode_offset WILL_BE ode_counter;
    obs_offset WILL_BE obs_counter;
)WHERE(
    ntrays > 1;
    liqout.state, vapout.state WILL_NOT_BE_THE_SAME;
    vapin.state.cd, vapout.state.cd WILL_BE_THE_SAME;
    vapin.pd.phase_indicator == 'V';
    liqin.pd.phase_indicator == 'L';
    vapout.pd.phase_indicator == 'V';
    liqout.pd.phase_indicator == 'L';
    )REFINES cmumodel;

	cd ALIASES liqout.cd;
	pdV ALIASES vapout.pd;
	pdL ALIASES liqout.pd;
	equilibrated ALIASES liqout.equilibrated;
	pdVL IS_A phases_data('VL', vapout.pd.vapor_option,
	          liqout.pd.liquid1_option, 'none');

	vap_option ALIASES vapout.pd.vapor_option;
	liq_option ALIASES liqout.pd.liquid1_option;
	tmp_phaseV[2..ntrays] IS_A select_mixture_type(cd, vap_option);
	tmp_phaseL[2..ntrays] IS_A select_mixture_type(cd, liq_option);
	FOR i IN [2..ntrays] CREATE
	    phaseV[i]['vapor'] ALIASES tmp_phaseV[i].phase;
	    phaseL[i]['liquid1'] ALIASES tmp_phaseL[i].phase;
	END FOR;
	FOR i IN [2..ntrays] CREATE
	    vapor_state[i] IS_A thermodynamics(cd,pdV,phaseV[i],equilibrated);
	    liquid_state[i] IS_A thermodynamics(cd,pdL,phaseL[i],equilibrated);
	END FOR;
	FOR i IN [2..ntrays] CREATE
	    tmp_vapor[i] IS_A detailed_stream(vapor_state[i]);
	    tmp_liquid[i] IS_A detailed_stream(liquid_state[i]);
	END FOR;

        vapor[V_set_trays]
            ALIASES (vapout.Details,tmp_vapor[2..ntrays],vapin.Details)
 	    WHERE V_set_trays IS_A set OF integer_constant
	    WITH_VALUE (1..ntrays+1);

        liquid[L_set_trays]
            ALIASES (liqin.Details,tmp_liquid[2..ntrays],liqout.Details)
 	    WHERE L_set_trays IS_A set OF integer_constant
	    WITH_VALUE (1..ntrays+1);

	FOR i IN [1..ntrays] CREATE
	    phaseVL[i][VLphases[i]] ALIASES
		(vapor[i].state.phase['vapor'],liquid[i+1].state.phase['liquid1'])
		WHERE VLphases[i] IS_A set OF symbol_constant
		WITH_VALUE ('vapor','liquid1');
	END FOR;
	FOR i IN [1..ntrays] CREATE
	    tray_state[i] IS_A thermodynamics(cd,pdVL,phaseVL[i],equilibrated);
	END FOR;
	FOR i IN [1..ntrays] CREATE
            tray[i] IS_A detailed_tray(liquid[i], vapor[i+1], liquid[i+1],
                                       vapor[i], tray_state[i], t,
                                       dynamic, ode_offset, obs_offset);
	END FOR;

	FOR i IN [1..ntrays] CREATE
	    Vol[i] ALIASES tray[i].Vol;
	    vol_liq[i] ALIASES tray[i].vol_liq;
	    vol_vap[i] ALIASES tray[i].vol_vap;
	    cmo_ratio[i] ALIASES tray[i].cmo_ratio;
	    tray_T[i] ALIASES tray[i].T;
	    tray_P[i] ALIASES tray[i].P;
	    Qin[i] ALIASES tray[i].Qin;
	END FOR;

	METHODS
	METHOD check_self;
	    FOR i IN [2..ntrays] DO
		IF (liquid[i].flow < 1e-4 {mole/s}) THEN
		    STOP {liquid flow to tray i dried up};
		END IF;
		IF (vapor[i].flow < 1e-4 {mole/s}) THEN
		    STOP {vapor flow from tray i dried up};
		END IF;
	    END FOR;
	    IF (abs(vapin.flow+liqin.flow - vapout.flow - liqout.flow)
	             > 1.0e-4) THEN
		STOP {stack violates overall mass-balance};
	    END IF;
	    RUN tray_state[1..ntrays].check_self;
	END check_self;

	METHOD check_all;
	    IF (liqout.flow < 1e-4 {mole/s}) THEN
		STOP {Liquid flow dried up in stack};
	    END IF;
	    IF (vapout.flow < 1e-4 {mole/s}) THEN
		STOP {All vapor condensed in stack};
	    END IF;
	    IF (vapin.flow < 1e-4 {mole/s}) THEN
		STOP {No vapin flowing to stack};
	    END IF;
	    IF (liqin.flow < 1e-4 {mole/s}) THEN
		STOP {No liqin flowing to stack};
	    END IF;
	    RUN check_self;
	END check_all;

	METHOD default_self;
	    RUN vapor[2..ntrays].default_self;
	    RUN liquid[2..ntrays].default_self;
	    RUN pdVL.default_self;
	    RUN phaseVL[1..ntrays][VLphases[1..ntrays]].default_self;
	    RUN tray_state[1..ntrays].default_self;
	    RUN tray[1..ntrays].default_self;
	END default_self;

	METHOD default_all;
	    RUN vapin.default_self;
	    RUN liqin.default_self;
	    RUN vapout.default_self;
	    RUN liqout.default_self;
	    RUN default_self;
	END default_all;
	METHOD bound_self;
	    RUN vapor[2..ntrays].bound_self;
	    RUN liquid[1..ntrays].bound_self;
	    RUN tray_state[1..ntrays].bound_self;
	    RUN tray[1..ntrays].bound_self;
	END bound_self;
	METHOD bound_all;
 	    RUN vapin.bound_self;
	    RUN liqin.bound_self;
	    RUN vapout.bound_self;
	    RUN liqout.bound_self;
	    RUN bound_self;
	END bound_all;
	METHOD scale_self;
	    RUN vapor[2..ntrays].scale_self;
	    RUN liquid[1..ntrays].scale_self;
	    RUN tray_state[1..ntrays].scale_self;
	    RUN tray[1..ntrays].scale_self;
	END scale_self;
	METHOD scale_all;
  	    RUN vapin.scale_self;
	    RUN liqin.scale_self;
	    RUN vapout.scale_self;
	    RUN liqout.scale_self;
	    RUN scale_self;
	END scale_all;
	METHOD seqmod;
	    RUN tray[1..ntrays].seqmod;
	END seqmod;
	METHOD specify;
	    RUN vapin.specify;
	    RUN liqin.specify;
	    RUN seqmod;
	END specify;
	METHOD reset_to_adiabatic;
	    RUN seqmod;
	    Qin[1..ntrays] :=0 {kW};
	    FREE cmo_ratio[1..ntrays];
	    FIX Qin[1..ntrays];
	END reset_to_adiabatic;
	METHOD set_ode;
	    RUN tray[1..ntrays].set_ode;
	END set_ode;
	METHOD set_obs;
	    RUN tray[1..ntrays].set_obs;
	END set_obs;
END tray_stack;

MODEL column(
    vap_distillate WILL_BE stream;
    liq_distillate WILL_BE stream;
    con_partial WILL_BE boolean;
    n_trays_above WILL_BE integer_constant;
    feed WILL_BE stream;
    n_trays_below WILL_BE integer_constant;
    reboil_partial WILL_BE boolean;
    vap_bottoms WILL_BE stream;
    liq_bottoms WILL_BE stream;
    t WILL_BE solver_var;
    dynamic WILL_BE boolean;
    ode_offset WILL_BE ode_counter;
    obs_offset WILL_BE obs_counter;
)WHERE(
    n_trays_above > 1;
    n_trays_below > 1;
    feed.state, vap_bottoms.state, vap_distillate.state,
         liq_bottoms.state, liq_distillate.state WILL_NOT_BE_THE_SAME;
    feed.state.cd, vap_distillate.state.cd, vap_bottoms.state.cd,
	 liq_distillate.state.cd, liq_bottoms.state.cd WILL_BE_THE_SAME;
    (feed.pd.phase_indicator IN ['V','L','VL','VLL']) == TRUE;
    liq_bottoms.pd.phase_indicator == 'L';
    vap_bottoms.pd.phase_indicator == 'V';
    liq_distillate.pd.phase_indicator == 'L';
    vap_distillate.pd.phase_indicator == 'V';
)REFINES cmumodel;

    cd ALIASES feed.cd;
    pdV ALIASES vap_distillate.pd;
    pdL ALIASES liq_distillate.pd;
    equilibrated ALIASES vap_distillate.equilibrated;

    tray_P[tmp1] ALIASES (top_stack.tray_P[1..n_trays_above],feed_tray.P,
        bottom_stack.tray_P[1..n_trays_below]) WHERE tmp1 IS_A set OF integer_constant
        WITH_VALUE (1..n_trays_above+n_trays_below+1);
    tray_T[tmp2] ALIASES (top_stack.tray_T[1..n_trays_above],feed_tray.T,
        bottom_stack.tray_T[1..n_trays_below]) WHERE tmp2 IS_A set OF integer_constant
        WITH_VALUE (1..n_trays_above+n_trays_below+1);
    cmo_ratio[tmp3] ALIASES (top_stack.cmo_ratio[1..n_trays_above],feed_tray.q,
        bottom_stack.cmo_ratio[1..n_trays_below]) WHERE tmp3 IS_A set OF integer_constant
	WITH_VALUE (1..n_trays_above+n_trays_below+1);
    Qin[tmp4] ALIASES (top_stack.Qin[1..n_trays_above],feed_tray.Qin,
        bottom_stack.Qin[1..n_trays_below]) WHERE tmp4 IS_A set OF integer_constant
	WITH_VALUE (1..n_trays_above+n_trays_below+1);

    col_feed ALIASES feed_tray.feed;
    vapor_distillate ALIASES condenser.vap_distillate;
    liquid_distillate ALIASES condenser.liq_distillate;
    reflux_ratio ALIASES condenser.reflux_ratio;
    condenser_T ALIASES condenser.T;
    condenser_P ALIASES condenser.P;
    vapor_bottoms ALIASES reboiler.vap_bottom;
    liquid_bottoms ALIASES reboiler.liq_bottom;
    reboil_ratio ALIASES reboiler.reboil_ratio;
    reboiler_T ALIASES reboiler.T;
    reboiler_P ALIASES reboiler.P;

    condenser_liqout IS_A stream(cd,pdL,equilibrated);
    top_stack_vapout IS_A stream(cd,pdV,equilibrated);
    top_stack_liqout IS_A stream(cd,pdL,equilibrated);
    feed_vapout IS_A stream(cd,pdV,equilibrated);
    feed_liqout IS_A stream(cd,pdL,equilibrated);
    bottom_stack_vapout IS_A stream(cd,pdV,equilibrated);
    bottom_stack_liqout IS_A stream(cd,pdL,equilibrated);
    reboiler_vapout IS_A stream(cd,pdV,equilibrated);

    condenser IS_A condenser(top_stack_vapout,vap_distillate,liq_distillate,
       condenser_liqout,con_partial,t,dynamic,ode_offset,obs_offset);

    top_stack IS_A tray_stack(n_trays_above,feed_vapout,condenser_liqout,
       top_stack_vapout,top_stack_liqout,t,dynamic,ode_offset,obs_offset);

    feed_tray IS_A feed_tray(feed,top_stack_liqout,bottom_stack_vapout,
       feed_liqout,feed_vapout,t,dynamic,ode_offset,obs_offset);

    bottom_stack IS_A tray_stack(n_trays_below,reboiler_vapout,feed_liqout,
       bottom_stack_vapout,bottom_stack_liqout,t,dynamic,ode_offset,obs_offset);

    reboiler IS_A reboiler(bottom_stack_liqout,vap_bottoms,liq_bottoms,
       reboiler_vapout,reboil_partial,t,dynamic,ode_offset,obs_offset);

    METHODS
	METHOD check_self;
	    RUN condenser.check_self;
	    RUN top_stack_vapout.check_self;
	    RUN condenser_liqout.check_self;
	    RUN top_stack.check_self;
	    RUN top_stack_liqout.check_self;
	    RUN feed_vapout.check_self;
	    RUN feed_tray.check_self;
	    RUN feed_liqout.check_self;
	    RUN bottom_stack_vapout.check_self;
	    RUN bottom_stack.check_self;
	    RUN bottom_stack.liqout.check_self;
	    RUN reboiler_vapout.check_self;
	    RUN reboiler.check_self;
	    IF (abs(feed.flow-vap_distillate.flow-liq_distillate.flow
		-vap_bottoms.flow-liq_bottoms.flow) > 1.0e-4) THEN
		STOP {column violates overall mass-balance};
	    END IF;
	END check_self;

	METHOD check_all;
	    IF con_partial THEN
		IF (vap_distillate.flow < 1e-4 {mole/s}) THEN
		    STOP {vapor distillate flow dried up};
		END IF;
	    ELSE
		IF (liq_distillate.flow < 1e-4 {mole/s}) THEN
		    STOP {liquid distillate flow dried up};
		END IF;
	    END IF;
	    IF (feed.flow < 1e-4 {mole/s}) THEN
		STOP {distillate feed flow dried up};
	    END IF;
	    IF reboil_partial THEN
		IF (liq_bottoms.flow < 1e-4 {mole/s}) THEN
		    STOP {liquid bottoms flow dried up};
		END IF;
	    ELSE
		IF (vap_bottoms.flow < 1e-4 {mole/s}) THEN
		    STOP {vapor bottoms flow dried up};
		END IF;
	    END IF;
	    RUN check_self;
	END check_all;
	METHOD default_self;
    	    RUN top_stack_vapout.default_self;
	    RUN condenser.default_self;
	    RUN condenser_liqout.default_self;
	    RUN top_stack.default_self;
	    RUN top_stack_liqout.default_self;
	    RUN feed_vapout.default_self;
	    RUN feed_liqout.default_self;
	    RUN feed_tray.default_self;
	    RUN bottom_stack_vapout.default_self;
	    RUN bottom_stack.default_self;
	    RUN bottom_stack.liqout.default_self;
	    RUN reboiler_vapout.default_self;
	    RUN reboiler.default_self;
	END default_self;
	METHOD default_all;
 	    RUN feed.default_self;
	    RUN vap_distillate.default_self;
	    RUN liq_distillate.default_self;
	    RUN liq_bottoms.default_self;
	    RUN vap_bottoms.default_self;
	    RUN default_self;
	END default_all;
	METHOD bound_self;
	    RUN condenser.bound_self;
	    RUN top_stack_vapout.bound_self;
	    RUN condenser_liqout.bound_self;
	    RUN top_stack.bound_self;
	    RUN top_stack_liqout.bound_self;
	    RUN feed_vapout.bound_self;
	    RUN feed_tray.bound_self;
	    RUN feed_liqout.bound_self;
	    RUN bottom_stack_vapout.bound_self;
	    RUN bottom_stack.bound_self;
	    RUN bottom_stack.liqout.bound_self;
	    RUN reboiler_vapout.bound_self;
	    RUN reboiler.bound_self;
	END bound_self;
	METHOD bound_all;
  	    RUN feed.bound_self;
	    RUN vap_distillate.bound_self;
	    RUN liq_distillate.bound_self;
	    RUN liq_bottoms.bound_self;
	    RUN vap_bottoms.bound_self;
	    RUN bound_self;
	END bound_all;
	METHOD scale_self;
	    RUN condenser.scale_self;
	    RUN top_stack_vapout.scale_self;
	    RUN condenser_liqout.scale_self;
	    RUN top_stack.scale_self;
	    RUN top_stack_liqout.scale_self;
	    RUN feed_vapout.scale_self;
	    RUN feed_tray.scale_self;
	    RUN feed_liqout.scale_self;
	    RUN bottom_stack_vapout.scale_self;
	    RUN bottom_stack.scale_self;
	    RUN bottom_stack.liqout.scale_self;
	    RUN reboiler_vapout.scale_self;
	    RUN reboiler.scale_self;
	END scale_self;
	METHOD scale_all;
  	    RUN feed.scale_self;
	    RUN vap_distillate.scale_self;
	    RUN liq_distillate.scale_self;
	    RUN liq_bottoms.scale_self;
	    RUN vap_bottoms.scale_self;
	    RUN scale_self;
	END scale_all;
	METHOD seqmod;
	    RUN condenser.seqmod;
	    RUN top_stack.seqmod;
	    RUN feed_tray.seqmod;
	    RUN bottom_stack.seqmod;
	    RUN reboiler.seqmod;
	END seqmod;
	METHOD specify;
	    RUN feed.specify;
	    RUN seqmod;
	END specify;
	METHOD reset_to_adiabatic;
	    RUN seqmod;
	    RUN top_stack.reset_to_adiabatic;
	    RUN feed_tray.reset_to_adiabatic;
	    RUN bottom_stack.reset_to_adiabatic;
	END reset_to_adiabatic;
	METHOD set_ode;
	    RUN condenser.set_ode;
	    RUN top_stack.set_ode;
	    RUN feed_tray.set_ode;
	    RUN bottom_stack.set_ode;
	    RUN reboiler.set_ode;
	END set_ode;
	METHOD set_obs;
	    RUN condenser.set_obs;
	    RUN top_stack.set_obs;
	    RUN feed_tray.set_obs;
	    RUN bottom_stack.set_obs;
	    RUN reboiler.set_obs;
	END set_obs;
END column;


(***************************************************************************)


MODEL test_tray_stack() REFINES testflashmodel();

    cd IS_A components_data(['methanol','ethanol','water'],'water');
    pdV IS_A phases_data('V', 'Pitzer_vapor_mixture', 'none', 'none');
    pdL IS_A phases_data('L', 'none', 'UNIFAC_liquid_mixture', 'none');
    equilibrated IS_A boolean;
    vin IS_A stream(cd,pdV,equilibrated);
    lin IS_A stream(cd,pdL,equilibrated);
    lout IS_A stream(cd,pdL,equilibrated);
    vout IS_A stream(cd,pdV,equilibrated);
    ntrays IS_A integer_constant;
    ntrays :==10;
    t IS_A time;
    dynamic IS_A boolean;
    ode_offset IS_A ode_counter;
    obs_offset IS_A obs_counter;
    fl1 IS_A tray_stack(ntrays, vin, lin, vout, lout, t,
                        dynamic, ode_offset, obs_offset);

    (* boundwidth might be unit specific *)
    boundwidth IS_A bound_width;

METHODS

METHOD default_all;
	RUN default_self;
END default_all;

METHOD default_self;
        boundwidth := 10;
	equilibrated :=TRUE;
	ode_offset :=1;
	obs_offset :=1;
	RUN vin.default_self;
	RUN lin.default_self;
	RUN lout.default_self;
	RUN vout.default_self;
	RUN fl1.default_self;
END default_self;

METHOD check_all;
	RUN check_self;
END check_all;

METHOD check_self;
    RUN vin.check_self;
    RUN lin.check_self;
    RUN lout.check_self;
    RUN vout.check_self;
    RUN fl1.check_self;
END check_self;

METHOD bound_all;
	RUN bound_self;
END bound_all;

METHOD bound_self;
    fl1.boundwidth := boundwidth;
    lin.boundwidth := boundwidth;
    vin.boundwidth := boundwidth;
    lout.boundwidth := boundwidth;
    vout.boundwidth := boundwidth;
    RUN fl1.bound_all;
END bound_self;

METHOD scale_self;
    RUN vin.scale_self;
    RUN lin.scale_self;
    RUN lout.scale_self;
    RUN vout.scale_self;
    RUN fl1.scale_self;
END scale_self;

METHOD specify;
	RUN fl1.specify;
END specify;

METHOD values;
	vin.P := 1 {atm};
	vin.T := 365 {K};
	vin.f['methanol'] := 0.01 {kmol/s};
	vin.f['ethanol'] := 0.015 {kmol/s};
	vin.f['water'] := 0.02 {kmol/s};
	lin.P := 1 {atm};
	lin.T := 365 {K};
	lin.f['methanol'] := 0.01 {kmol/s};
	lin.f['ethanol'] := 0.015 {kmol/s};
	lin.f['water'] := 0.02 {kmol/s};
	FOR i IN [1..ntrays] DO
	    fl1.cmo_ratio[i] := 1;
	    fl1.tray_P[i] := 1 {atm};
	    fl1.tray_T[i] := 365 {K};
	    fl1.Qin[i] := 0 {kW};
	    fl1.Vol[i] := 3 {m^3};
	    fl1.vol_liq[i] := 1 {m^3};
	END FOR;
END values;

END test_tray_stack;

MODEL test_column() REFINES testflashmodel();

    cd IS_A components_data(['n_pentane','n_hexane','n_heptane'],'n_heptane');
    pdV IS_A phases_data('V', 'Pitzer_vapor_mixture', 'none', 'none');
    pdL IS_A phases_data('L', 'none', 'UNIFAC_liquid_mixture', 'none');
    equilibrated IS_A boolean;
    vap_dist IS_A stream(cd,pdV,equilibrated);
    liq_dist IS_A stream(cd,pdL,equilibrated);
    liq_bot IS_A stream(cd,pdL,equilibrated);
    vap_bot IS_A stream(cd,pdV,equilibrated);
    feed IS_A stream(cd,pdL,equilibrated);
    below IS_A integer_constant;
    below :==5;
    above IS_A integer_constant;
    above :==5;
    t IS_A time;
    dynamic IS_A boolean;
    C_partial IS_A boolean;
    R_partial IS_A boolean;
    ode_offset IS_A ode_counter;
    obs_offset IS_A obs_counter;
    col IS_A column(vap_dist,liq_dist,C_partial,above,feed,below,R_partial,
        vap_bot,liq_bot,t,dynamic,ode_offset,obs_offset);

    (* boundwidth might be unit specific *)
    boundwidth IS_A bound_width;

    METHODS

    METHOD default_all;
	RUN default_self;
    END default_all;

    METHOD default_self;
	boundwidth := 10;
	equilibrated :=FALSE;
	ode_offset :=1;
	obs_offset :=1;
	RUN vap_dist.default_self;
	RUN liq_dist.default_self;
	RUN feed.default_self;
	RUN vap_bot.default_self;
	RUN liq_bot.default_self;
	RUN col.default_self;
    END default_self;

    METHOD check_all;
	RUN check_self;
    END check_all;

    METHOD check_self;
	IF C_partial THEN
	    RUN vap_dist.check_self;
	ELSE
	    RUN liq_dist.check_self;
	END IF;
	RUN feed.check_self;
	IF R_partial THEN
	    RUN liq_bot.check_self;
	ELSE
	    RUN vap_bot.check_self;
	END IF;
	RUN col.check_self;
    END check_self;

    METHOD bound_all;
	RUN bound_self;
    END bound_all;

    METHOD bound_self;
	vap_dist.boundwidth := boundwidth;
	liq_dist.boundwidth := boundwidth;
	feed.boundwidth := boundwidth;
	liq_bot.boundwidth := boundwidth;
	vap_bot.boundwidth := boundwidth;
	RUN col.bound_all;
    END bound_self;

    METHOD scale_self;
	RUN vap_dist.scale_self;
	RUN liq_dist.scale_self;
	RUN feed.scale_self;
	RUN vap_bot.scale_self;
	RUN liq_bot.scale_self;
	RUN col.scale_self;
    END scale_self;

    METHOD scale_all;
	RUN scale_self;
    END scale_all;

    METHOD specify;
	RUN col.specify;
    END specify;

    METHOD values;
	feed.P := 1 {atm};
	feed.T := 365 {K};
	feed.f['n_pentane'] := 0.01 {kmol/s};
	feed.f['n_hexane'] := 0.01 {kmol/s};
	feed.f['n_heptane'] := 0.01 {kmol/s};
	vap_dist.flow :=0 {mol/s};
	vap_bot.flow :=0 {mol/s};
	col.condenser.Vol :=3 {m^3};
	col.condenser.vol_liq :=1 {m^3};
	col.reflux_ratio :=1.5;
	col.feed_tray.Vol :=1 {m^3};
	col.feed_tray.vol_liq :=0.3 {m^3};
	col.feed_tray.q :=1;
	col.top_stack.Vol[1..above] :=1 {m^3};
	col.top_stack.vol_liq[1..above] :=0.3 {m^3};
	col.bottom_stack.Vol[1..above] :=1 {m^3};
	col.bottom_stack.vol_liq[1..above] :=0.3 {m^3};
	col.reboiler.Vol :=3 {m^3};
	col.reboiler.vol_liq :=1 {m^3};
	col.reboil_ratio :=2;
    END values;

END test_column;
1	REQUIRE "dyn_flash.a4l";
2	(* => dyn_flash.a4l, splitter.a4l, stream_holdup.a4l thermodynamics.a4l,
3	* components.a4l, phases.a4l, atoms.a4l, measures.a4l, system.a4l,
4	* basemodel.a4l *)
5	PROVIDE "dyn_column.a4l";
6
7	(*
8	* dyn_colunm.a4l
9	* by Duncan Coffey
10	* Part of the ASCEND Library
11	* $Date: 1998/06/17 19:01:29 $
12	* $Revision: 1.2 $
13	* $Author: mthomas $
14	* $Source: /afs/cs.cmu.edu/project/ascend/Repository/models/dyn_column.a4l,v $
15	*
16	* This file is part of the ASCEND Modeling Library.
17	*
18	* Copyright (C) 1998 Duncan Coffey
19	*
20	* The ASCEND Modeling Library is free software; you can redistribute
21	* it and/or modify it under the terms of the GNU General Public
22	* License as published by the Free Software Foundation; either
23	* version 2 of the License, or (at your option) any later version.
24	*
25	* The ASCEND Modeling Library is distributed in hope that it
26	* will be useful, but WITHOUT ANY WARRANTY; without even the implied
27	* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
28	* See the GNU General Public License for more details.
29	*
30	* You should have received a copy of the GNU General Public License
31	* along with the program; if not, write to the Free Software
32	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check
33	* the file named COPYING.
34	*)
35
36
37	(*********************************************************************
38	* Requires an empty ascend system.
39	*********************************************************************)
40
41
42	(* *********************************+********************************** *)
43	(* ****************** Reactor ******************* *)
44	(* *********************************+********************************** *)
45
46	MODEL tray_stack(
47	ntrays WILL_BE integer_constant;
48	vapin WILL_BE stream;
49	liqin WILL_BE stream;
50	vapout WILL_BE stream;
51	liqout WILL_BE stream;
52	t WILL_BE solver_var;
53	dynamic WILL_BE boolean;
54	ode_offset WILL_BE ode_counter;
55	obs_offset WILL_BE obs_counter;
56	)WHERE(
57	ntrays > 1;
58	liqout.state, vapout.state WILL_NOT_BE_THE_SAME;
59	vapin.state.cd, vapout.state.cd WILL_BE_THE_SAME;
60	vapin.pd.phase_indicator == 'V';
61	liqin.pd.phase_indicator == 'L';
62	vapout.pd.phase_indicator == 'V';
63	liqout.pd.phase_indicator == 'L';
64	)REFINES cmumodel;
65
66	cd ALIASES liqout.cd;
67	pdV ALIASES vapout.pd;
68	pdL ALIASES liqout.pd;
69	equilibrated ALIASES liqout.equilibrated;
70	pdVL IS_A phases_data('VL', vapout.pd.vapor_option,
71	liqout.pd.liquid1_option, 'none');
72
73	vap_option ALIASES vapout.pd.vapor_option;
74	liq_option ALIASES liqout.pd.liquid1_option;
75	tmp_phaseV[2..ntrays] IS_A select_mixture_type(cd, vap_option);
76	tmp_phaseL[2..ntrays] IS_A select_mixture_type(cd, liq_option);
77	FOR i IN [2..ntrays] CREATE
78	phaseV[i]['vapor'] ALIASES tmp_phaseV[i].phase;
79	phaseL[i]['liquid1'] ALIASES tmp_phaseL[i].phase;
80	END FOR;
81	FOR i IN [2..ntrays] CREATE
82	vapor_state[i] IS_A thermodynamics(cd,pdV,phaseV[i],equilibrated);
83	liquid_state[i] IS_A thermodynamics(cd,pdL,phaseL[i],equilibrated);
84	END FOR;
85	FOR i IN [2..ntrays] CREATE
86	tmp_vapor[i] IS_A detailed_stream(vapor_state[i]);
87	tmp_liquid[i] IS_A detailed_stream(liquid_state[i]);
88	END FOR;
89
90	vapor[V_set_trays]
91	ALIASES (vapout.Details,tmp_vapor[2..ntrays],vapin.Details)
92	WHERE V_set_trays IS_A set OF integer_constant
93	WITH_VALUE (1..ntrays+1);
94
95	liquid[L_set_trays]
96	ALIASES (liqin.Details,tmp_liquid[2..ntrays],liqout.Details)
97	WHERE L_set_trays IS_A set OF integer_constant
98	WITH_VALUE (1..ntrays+1);
99
100	FOR i IN [1..ntrays] CREATE
101	phaseVL[i][VLphases[i]] ALIASES
102	(vapor[i].state.phase['vapor'],liquid[i+1].state.phase['liquid1'])
103	WHERE VLphases[i] IS_A set OF symbol_constant
104	WITH_VALUE ('vapor','liquid1');
105	END FOR;
106	FOR i IN [1..ntrays] CREATE
107	tray_state[i] IS_A thermodynamics(cd,pdVL,phaseVL[i],equilibrated);
108	END FOR;
109	FOR i IN [1..ntrays] CREATE
110	tray[i] IS_A detailed_tray(liquid[i], vapor[i+1], liquid[i+1],
111	vapor[i], tray_state[i], t,
112	dynamic, ode_offset, obs_offset);
113	END FOR;
114
115	FOR i IN [1..ntrays] CREATE
116	Vol[i] ALIASES tray[i].Vol;
117	vol_liq[i] ALIASES tray[i].vol_liq;
118	vol_vap[i] ALIASES tray[i].vol_vap;
119	cmo_ratio[i] ALIASES tray[i].cmo_ratio;
120	tray_T[i] ALIASES tray[i].T;
121	tray_P[i] ALIASES tray[i].P;
122	Qin[i] ALIASES tray[i].Qin;
123	END FOR;
124
125	METHODS
126	METHOD check_self;
127	FOR i IN [2..ntrays] DO
128	IF (liquid[i].flow < 1e-4 {mole/s}) THEN
129	STOP {liquid flow to tray i dried up};
130	END IF;
131	IF (vapor[i].flow < 1e-4 {mole/s}) THEN
132	STOP {vapor flow from tray i dried up};
133	END IF;
134	END FOR;
135	IF (abs(vapin.flow+liqin.flow - vapout.flow - liqout.flow)
136	> 1.0e-4) THEN
137	STOP {stack violates overall mass-balance};
138	END IF;
139	RUN tray_state[1..ntrays].check_self;
140	END check_self;
141
142	METHOD check_all;
143	IF (liqout.flow < 1e-4 {mole/s}) THEN
144	STOP {Liquid flow dried up in stack};
145	END IF;
146	IF (vapout.flow < 1e-4 {mole/s}) THEN
147	STOP {All vapor condensed in stack};
148	END IF;
149	IF (vapin.flow < 1e-4 {mole/s}) THEN
150	STOP {No vapin flowing to stack};
151	END IF;
152	IF (liqin.flow < 1e-4 {mole/s}) THEN
153	STOP {No liqin flowing to stack};
154	END IF;
155	RUN check_self;
156	END check_all;
157
158	METHOD default_self;
159	RUN vapor[2..ntrays].default_self;
160	RUN liquid[2..ntrays].default_self;
161	RUN pdVL.default_self;
162	RUN phaseVL[1..ntrays][VLphases[1..ntrays]].default_self;
163	RUN tray_state[1..ntrays].default_self;
164	RUN tray[1..ntrays].default_self;
165	END default_self;
166
167	METHOD default_all;
168	RUN vapin.default_self;
169	RUN liqin.default_self;
170	RUN vapout.default_self;
171	RUN liqout.default_self;
172	RUN default_self;
173	END default_all;
174	METHOD bound_self;
175	RUN vapor[2..ntrays].bound_self;
176	RUN liquid[1..ntrays].bound_self;
177	RUN tray_state[1..ntrays].bound_self;
178	RUN tray[1..ntrays].bound_self;
179	END bound_self;
180	METHOD bound_all;
181	RUN vapin.bound_self;
182	RUN liqin.bound_self;
183	RUN vapout.bound_self;
184	RUN liqout.bound_self;
185	RUN bound_self;
186	END bound_all;
187	METHOD scale_self;
188	RUN vapor[2..ntrays].scale_self;
189	RUN liquid[1..ntrays].scale_self;
190	RUN tray_state[1..ntrays].scale_self;
191	RUN tray[1..ntrays].scale_self;
192	END scale_self;
193	METHOD scale_all;
194	RUN vapin.scale_self;
195	RUN liqin.scale_self;
196	RUN vapout.scale_self;
197	RUN liqout.scale_self;
198	RUN scale_self;
199	END scale_all;
200	METHOD seqmod;
201	RUN tray[1..ntrays].seqmod;
202	END seqmod;
203	METHOD specify;
204	RUN vapin.specify;
205	RUN liqin.specify;
206	RUN seqmod;
207	END specify;
208	METHOD reset_to_adiabatic;
209	RUN seqmod;
210	Qin[1..ntrays] :=0 {kW};
211	FREE cmo_ratio[1..ntrays];
212	FIX Qin[1..ntrays];
213	END reset_to_adiabatic;
214	METHOD set_ode;
215	RUN tray[1..ntrays].set_ode;
216	END set_ode;
217	METHOD set_obs;
218	RUN tray[1..ntrays].set_obs;
219	END set_obs;
220	END tray_stack;
221
222	MODEL column(
223	vap_distillate WILL_BE stream;
224	liq_distillate WILL_BE stream;
225	con_partial WILL_BE boolean;
226	n_trays_above WILL_BE integer_constant;
227	feed WILL_BE stream;
228	n_trays_below WILL_BE integer_constant;
229	reboil_partial WILL_BE boolean;
230	vap_bottoms WILL_BE stream;
231	liq_bottoms WILL_BE stream;
232	t WILL_BE solver_var;
233	dynamic WILL_BE boolean;
234	ode_offset WILL_BE ode_counter;
235	obs_offset WILL_BE obs_counter;
236	)WHERE(
237	n_trays_above > 1;
238	n_trays_below > 1;
239	feed.state, vap_bottoms.state, vap_distillate.state,
240	liq_bottoms.state, liq_distillate.state WILL_NOT_BE_THE_SAME;
241	feed.state.cd, vap_distillate.state.cd, vap_bottoms.state.cd,
242	liq_distillate.state.cd, liq_bottoms.state.cd WILL_BE_THE_SAME;
243	(feed.pd.phase_indicator IN ['V','L','VL','VLL']) == TRUE;
244	liq_bottoms.pd.phase_indicator == 'L';
245	vap_bottoms.pd.phase_indicator == 'V';
246	liq_distillate.pd.phase_indicator == 'L';
247	vap_distillate.pd.phase_indicator == 'V';
248	)REFINES cmumodel;
249
250	cd ALIASES feed.cd;
251	pdV ALIASES vap_distillate.pd;
252	pdL ALIASES liq_distillate.pd;
253	equilibrated ALIASES vap_distillate.equilibrated;
254
255	tray_P[tmp1] ALIASES (top_stack.tray_P[1..n_trays_above],feed_tray.P,
256	bottom_stack.tray_P[1..n_trays_below]) WHERE tmp1 IS_A set OF integer_constant
257	WITH_VALUE (1..n_trays_above+n_trays_below+1);
258	tray_T[tmp2] ALIASES (top_stack.tray_T[1..n_trays_above],feed_tray.T,
259	bottom_stack.tray_T[1..n_trays_below]) WHERE tmp2 IS_A set OF integer_constant
260	WITH_VALUE (1..n_trays_above+n_trays_below+1);
261	cmo_ratio[tmp3] ALIASES (top_stack.cmo_ratio[1..n_trays_above],feed_tray.q,
262	bottom_stack.cmo_ratio[1..n_trays_below]) WHERE tmp3 IS_A set OF integer_constant
263	WITH_VALUE (1..n_trays_above+n_trays_below+1);
264	Qin[tmp4] ALIASES (top_stack.Qin[1..n_trays_above],feed_tray.Qin,
265	bottom_stack.Qin[1..n_trays_below]) WHERE tmp4 IS_A set OF integer_constant
266	WITH_VALUE (1..n_trays_above+n_trays_below+1);
267
268	col_feed ALIASES feed_tray.feed;
269	vapor_distillate ALIASES condenser.vap_distillate;
270	liquid_distillate ALIASES condenser.liq_distillate;
271	reflux_ratio ALIASES condenser.reflux_ratio;
272	condenser_T ALIASES condenser.T;
273	condenser_P ALIASES condenser.P;
274	vapor_bottoms ALIASES reboiler.vap_bottom;
275	liquid_bottoms ALIASES reboiler.liq_bottom;
276	reboil_ratio ALIASES reboiler.reboil_ratio;
277	reboiler_T ALIASES reboiler.T;
278	reboiler_P ALIASES reboiler.P;
279
280	condenser_liqout IS_A stream(cd,pdL,equilibrated);
281	top_stack_vapout IS_A stream(cd,pdV,equilibrated);
282	top_stack_liqout IS_A stream(cd,pdL,equilibrated);
283	feed_vapout IS_A stream(cd,pdV,equilibrated);
284	feed_liqout IS_A stream(cd,pdL,equilibrated);
285	bottom_stack_vapout IS_A stream(cd,pdV,equilibrated);
286	bottom_stack_liqout IS_A stream(cd,pdL,equilibrated);
287	reboiler_vapout IS_A stream(cd,pdV,equilibrated);
288
289	condenser IS_A condenser(top_stack_vapout,vap_distillate,liq_distillate,
290	condenser_liqout,con_partial,t,dynamic,ode_offset,obs_offset);
291
292	top_stack IS_A tray_stack(n_trays_above,feed_vapout,condenser_liqout,
293	top_stack_vapout,top_stack_liqout,t,dynamic,ode_offset,obs_offset);
294
295	feed_tray IS_A feed_tray(feed,top_stack_liqout,bottom_stack_vapout,
296	feed_liqout,feed_vapout,t,dynamic,ode_offset,obs_offset);
297
298	bottom_stack IS_A tray_stack(n_trays_below,reboiler_vapout,feed_liqout,
299	bottom_stack_vapout,bottom_stack_liqout,t,dynamic,ode_offset,obs_offset);
300
301	reboiler IS_A reboiler(bottom_stack_liqout,vap_bottoms,liq_bottoms,
302	reboiler_vapout,reboil_partial,t,dynamic,ode_offset,obs_offset);
303
304	METHODS
305	METHOD check_self;
306	RUN condenser.check_self;
307	RUN top_stack_vapout.check_self;
308	RUN condenser_liqout.check_self;
309	RUN top_stack.check_self;
310	RUN top_stack_liqout.check_self;
311	RUN feed_vapout.check_self;
312	RUN feed_tray.check_self;
313	RUN feed_liqout.check_self;
314	RUN bottom_stack_vapout.check_self;
315	RUN bottom_stack.check_self;
316	RUN bottom_stack.liqout.check_self;
317	RUN reboiler_vapout.check_self;
318	RUN reboiler.check_self;
319	IF (abs(feed.flow-vap_distillate.flow-liq_distillate.flow
320	-vap_bottoms.flow-liq_bottoms.flow) > 1.0e-4) THEN
321	STOP {column violates overall mass-balance};
322	END IF;
323	END check_self;
324
325	METHOD check_all;
326	IF con_partial THEN
327	IF (vap_distillate.flow < 1e-4 {mole/s}) THEN
328	STOP {vapor distillate flow dried up};
329	END IF;
330	ELSE
331	IF (liq_distillate.flow < 1e-4 {mole/s}) THEN
332	STOP {liquid distillate flow dried up};
333	END IF;
334	END IF;
335	IF (feed.flow < 1e-4 {mole/s}) THEN
336	STOP {distillate feed flow dried up};
337	END IF;
338	IF reboil_partial THEN
339	IF (liq_bottoms.flow < 1e-4 {mole/s}) THEN
340	STOP {liquid bottoms flow dried up};
341	END IF;
342	ELSE
343	IF (vap_bottoms.flow < 1e-4 {mole/s}) THEN
344	STOP {vapor bottoms flow dried up};
345	END IF;
346	END IF;
347	RUN check_self;
348	END check_all;
349	METHOD default_self;
350	RUN top_stack_vapout.default_self;
351	RUN condenser.default_self;
352	RUN condenser_liqout.default_self;
353	RUN top_stack.default_self;
354	RUN top_stack_liqout.default_self;
355	RUN feed_vapout.default_self;
356	RUN feed_liqout.default_self;
357	RUN feed_tray.default_self;
358	RUN bottom_stack_vapout.default_self;
359	RUN bottom_stack.default_self;
360	RUN bottom_stack.liqout.default_self;
361	RUN reboiler_vapout.default_self;
362	RUN reboiler.default_self;
363	END default_self;
364	METHOD default_all;
365	RUN feed.default_self;
366	RUN vap_distillate.default_self;
367	RUN liq_distillate.default_self;
368	RUN liq_bottoms.default_self;
369	RUN vap_bottoms.default_self;
370	RUN default_self;
371	END default_all;
372	METHOD bound_self;
373	RUN condenser.bound_self;
374	RUN top_stack_vapout.bound_self;
375	RUN condenser_liqout.bound_self;
376	RUN top_stack.bound_self;
377	RUN top_stack_liqout.bound_self;
378	RUN feed_vapout.bound_self;
379	RUN feed_tray.bound_self;
380	RUN feed_liqout.bound_self;
381	RUN bottom_stack_vapout.bound_self;
382	RUN bottom_stack.bound_self;
383	RUN bottom_stack.liqout.bound_self;
384	RUN reboiler_vapout.bound_self;
385	RUN reboiler.bound_self;
386	END bound_self;
387	METHOD bound_all;
388	RUN feed.bound_self;
389	RUN vap_distillate.bound_self;
390	RUN liq_distillate.bound_self;
391	RUN liq_bottoms.bound_self;
392	RUN vap_bottoms.bound_self;
393	RUN bound_self;
394	END bound_all;
395	METHOD scale_self;
396	RUN condenser.scale_self;
397	RUN top_stack_vapout.scale_self;
398	RUN condenser_liqout.scale_self;
399	RUN top_stack.scale_self;
400	RUN top_stack_liqout.scale_self;
401	RUN feed_vapout.scale_self;
402	RUN feed_tray.scale_self;
403	RUN feed_liqout.scale_self;
404	RUN bottom_stack_vapout.scale_self;
405	RUN bottom_stack.scale_self;
406	RUN bottom_stack.liqout.scale_self;
407	RUN reboiler_vapout.scale_self;
408	RUN reboiler.scale_self;
409	END scale_self;
410	METHOD scale_all;
411	RUN feed.scale_self;
412	RUN vap_distillate.scale_self;
413	RUN liq_distillate.scale_self;
414	RUN liq_bottoms.scale_self;
415	RUN vap_bottoms.scale_self;
416	RUN scale_self;
417	END scale_all;
418	METHOD seqmod;
419	RUN condenser.seqmod;
420	RUN top_stack.seqmod;
421	RUN feed_tray.seqmod;
422	RUN bottom_stack.seqmod;
423	RUN reboiler.seqmod;
424	END seqmod;
425	METHOD specify;
426	RUN feed.specify;
427	RUN seqmod;
428	END specify;
429	METHOD reset_to_adiabatic;
430	RUN seqmod;
431	RUN top_stack.reset_to_adiabatic;
432	RUN feed_tray.reset_to_adiabatic;
433	RUN bottom_stack.reset_to_adiabatic;
434	END reset_to_adiabatic;
435	METHOD set_ode;
436	RUN condenser.set_ode;
437	RUN top_stack.set_ode;
438	RUN feed_tray.set_ode;
439	RUN bottom_stack.set_ode;
440	RUN reboiler.set_ode;
441	END set_ode;
442	METHOD set_obs;
443	RUN condenser.set_obs;
444	RUN top_stack.set_obs;
445	RUN feed_tray.set_obs;
446	RUN bottom_stack.set_obs;
447	RUN reboiler.set_obs;
448	END set_obs;
449	END column;
450
451
452
453	(***************************************************************************)
454
455
456
457	MODEL test_tray_stack() REFINES testflashmodel();
458
459	cd IS_A components_data(['methanol','ethanol','water'],'water');
460	pdV IS_A phases_data('V', 'Pitzer_vapor_mixture', 'none', 'none');
461	pdL IS_A phases_data('L', 'none', 'UNIFAC_liquid_mixture', 'none');
462	equilibrated IS_A boolean;
463	vin IS_A stream(cd,pdV,equilibrated);
464	lin IS_A stream(cd,pdL,equilibrated);
465	lout IS_A stream(cd,pdL,equilibrated);
466	vout IS_A stream(cd,pdV,equilibrated);
467	ntrays IS_A integer_constant;
468	ntrays :==10;
469	t IS_A time;
470	dynamic IS_A boolean;
471	ode_offset IS_A ode_counter;
472	obs_offset IS_A obs_counter;
473	fl1 IS_A tray_stack(ntrays, vin, lin, vout, lout, t,
474	dynamic, ode_offset, obs_offset);
475
476	(* boundwidth might be unit specific *)
477	boundwidth IS_A bound_width;
478
479	METHODS
480
481	METHOD default_all;
482	RUN default_self;
483	END default_all;
484
485	METHOD default_self;
486	boundwidth := 10;
487	equilibrated :=TRUE;
488	ode_offset :=1;
489	obs_offset :=1;
490	RUN vin.default_self;
491	RUN lin.default_self;
492	RUN lout.default_self;
493	RUN vout.default_self;
494	RUN fl1.default_self;
495	END default_self;
496
497	METHOD check_all;
498	RUN check_self;
499	END check_all;
500
501	METHOD check_self;
502	RUN vin.check_self;
503	RUN lin.check_self;
504	RUN lout.check_self;
505	RUN vout.check_self;
506	RUN fl1.check_self;
507	END check_self;
508
509	METHOD bound_all;
510	RUN bound_self;
511	END bound_all;
512
513	METHOD bound_self;
514	fl1.boundwidth := boundwidth;
515	lin.boundwidth := boundwidth;
516	vin.boundwidth := boundwidth;
517	lout.boundwidth := boundwidth;
518	vout.boundwidth := boundwidth;
519	RUN fl1.bound_all;
520	END bound_self;
521
522	METHOD scale_self;
523	RUN vin.scale_self;
524	RUN lin.scale_self;
525	RUN lout.scale_self;
526	RUN vout.scale_self;
527	RUN fl1.scale_self;
528	END scale_self;
529
530	METHOD specify;
531	RUN fl1.specify;
532	END specify;
533
534	METHOD values;
535	vin.P := 1 {atm};
536	vin.T := 365 {K};
537	vin.f['methanol'] := 0.01 {kmol/s};
538	vin.f['ethanol'] := 0.015 {kmol/s};
539	vin.f['water'] := 0.02 {kmol/s};
540	lin.P := 1 {atm};
541	lin.T := 365 {K};
542	lin.f['methanol'] := 0.01 {kmol/s};
543	lin.f['ethanol'] := 0.015 {kmol/s};
544	lin.f['water'] := 0.02 {kmol/s};
545	FOR i IN [1..ntrays] DO
546	fl1.cmo_ratio[i] := 1;
547	fl1.tray_P[i] := 1 {atm};
548	fl1.tray_T[i] := 365 {K};
549	fl1.Qin[i] := 0 {kW};
550	fl1.Vol[i] := 3 {m^3};
551	fl1.vol_liq[i] := 1 {m^3};
552	END FOR;
553	END values;
554
555	END test_tray_stack;
556
557	MODEL test_column() REFINES testflashmodel();
558
559	cd IS_A components_data(['n_pentane','n_hexane','n_heptane'],'n_heptane');
560	pdV IS_A phases_data('V', 'Pitzer_vapor_mixture', 'none', 'none');
561	pdL IS_A phases_data('L', 'none', 'UNIFAC_liquid_mixture', 'none');
562	equilibrated IS_A boolean;
563	vap_dist IS_A stream(cd,pdV,equilibrated);
564	liq_dist IS_A stream(cd,pdL,equilibrated);
565	liq_bot IS_A stream(cd,pdL,equilibrated);
566	vap_bot IS_A stream(cd,pdV,equilibrated);
567	feed IS_A stream(cd,pdL,equilibrated);
568	below IS_A integer_constant;
569	below :==5;
570	above IS_A integer_constant;
571	above :==5;
572	t IS_A time;
573	dynamic IS_A boolean;
574	C_partial IS_A boolean;
575	R_partial IS_A boolean;
576	ode_offset IS_A ode_counter;
577	obs_offset IS_A obs_counter;
578	col IS_A column(vap_dist,liq_dist,C_partial,above,feed,below,R_partial,
579	vap_bot,liq_bot,t,dynamic,ode_offset,obs_offset);
580
581	(* boundwidth might be unit specific *)
582	boundwidth IS_A bound_width;
583
584	METHODS
585
586	METHOD default_all;
587	RUN default_self;
588	END default_all;
589
590	METHOD default_self;
591	boundwidth := 10;
592	equilibrated :=FALSE;
593	ode_offset :=1;
594	obs_offset :=1;
595	RUN vap_dist.default_self;
596	RUN liq_dist.default_self;
597	RUN feed.default_self;
598	RUN vap_bot.default_self;
599	RUN liq_bot.default_self;
600	RUN col.default_self;
601	END default_self;
602
603	METHOD check_all;
604	RUN check_self;
605	END check_all;
606
607	METHOD check_self;
608	IF C_partial THEN
609	RUN vap_dist.check_self;
610	ELSE
611	RUN liq_dist.check_self;
612	END IF;
613	RUN feed.check_self;
614	IF R_partial THEN
615	RUN liq_bot.check_self;
616	ELSE
617	RUN vap_bot.check_self;
618	END IF;
619	RUN col.check_self;
620	END check_self;
621
622	METHOD bound_all;
623	RUN bound_self;
624	END bound_all;
625
626	METHOD bound_self;
627	vap_dist.boundwidth := boundwidth;
628	liq_dist.boundwidth := boundwidth;
629	feed.boundwidth := boundwidth;
630	liq_bot.boundwidth := boundwidth;
631	vap_bot.boundwidth := boundwidth;
632	RUN col.bound_all;
633	END bound_self;
634
635	METHOD scale_self;
636	RUN vap_dist.scale_self;
637	RUN liq_dist.scale_self;
638	RUN feed.scale_self;
639	RUN vap_bot.scale_self;
640	RUN liq_bot.scale_self;
641	RUN col.scale_self;
642	END scale_self;
643
644	METHOD scale_all;
645	RUN scale_self;
646	END scale_all;
647
648	METHOD specify;
649	RUN col.specify;
650	END specify;
651
652	METHOD values;
653	feed.P := 1 {atm};
654	feed.T := 365 {K};
655	feed.f['n_pentane'] := 0.01 {kmol/s};
656	feed.f['n_hexane'] := 0.01 {kmol/s};
657	feed.f['n_heptane'] := 0.01 {kmol/s};
658	vap_dist.flow :=0 {mol/s};
659	vap_bot.flow :=0 {mol/s};
660	col.condenser.Vol :=3 {m^3};
661	col.condenser.vol_liq :=1 {m^3};
662	col.reflux_ratio :=1.5;
663	col.feed_tray.Vol :=1 {m^3};
664	col.feed_tray.vol_liq :=0.3 {m^3};
665	col.feed_tray.q :=1;
666	col.top_stack.Vol[1..above] :=1 {m^3};
667	col.top_stack.vol_liq[1..above] :=0.3 {m^3};
668	col.bottom_stack.Vol[1..above] :=1 {m^3};
669	col.bottom_stack.vol_liq[1..above] :=0.3 {m^3};
670	col.reboiler.Vol :=3 {m^3};
671	col.reboiler.vol_liq :=1 {m^3};
672	col.reboil_ratio :=2;
673	END values;
674
675	END test_column;