Changeset 909 for branches


Ignore:
Timestamp:
Feb 19, 2010, 7:08:11 PM (13 years ago)
Author:
Argimiro Resende Secchi
Message:

Starting checking new EML.

Location:
branches/gui
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/gui/eml/controllers/PIDIncr.mso

    r684 r909  
    3737       
    3838        PID_Select      as Switcher     (Brief="Type of PID Incremental", Valid=["Ideal","Parallel","Series","Ideal_AWBT","Parallel_AWBT","Series_AWBT","Ideal_AW","Parallel_AW","Series_AW"], Default = "Ideal");
    39         Action                          as Switcher     (Brief="Controller action", Valid=["Direct","Reverse"], Default = "Reverse");
    40         Mode                    as Switcher     (Brief="Controller mode", Valid=["Automatic","Manual"], Default = "Automatic");
    41         Clip                            as Switcher     (Brief="Controller mode", Valid=["Clipped","Unclipped"], Default = "Clipped");
    42        
    43         alpha                   as positive                             (Brief="Derivative term filter constant", Default=1);
    44         beta                    as positive                             (Brief="Proportional term setPoint change filter");
    45         bias                    as control_signal       (Brief="Previous scaled bias", Default=0.5);
    46         derivTime       as time_sec                     (Brief="Derivative time constant");
    47         intTime         as time_sec                     (Brief="Integral time constant");
    48         gain                    as positive                             (Brief="Controller gain", Default=0.5);
    49         gamma           as positive                             (Brief="Derivative term SP change filter");
    50         tau                     as time_sec                     (Brief="Input filter time constant");
    51         tauSet          as time_sec                     (Brief="Input filter time constant");
    52         MinInput                as control_signal       (Default=-1000);
     39        Action          as Switcher     (Brief="Controller action", Valid=["Direct","Reverse"], Default = "Reverse");
     40        Mode            as Switcher     (Brief="Controller mode", Valid=["Automatic","Manual"], Default = "Automatic");
     41        Clip            as Switcher     (Brief="Controller mode", Valid=["Clipped","Unclipped"], Default = "Clipped");
     42       
     43        alpha           as positive             (Brief="Derivative term filter constant", Default=1);
     44        beta            as positive             (Brief="Proportional term setPoint change filter");
     45        bias            as control_signal       (Brief="Previous scaled bias", Default=0.5);
     46        derivTime       as time_sec             (Brief="Derivative time constant");
     47        intTime         as time_sec             (Brief="Integral time constant");
     48        gain            as positive             (Brief="Controller gain", Default=0.5);
     49        gamma           as positive             (Brief="Derivative term SP change filter");
     50        tau             as time_sec             (Brief="Input filter time constant");
     51        tauSet          as time_sec             (Brief="Input filter time constant");
     52        MinInput        as control_signal       (Default=0);
    5353        MaxInput        as control_signal       (Default=1000);
    54         MinOutput       as control_signal       (Default=-1000);
    55         MaxOutput       as control_signal       (Default=1000);
     54        MinOutput       as control_signal       (Default=0);
     55        MaxOutput       as control_signal       (Default=1);
    5656
    5757VARIABLES
    5858
    59 in              Input           as control_signal       (Protected=true, PosX=0, PosY=0.5);
    60 out     Output  as control_signal       (Protected=true, PosX=0.54, PosY=1);
    61         SetPoint                as control_signal;
     59in      Input           as control_signal       (Protected=true, PosX=0, PosY=0.5);
     60out     Output          as control_signal       (Protected=true, PosX=0.54, PosY=1);
     61        SetPoint        as control_signal;
    6262       
    6363#++++++++++++++++++++ PID Internal Variables ++++++++++++++++++++++++++++++++
    6464        PID_dderivTerm          as control_signal       (Brief="Derivative term",Unit='1/s', Default=0, Hidden=true);
    65         PID_dFilt                       as control_signal       (Brief="Derivative term filtered", Default=0.5,Unit='1/s', Hidden=true);
    66         PID_error                       as control_signal       (Brief="Error definition for proportional term",Unit='1/s', Hidden=true);
    67         PID_errorD                      as control_signal       (Brief="Error definition for derivative term",Unit='1/s', Hidden=true);
    68         PID_errorI                      as control_signal       (Brief="Error definition for integral term", Hidden=true);
    69         PID_inputFilt                   as control_signal       (Brief="Filtered input", Hidden=true);
     65        PID_dFilt               as control_signal       (Brief="Derivative term filtered", Default=0.5,Unit='1/s', Hidden=true);
     66        PID_error               as control_signal       (Brief="Error definition for proportional term",Unit='1/s', Hidden=true);
     67        PID_errorD              as control_signal       (Brief="Error definition for derivative term",Unit='1/s', Hidden=true);
     68        PID_errorI              as control_signal       (Brief="Error definition for integral term", Hidden=true);
     69        PID_inputFilt           as control_signal       (Brief="Filtered input", Hidden=true);
    7070        PID_dintTerm            as control_signal       (Brief="Integral term", Default=0,Unit='1/s', Hidden=true);
    71         PID_doutp                       as control_signal       (Brief="Sum of proportional, integral and derivative terms",Unit='1/s', Hidden=true);
    72         PID_outps                       as control_signal       (Brief="Variable outp scaled between -1 and 1", Hidden=true);
    73         PID_outp                        as control_signal       (Brief="Variable outp", Hidden=true);
     71        PID_doutp               as control_signal       (Brief="Sum of proportional, integral and derivative terms",Unit='1/s', Hidden=true);
     72        PID_outps               as control_signal       (Brief="Variable outp scaled between -1 and 1", Hidden=true, Default=0.5);
     73        PID_outp                as control_signal       (Brief="Variable outp", Hidden=true);
    7474        PID_dpropTerm           as control_signal       (Brief="Proportional term", Default=0,Unit='1/s', Hidden=true);
    7575        PID_setPointFilt        as control_signal       (Brief="Filtered setPoint", Default=0, Hidden=true);
    76         PID_input                       as control_signal       (Brief="Previous scaled input signal", Default=0.5, Hidden=true);
    77         PID_output                      as control_signal       (Brief="Scaled output signal", Default=0.5, Hidden=true);
     76        PID_input               as control_signal       (Brief="Previous scaled input signal", Default=0.5, Hidden=true);
     77        PID_output              as control_signal       (Brief="Scaled output signal", Default=0.5, Hidden=true);
    7878        PID_setPoint            as control_signal       (Brief="Scaled setPoint",Default=0.5, Hidden=true);
    79         PID_AWFactor            as Real                                 (Brief="Integral term multiplier used in anti-reset windup", Hidden=true);
    80         PID_action                      as Real                                 (Hidden=true);
     79        PID_AWFactor            as Real                         (Brief="Integral term multiplier used in anti-reset windup", Hidden=true);
     80        PID_action              as Real                         (Hidden=true);
    8181#++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++++++
    8282
     
    8787
    8888"Output "
    89         Output = PID_output*(MaxOutput-MinOutput) +MinOutput;
     89        Output = PID_output*(MaxOutput - MinOutput) + MinOutput;
    9090       
    9191"Set Point "
    9292        PID_setPoint*(MaxInput - MinInput) = SetPoint - MinInput;
    9393
    94         if (tau < 1e-6) then
     94        if (tau < 1e-3*'s') then
    9595                "Input first order filter"
    9696                (tau + 1e-3*'s')*diff(PID_inputFilt)= PID_input - PID_inputFilt;
     
    100100        end
    101101
    102         if (tauSet < 1e-6) then
     102        if (tauSet < 1e-3*'s') then
    103103                "setPoint first order filter"
    104104                (tauSet + 1e-3*'s')*diff(PID_setPointFilt)= PID_setPoint - PID_setPointFilt;
     
    128128        PID_dpropTerm=PID_error; 
    129129       
    130         if (derivTime equal 0) then
     130        if (derivTime < 1e-3*'s') then
    131131                "Derivative term filter"       
    132132                alpha*(derivTime + 1e-3*'s')*diff(PID_dFilt) = PID_errorD - PID_dFilt;
     
    147147        switch Clip
    148148        case "Clipped":
    149                 #if abs(PID_outps)>1 then
    150                 #       "Calculate clipped output when it's saturated"
    151                 #       Ports.output=(sign(PID_outps)*1+1)/2;
    152                 #else
    153                 #       "Calculate clipped output when it's not saturated"
    154                 #       Ports.output=PID_outps;
    155                 #end
    156                 PID_output = max([0, PID_outp]);
     149                if abs(PID_outps)>1 then
     150                        "Calculate clipped output when saturated"
     151                        PID_output=(sign(PID_outps)+1)/2;
     152                else
     153                        "Calculate clipped output when not saturated"
     154                        PID_output=PID_outp;
     155                end
     156                #PID_output = max([0, PID_outp]);
    157157        case "Unclipped":
    158158                "Calculate unclipped output"
  • branches/gui/eml/controllers/PIDs.mso

    r771 r909  
    2828
    2929        PID_Select      as Switcher     (Brief="Type of PID Incremental", Valid=["Ideal","Parallel","Series","Ideal_AWBT","Parallel_AWBT","Series_AWBT","Ideal_AW","Parallel_AW","Series_AW"], Default = "Ideal");
    30         Action                          as Switcher     (Brief="Controller action", Valid=["Direct","Reverse"], Default = "Reverse");
    31         Mode                    as Switcher     (Brief="Controller mode", Valid=["Automatic","Manual"], Default = "Automatic");
    32         Clip                            as Switcher     (Brief="Controller mode", Valid=["Clipped","Unclipped"], Default = "Clipped");
    33 
    34         alpha                   as positive                             (Brief="Derivative term filter constant", Default=1);
    35         beta                    as positive                             (Brief="Proportional term setPoint change filter");
    36         bias                    as control_signal       (Brief="Previous scaled bias", Default=0.5);
    37         derivTime       as time_sec                     (Brief="Derivative time constant");
    38         intTime         as time_sec                     (Brief="Integral time constant");
    39         gain                    as positive                             (Brief="Controller gain", Default=0.5);
    40         gamma           as positive                             (Brief="Derivative term SP change filter");
    41         tau                     as time_sec                     (Brief="Input filter time constant");
    42         tauSet          as time_sec                     (Brief="Input filter time constant");
    43         MinInput                as control_signal       (Default=-1000);
     30        Action          as Switcher     (Brief="Controller action", Valid=["Direct","Reverse"], Default = "Reverse");
     31        Mode            as Switcher     (Brief="Controller mode", Valid=["Automatic","Manual"], Default = "Automatic");
     32        Clip            as Switcher     (Brief="Controller mode", Valid=["Clipped","Unclipped"], Default = "Clipped");
     33
     34        alpha           as positive             (Brief="Derivative term filter constant", Default=1);
     35        beta            as positive             (Brief="Proportional term setPoint change filter");
     36        bias            as control_signal       (Brief="Previous scaled bias", Default=0.5);
     37        derivTime       as time_sec             (Brief="Derivative time constant");
     38        intTime         as time_sec             (Brief="Integral time constant");
     39        gain            as positive             (Brief="Controller gain", Default=0.5);
     40        gamma           as positive             (Brief="Derivative term SP change filter");
     41        tau             as time_sec             (Brief="Input filter time constant");
     42        tauSet          as time_sec             (Brief="Input filter time constant");
     43        MinInput        as control_signal       (Default=0);
    4444        MaxInput        as control_signal       (Default=1000);
    45         MinOutput       as control_signal       (Default=-1000);
    46         MaxOutput       as control_signal       (Default=1000);
    47        
     45        MinOutput       as control_signal       (Default=0);
     46        MaxOutput       as control_signal       (Default=1);
     47
    4848VARIABLES
    49 in              Input           as control_signal       (Protected=true, PosX=0, PosY=0.5);
    50 out     Output  as control_signal       (Protected=true, PosX=0.54, PosY=1);
    51         SetPoint                as control_signal;
     49in      Input           as control_signal       (Protected=true, PosX=0, PosY=0.5);
     50out     Output          as control_signal       (Protected=true, PosX=0.54, PosY=1);
     51        SetPoint        as control_signal;
    5252
    5353#++++++++++++++++++++ PID Internal Variables ++++++++++++++++++++++++++++++++
    5454        PID_derivTerm   as control_signal       (Brief="Derivative term", Hidden =true , Default=0);
    55         PID_dFilt               as control_signal       (Brief="Derivative term filtered", Hidden =true ,Default=0.5);
    56         PID_error               as control_signal       (Brief="Error definition for proportional term",Hidden =true );
     55        PID_dFilt       as control_signal       (Brief="Derivative term filtered", Hidden =true ,Default=0.5);
     56        PID_error       as control_signal       (Brief="Error definition for proportional term",Hidden =true );
    5757        PID_errorD      as control_signal       (Brief="Error definition for derivative term", Hidden =true );
    58         PID_errorI              as control_signal       (Brief="Error definition for integral term", Hidden =true);
    59         PID_inputFilt           as control_signal       (Brief="Filtered input", Hidden =true);
     58        PID_errorI      as control_signal       (Brief="Error definition for integral term", Hidden =true);
     59        PID_inputFilt   as control_signal       (Brief="Filtered input", Hidden =true);
    6060        PID_intTerm     as control_signal       (Brief="Integral term", Hidden =true , Default=0);
    61         PID_outp                as control_signal       (Brief="Sum of proportional, integral and derivative terms", Hidden =true );
    62         PID_outps               as control_signal       (Brief="Variable outp scaled between -1 and 1",Hidden =true);
     61        PID_outp        as control_signal       (Brief="Sum of proportional, integral and derivative terms", Hidden =true );
     62        PID_outps       as control_signal       (Brief="Variable outp scaled between -1 and 1",Hidden =true);
    6363        PID_propTerm    as control_signal       (Brief="Proportional term", Default=0 , Hidden =true );
    64         PID_setPointFilt  as control_signal     (Brief="Filtered setPoint", Default=0, Hidden =true);
    65         PID_AWFactor    as Real                                 (Brief="Integral term multiplier used in anti-reset windup", Hidden=true);
    66         PID_action              as Real                                 (Protected=true, Hidden=true);
     64        PID_setPointFilt  as control_signal (Brief="Filtered setPoint", Default=0, Hidden =true);
     65        PID_AWFactor    as Real                 (Brief="Integral term multiplier used in anti-reset windup", Hidden=true);
     66        PID_action      as Real                         (Protected=true, Hidden=true);
    6767       
    6868        PID_input       as control_signal       (Brief="Previous scaled input signal", Default=0.5, Hidden=true);
    6969        PID_output      as control_signal       (Brief="Scaled output signal", Default=0.5, Hidden=true);
    70         PID_setPoint   as control_signal        (Brief="Scaled setPoint",Default=0.5, Hidden=true);
     70        PID_setPoint    as control_signal       (Brief="Scaled setPoint",Default=0.5, Hidden=true);
    7171#++++++++++++++++++++++++++++++++++++++++++++++++++++
    7272
     
    7777
    7878"Output "
    79         Output = PID_output*(MaxOutput-MinOutput) +MinOutput;
     79        Output = PID_output*(MaxOutput - MinOutput) + MinOutput;
    8080       
    8181"Set Point "
     
    9494        EQUATIONS
    9595
    96         if (tau equal 0) then
     96        if (tau < 1e-3*'s') then
    9797                "Input first order filter"
    9898                (tau + 1e-3*'s')*diff(PID_inputFilt)= PID_input - PID_inputFilt;
     
    102102        end
    103103
    104         if (tauSet equal 0) then
     104        if (tauSet < 1e-3*'s') then
    105105                "setPoint first order filter"
    106106                (tauSet + 1e-3*'s')*diff(PID_setPointFilt)= PID_setPoint - PID_setPointFilt;
     
    130130        PID_propTerm=PID_error;
    131131       
    132         if (derivTime equal 0) then
     132        if (derivTime < 1e-3*'s') then
    133133                "Derivative term filter"       
    134134                alpha*(derivTime + 1e-3*'s')*diff(PID_dFilt) = PID_errorD - PID_dFilt;
     
    147147        case "Clipped":
    148148                if abs(PID_outps)>1 then
    149                         "Calculate clipped output when it´s saturated"
    150                         PID_output=(sign(PID_outps)*1+1)/2;
     149                        "Calculate clipped output when saturated"
     150                        PID_output=(sign(PID_outps)+1)/2;
    151151                else
    152                         "Calculate clipped output when it´s not saturated"
     152                        "Calculate clipped output when not saturated"
    153153                        PID_output=PID_outp;
    154154                end
  • branches/gui/eml/pressure_changers/valve.mso

    r808 r909  
    9090                (1-Inlet.v)*PP.LiquidVolume((Inlet.T+Outlet.T)/2, (Inlet.P+Outlet.P)/2, Outlet.z);
    9191
    92         if Pdrop > 0 then
     92        if Pdrop > 0 * 'atm' then
    9393                "Flow"
    9494                Outlet.F * v = k*x*sqrt(Pdrop * rho_ref / rho ) ;
     
    242242        case "Liquid-Only":
    243243       
    244 if Pdrop > 0 then
     244if Pdrop > 0 * 'atm' then
    245245
    246246"Valve Equation - Liquid Flow"
     
    270270        case "Vapour-Only":
    271271       
    272 if Pdrop > 0 then #Update for gas flow !!!!
     272if Pdrop > 0 * 'atm' then #Update for gas flow !!!!
    273273       
    274274"Liquid-gas Coefficient Ratio"
  • branches/gui/sample/controllers/CSTR_noniso_pid.mso

    r735 r909  
    1818* Author: Argimiro R. Secchi
    1919* $Id$
    20 *--------------------------------------------------------------------#
     20*--------------------------------------------------------------------*#
    2121
    2222using "controllers/PIDs";
     
    113113 
    114114        VARIABLES
    115         L_ad as Real;
    116         Lmin as length;
    117         Lmax as length;
    118         T_ad as Real;
    119         Tmin as temperature;
    120         Tmax as temperature;
    121115        Lsp as length;
    122116        Tsp as temperature;
    123        
     117out     LI as control_signal (Brief="Level Indicator");
     118out     TI as control_signal (Brief="Temperature Indicator");
     119
    124120        CONNECTIONS
    125121        FEED to CSTR1.Inlet;
     122        LI to PIDL.Input;
     123        TI to PIDT.Input;
    126124       
    127125        SET
     
    140138        PIDT.PID_Select = "Ideal_AWBT";
    141139       
     140#   Level control: PID parameters
     141        PIDL.bias=0;
     142        PIDL.alpha=0.1;
     143        PIDL.Action="Direct";
     144        PIDL.gamma=1;
     145        PIDL.beta=1;
     146        PIDL.Clip="Clipped";
     147        PIDL.Mode="Automatic";
     148        PIDL.gain=1;
     149        PIDL.intTime=2.5*'h';
     150        PIDL.derivTime=0*'s';
     151        PIDL.tau=1*'s';
     152        PIDL.tauSet=1*'s';
     153
     154#   Temperature control: PID parameters
     155        PIDT.bias = 0;
     156        PIDT.alpha=0.1;
     157        PIDT.Action="Reverse";
     158        PIDT.gamma=1;
     159        PIDT.beta=1;
     160        PIDT.Clip="Clipped";
     161        PIDT.Mode="Automatic";
     162        PIDT.gain=1;
     163        PIDT.intTime=2.5*'h';
     164        PIDT.derivTime=1*'h';
     165        PIDT.tau=1*'s';
     166        PIDT.tauSet=1*'s';     
     167       
     168#       Operating range for control variables
     169        PIDL.MaxInput=5;
     170        PIDL.MinInput=0;
     171        PIDT.MaxInput=700;
     172        PIDT.MinInput=230;     
     173        PIDT.MaxOutput=700;
     174        PIDT.MinOutput=230;     
     175
    142176        EQUATIONS
    143177
    144         "Dimensionless level to connect PID"
    145         L_ad*(Lmax-Lmin)=CSTR1.h-Lmin;
    146         PIDL.Ports.input=L_ad;
    147 
    148         "Dimensionless temperature to connect PID"
    149         T_ad*(Tmax-Tmin)=CSTR1.T-Tmin;
    150         PIDT.Ports.input=T_ad;
    151        
     178        "Level sensor"
     179        LI * 'm' = CSTR1.h;
     180
     181        "Temperature sensor"
     182        TI * 'K' = CSTR1.T;
     183
     184        "Setpoints"
     185        PIDL.SetPoint * 'm' = Lsp;
     186        PIDT.SetPoint * 'K' = Tsp;
     187
    152188        "Manipulated Variables"
    153         CSTR1.x  = PIDL.Ports.output;
    154         CSTR1.Tw  = PIDT.Ports.output*(Tmax-Tmin)+Tmin;
    155        
    156 #   Level control: PID parameters
    157         PIDL.Parameters.bias=0;
    158         PIDL.Parameters.alpha=0.1;
    159         PIDL.Options.action=-1;
    160         PIDL.Parameters.gamma=1;
    161         PIDL.Parameters.beta=1;
    162         PIDL.Options.clip=1;
    163         PIDL.Options.autoMan=0;
    164         PIDL.Parameters.gain=1;
    165         PIDL.Parameters.intTime=2.5*'h';
    166         PIDL.Parameters.derivTime=0*'s';
    167         PIDL.Ports.setPoint=(Lsp - Lmin)/(Lmax - Lmin);
    168         PIDL.Parameters.tau=1*'s';
    169         PIDL.Parameters.tauSet=1*'s';
    170 
    171 #   Temperature control: PID parameters
    172         PIDT.Parameters.bias = 0;
    173         PIDT.Parameters.alpha=0.1;
    174         PIDT.Options.action=1;
    175         PIDT.Parameters.gamma=1;
    176         PIDT.Parameters.beta=1;
    177         PIDT.Options.clip=1;
    178         PIDT.Options.autoMan=0;
    179         PIDT.Parameters.gain=1;
    180         PIDT.Parameters.intTime=2.5*'h';
    181         PIDT.Parameters.derivTime=1*'h';
    182         PIDT.Ports.setPoint=(Tsp - Tmin)/(Tmax - Tmin);
    183         PIDT.Parameters.tau=1*'s';
    184         PIDT.Parameters.tauSet=1*'s';   
    185        
    186         "Operating range for control variables"
    187         Lmax=5*'m';
    188         Lmin=0*'m';
    189         Tmax=700*'K';
    190         Tmin=230*'K';   
     189        CSTR1.x = PIDL.Output;
     190        CSTR1.Tw = PIDT.Output * 'K';
    191191
    192192        "Feed Stream"
  • branches/gui/sample/controllers/Sample_flash_pid.mso

    r735 r909  
    2222* Author: Rafael de Pelegrini Soares
    2323* $Id$
    24 *------------------------------------------------------------------#
     24*------------------------------------------------------------------*#
    2525
    2626using "stage_separators/flash";
     27using "pressure_changers/valve.mso";
    2728using "controllers/PIDIncr";
    2829
     
    3536                VapourModel = "PR");
    3637        NComp   as Integer;
    37         #Maximum and minimum vapor and liquid flow rates
    38         FVMin as flow_mol;
    39         FVMax as flow_mol;
    40         FLMax as flow_mol;
    41         FLMin as flow_mol;
    42         #Maximum and minimum pressure
    43         PMin as pressure;
    44         PMax as pressure;
    45         #Maximum and minimum level
    46         LMax as length;
    47         LMin as length;
    4838
    4939        VARIABLES
    50         L_ad as Real (Brief="Dimensionless level");
    51         P_ad as Real (Brief="Dimensionless pressure");
    5240        Q       as energy_source (Brief="Heat supplied");
    5341       
     
    5745        fl as flash;
    5846        s1 as source;
    59        
     47        valve_top as valve_flow;
     48        valve_bot as valve_flow;
     49
    6050        SET
    6151        NComp = PP.NumberOfComponents;
     
    6555       
    6656        #Flash model parameters
    67         fl.V = 10 * 'm^3';
    68         fl.diameter = 0.5 * 'm';
    69         fl.orientation = "vertical";
     57        fl.Geometry.Lenght = 10 * 'm';
     58        fl.Geometry.Diameter = 1 * 'm';
     59        fl.Geometry.Orientation = "vertical";
    7060       
    7161        #Maximum and minimum values
    72         PMax=2.36 *'atm';
    73         PMin=0 *'atm';
    74         LMax=2 *'m';
    75         LMin=0 *'m';
    76         FVMax=300*'kmol/h';
    77         FVMin=0*'kmol/h';
    78         FLMax=692.7*'kmol/h';
    79         FLMin=0*'kmol/h';
     62        pidP.MaxInput=2.36;
     63        pidP.MinInput=0;
     64        pidL.MaxInput=2;
     65        pidL.MinInput=0;
     66        valve_top.MaxFlow=300*'kmol/h';
     67        valve_top.MinFlow=0*'kmol/h';
     68        valve_bot.MaxFlow=692.7*'kmol/h';
     69        valve_bot.MinFlow=0*'kmol/h';
    8070
    8171        CONNECTIONS
    8272        s1.Outlet to fl.Inlet;
    8373        Q.OutletQ to fl.InletQ;
     74        fl.OutletLiquid to valve_bot.Inlet;
     75        fl.OutletVapour to valve_top.Inlet;
     76        fl.LI to pidL.Input;
     77        fl.PI to pidP.Input;
     78        pidP.Output to valve_top.FlowFraction;
     79        pidL.Output to valve_bot.FlowFraction;
    8480
    8581        SET
     
    108104        pidP.beta =1;
    109105        pidP.gamma =1;
    110         #Pressure controller configuration
    111106        pidP.Mode = "Automatic";               
    112107        pidP.Clip = "Clipped";
    113108        pidP.Action = "Direct";
     109
     110        #Initial conditions
     111        fl.Levelpercent_Initial = 0.5;
     112        fl.Temperature_Initial = 340 * 'K';
     113        fl.Composition_Initial = [0.1, 0.1, 0.8];
    114114
    115115        SPECIFY
     
    118118
    119119        #Level controller parameters
    120         pidL.Ports.setPoint=0.5;
    121 
     120        pidL.SetPoint=0.5;
    122121
    123122        EQUATIONS
     
    134133                s1.F = 450 * 'kmol/h';
    135134        end
    136 
    137         #Control variables: fl.Level and fl.OutletV.P
    138         #Normalized control variables
    139         L_ad*(LMax-LMin)=fl.Level-LMin;
    140         P_ad*(PMax-PMin)=fl.OutletV.P-PMin;
    141        
    142         #Controllers input ports
    143         pidL.Ports.input=L_ad;
    144         pidP.Ports.input=P_ad; 
    145135       
    146136        #Setpoint change
    147137        if time < 2*'h' then
    148                 pidP.Ports.setPoint=0.501822;
     138                pidP.SetPoint=1;
    149139        else
    150                 pidP.Ports.setPoint=0.8474576;
     140                pidP.SetPoint=2;
    151141        end     
    152142       
    153         #Controllers output ports
    154         #Manipulated variables: fl.OutletV.F (pressure control) and fl.OutletL.F (level control)
    155         fl.OutletV.F = pidP.Ports.output*(FVMax-FVMin)+FVMin;
    156         fl.OutletL.F = pidL.Ports.output*(FLMax-FLMin)+FLMin;
    157 
    158         INITIAL
    159         fl.OutletL.T = 340 *'K';
    160         fl.Level = 1* 'm';
    161         fl.OutletL.z(1) = 0.1;
    162         fl.OutletL.z(2) = 0.1;
    163 
    164143        OPTIONS
    165144        TimeStep = 0.02;
  • branches/gui/sample/stage_separators/sample_flash.mso

    r796 r909  
    44
    55using "pressure_changers/valve";
    6 using "streams";
    76using "controllers/PIDs";
    87using "stage_separators/flash";
     
    173172
    174173        SET
    175         F101.Orientation = "vertical";
    176         F101.Heads = "hemispherical";
    177         F101.Diameter = 2 * 'm';
    178         F101.Lenght = 5 * 'm';
     174        F101.Geometry.Orientation = "vertical";
     175        F101.Geometry.Heads = "hemispherical";
     176        F101.Geometry.Diameter = 2 * 'm';
     177        F101.Geometry.Lenght = 5 * 'm';
    179178        F101.Levelpercent_Initial = 0.80;
    180179        F101.Temperature_Initial = 373 * 'K';
Note: See TracChangeset for help on using the changeset viewer.