$Title Global Optimization Model for the Design of Integrated Process Water

Networks

$Ontext
The objective of this model is to minimize the total cost of the integrated
process water networks consist of water using and water treatment operations

Further details can be found in Ahmetovic, E., Grossmann, I. E. (2010).

Global superstructure optimization for the design of integrated process water
networks.AIChE J.(In press).

$Offtext

$OFFSYMXREF
$OFFSYMLIST

Set p Process units (PU) /p1*p10/

d_p(p) Subset of PU /p1*p2/;

Set t Treatment units (TU) /t1*t10/

d_t(t) Subset of TU /t1*t2/;

Set s Sources of water /s1*s10/

d_s(s) Subset of Sources of water /s1/ ;

Set j Contaminants /A*K/

d_j(j) Subset of Contaminants /A,B/;

Alias (p,pp);
Alias (t,tt);
Alias (d_p,d_pp);
Alias (d_t,d_tt);
Alias (d_s,d_ss);

Scalar Recycle_PU 'Recycle around PU (if yes then 1)(if not then 0) ' /0/;
Scalar Recycle_TU 'Recycle around TU (if yes then 1) (if not then 0)' /0/;

Scalar N_max_streams Total number of streams in pipenetwork /20/;

Parameter FWWin(s) 'Flowrate of wastewater at SI inlets [ton/h]'

*Input data when you would like to optimize only wastewater treatment network
$ONEMPTY
/ /;

Parameter CFW(s) 'Costs of different sources of water [$/t]' /s1 1/;

Table xWin(s,j) 'Concentration of contaminants in fresh water at inital splitter

inlets [ppm]'
A B
s1 0 0;

Parameter FPUin(p) 'Flowrate of water at PU inlets [ton/h]'

/p1 40
p2 50/;

Table xPUin_max(p,j) 'Max. contaminant concentrations at PU inlets [ppm]'

A B
 p1 0 0
p2 50 50;

Table LPU(p,j) 'Discharge load of contaminants A and B in PU [kg/h]'

A B
p1 1 1.5
p2 1 1;

Parameter xout_max(j) 'Max. contaminant concentration in discharge stream into

environment [ppm]'
/A 10
B 10 /;

Table Removalratio(t,j) 'Removal ratio of contaminants in TU [%]'

A B
t1 95 0
t2 0 95;

Parameter betaTU(d_t,d_j) 'coefficient = 1-(removalratio/100)';

betaTU(d_t,d_j) = (1-(removalratio(d_t,d_j)/100));

Parameter IC(t) 'Investment cost coeff. for treatment units' /t1 16800,
t2 12600/;

Parameter OC(t) 'Operating cost coeff. for treatment units' /t1 1,

t2 0.0067/;

Parameter exp(t)'Cost function exponent for treatment units' /t1 0.7

t2 0.7/;

Scalar hours 'Hours of operation of plant per annum (h)' /8000/

Scalar AR 'Annualized factor for investment on TU' /0.1/;

Parameter IPT (t) Investment cost coefficient for pipe (t) /t1 100
t2 100/;

Parameter IPP (p) Investment cost coefficient for pipe (p) /p1 100
p2 100/;

Parameter IPF (s) Investment cost coefficient for pipe (p) /s1 100/;

Parameter CPT (t) Cost coefficient corresponding to existence of pipe (t) [$]
/t1 6
t2 6/;

Parameter CPP (p) Cost coefficient corresponding to existence of pipe (p) [$]
/p1 6
p2 6/;

Parameter CPF (s) Cost coefficient corresponding to existence of pipe (p) [$]
/s1 6/;

Parameter expT(t) Cost function exponent for the investment cost of pipe (t)
/t1 0.6,
t2 0.6/;

Parameter expP(p) Cost function exponent for the investment cost of pipe (p)
 /p1 0.6,
p2 0.6/;

Parameter expF(s) Cost function exponent for the investment cost of pipe (p)
/s1 0.6/;

Parameter PMP(p) Operating cost coefficient for pumping water through pipe (p)
/p1 0.006
p2 0.006/;

Parameter PMT(t) Operating cost coefficient for pumping water through pipe (t)
/t1 0.006
t2 0.006/;

Parameter PMF(s) Operating cost coefficient for pumping water through pipe (t)
/s1 0.006 /;

Binary variables
yFIP(s,p) 'if value of yFIP(p) is equal to 1 pipes (or streams FIP) exist
in the network'
yFIT(s,t) 'if value of yFIT(t) is equal to 1 pipes (or streams FIT) exist
in the network '
yFIF(d_s) 'if value of yFIF(t) is equal to 1 pipes (or streams FIF) exist
in the network '

yFP(pp,p) 'if value of yFP(pp,p) is equal to 1 pipes (or streams FP)

exist in the network'
yFPT(p,t) 'if value of yFPT(p,t) is equal to 1 pipes (or streams FPT)
exist in the network'
yFPO(p) 'if value of yFPO(p) is equal to 1 pipes (or streams FPO) exist
in the network'

yFTO(t) 'if value of yFTO(t) is equal to 1 pipes (or streams FTO) exist
in the network'
yFT(tt,t) 'if value of yFT(tt,t) is equal to 1 pipes (or streams FT)
exist in the network'
yFTP(t,p) 'if value of yFTP(t,p) is equal to 1 pipes (or streams FTP)
exist in the network';

Variables z Total cost for water network;

Positive variables
FW(s) flowrate of water streams going to initial spliter
FIP(s,p) flowrate of water streams from initial spliter going to MPU
FIT(s,t) flowrate of water streams from initial spliter going to
treatment units
FIF(s) flowrate of water streams from SI going to FM

FPUout(p) flowrate of water streams at outlet from PU

FP(pp,p) flowrate of water streams from SPU going to MPU

FP(p,pp) flowrate of water streams from SPU going to MPU
FPT(p,t) flowrate of water streams from SPU going to MTU
FPO(p) flowrate of water streams from SPU going to MF

FTP(t,p) flowrate of water streams from STU going to MPU

FT(tt,t) flowrate of water streams from STU going to MTU
FT(t,tt) flowrate of water streams from STU going to MTU
 FTO(t) flowrate of water streams from STU going to MF

FTUin(t) flowrate of water streams at inlet into treatment units

FTUout(t) flowrate of water streams at outlet from treatment units

Fout flowrate of water stream from final mixer

xPUin(p,j) concentration of contaminants in inlet streams in PU

xPUout(p,j) concentration of contaminants in outlet streams from PU

xTUin(t,j) concentration of contaminants in water streams at TU inlets

xTUout(t,j) concentration of contaminants in water streams at TU outlets

xSPUout(p,j) concentration of contaminants in water streams at SPU outlets

xSTUout(t,j) concentration of contaminants in water streams at STU outlets

xout concentration of contaminants in water streams at MF outlet

FWWtotal total flowrate of input wastewater at SI which need to be
treated in TU;

Equations
obj Total cost for water network

eq1IS (s) overal material balance of initial spliter (IS)

eq2MPU (p) mass balances of mixers in front of process units (MPU)

eq3MPU (p,j) mass balances of contaminants for mixers in front of process
units (MPU)
eq4PU (p) mass balances of proces units (PU)
eq5PU (p,j) mass balances of contaminants for process units (PU)

eq6SPU(p) mass balances of spliters behind process units (SPU)

eq7SPU(p,j) equality of contaminants concentrations at outlet PU i SPU

eq8MTU(t) mass balances of mixers in front of treatment units (MTU)

eq9MTU(t,j) mass balances of contaminants for mixers in front of
treatment units (TU)

eq10TU(t) mass balances of treatment units (TU)

eq11TU(t,j) dependence between treatment units inlet and outlet

concentrations

eq12STU(t) mass balances of splitters behind treatment units (TU)

eq13STU(t,j) equality concentrations at treatment units inlets and outlets

eq14MF mass balances of final mixer

eq15MF(j) mass balances of contaminants for final mixer

eq16RedEqu(j) contaminant flow balances for the overal system

eq17 design constraint for streams from spliter treatment units to mixer
process units
eq18 " "
eq19 design constraint for streams from spliter process units to mixer
process units
eq20 " "
eq21 design constraint for streams from spliter process units to mixer
process units
eq22 " "
eq23 design constraint for streams from spliter process units to mixer
treatment units
eq24 " "
eq25 design constraint for streams from spliter process units to final
mixer
eq26 " "
eq27 design constraint for streams from spliter treatment units to final
mixer
eq28 " "
eq29 design constraint for streams from spliter treatment units to mixer
treatment units
eq30 " "
eq31 " "
eq32 " "
eq33 design constraint for streams from initial spliter to mixer process
units
eq34 " "
eq35 design constraint for streams from initial spliter to mixer treatment
units
eq36 " "
eq37 design constraint for streams from initial spliter to final mixer
unit
eq38 " "
eq39 design constraint for maximum number of streams in the network;

eq1IS(d_s).. FW(d_s) =e=

sum(d_p, FIP(d_s,d_p) )
+ sum(d_t, FIT(d_s,d_t) )
+ FIF(d_s)$(card(d_p)=0)
;

eq2MPU(d_p).. FPUin(d_p) =e= sum(d_s, FIP(d_s,d_p) )

+ sum(d_pp$(ord(d_pp)<>ord(d_p) and (Recycle_PU =
0)),FP(d_pp,d_p))
+ sum(d_pp$(Recycle_PU = 1),FP(d_pp,d_p))
+ sum(d_t,FTP(d_t,d_p))
;

eq3MPU(d_p,d_j).. FPUin(d_p)*xPUin(d_p,d_j)=e=
sum(d_s, FIP(d_s,d_p)*xWin(d_s,d_j) )
+ sum(d_pp$(ord(d_pp)<>ord(d_p)and (Recycle_PU =
0)),FP(d_pp,d_p)*xPUout(d_pp,d_j))
+ sum(d_pp$(Recycle_PU = 1),FP(d_pp,d_p)*xPUout(d_pp,d_j))
+ sum(d_t,FTP(d_t,d_p)*xTUout(d_t,d_j))
;

eq4PU(d_p).. FPUin(d_p)=e= FPUout(d_p);

eq5PU(d_p,d_j).. FPUin(d_p)*xPUin(d_p,d_j)+LPU(d_p,d_j)*1e03 =e=

FPUout(d_p)*xPUout(d_p,d_j);

eq6SPU(d_p).. FPUout(d_p) =e= FPO(d_p)

+ sum(d_t,FPT(d_p,d_t))
+ sum(d_pp$(ord(d_pp)<>ord(d_p) and (Recycle_PU =
0)),FP(d_p,d_pp))
+ sum(d_pp$(Recycle_PU = 1),FP(d_p,d_pp))
 ;

eq7SPU(d_p,d_j).. xSPUout(d_p,d_j) =e= xPUout(d_p,d_j);

eq8MTU(d_t).. FTUin(d_t) =e=

sum(d_s, FIT(d_s,d_t) )
+ sum(d_tt$(ord(d_tt)<>ord(d_t) and
(Recycle_TU=0)),FT(d_tt,d_t))
+ sum(d_tt$(Recycle_TU=1),FT(d_tt,d_t))
+ sum(d_p,FPT(d_p,d_t))
;

eq9MTU(d_t,d_j).. FTUin(d_t)*xTUin(d_t,d_j) =e=

sum(d_s, FIT(d_s,d_t)*xWin(d_s,d_j) )
+ sum(d_tt$(ord(d_tt)<>ord(d_t) and
(Recycle_TU=0)),FT(d_tt,d_t)*xSTUout(d_tt,d_j))
+ sum(d_tt$(Recycle_TU=1),FT(d_tt,d_t)*xSTUout(d_tt,d_j))
+ sum(d_p,FPT(d_p,d_t)*xSPUout(d_p,d_j)) ;

eq10TU(d_t).. FTUin(d_t) =e= FTUout(d_t);

eq11TU(d_t,d_j).. xTUout(d_t,d_j)=e=betaTU(d_t,d_j)*xTUin(d_t,d_j);

eq12STU(d_t).. FTUout(d_t) =e= FTO(d_t)

+ sum(d_p,FTP(d_t,d_p))
+ sum(d_tt$(ord(d_tt)<>ord(d_t)and
(Recycle_TU=0)),FT(d_t,d_tt))
+ sum(d_tt$(Recycle_TU=1),FT(d_t,d_tt))
;

eq13STU(d_t,d_j).. xSTUout(d_t,d_j)=e=xTUout(d_t,d_j);

eq14MF.. Fout=e=
sum(d_p,FPO(d_p))
+ sum(d_t,FTO(d_t))
+ sum(d_s$(card(d_p)=0), FIF(d_s))
;

eq15MF(d_j).. Fout*xout(d_j)=e=
sum(d_p,FPO(d_p)*xSPUout(d_p,d_j))
+ sum(d_t,FTO(d_t)*xSTUout(d_t,d_j))
+ sum(d_s$(card(d_p)=0), FIF(d_s)*xWin(d_s,d_j))
;

eq16RedEqu(d_j).. sum(d_s, FW(d_s)*xWin(d_s,d_j) )

+ sum(d_p, LPU(d_p,d_j)*1e03)
=e=
sum(d_t,(1-betaTU(d_t,d_j))*(FTUin(d_t)*xTUin(d_t,d_j)))
+Fout*xout(d_j);

********************************************
*Design constraints relate the design variables
yFTP(t,p),yFP(pp,p),yFPT(p,t),yFPO(p),yFTO(t),yFT(tt,t)
*and variables of flowrates through the pipes in the network
*(these simply imply that if a pipe exists, the maximum flow in that pipe can take
the values between specified bounds
*while it does not exist the maximum flowrate goes to be zero)
*design constraint which relate the design variables (binary variables and
flowrates through pipes)
*streams from spliter treatment units to mixer process units
eq17(d_t,d_p).. FTP(d_t,d_p)=l=FTP.up(d_t,d_p)*yFTP(d_t,d_p);
eq18(d_t,d_p).. FTP.lo(d_t,d_p)*yFTP(d_t,d_p)=l=FTP(d_t,d_p);

*streams from spliter process units to mixer process units

eq19(d_pp,d_p)$(ord(d_pp)<>ord(d_p) and (Recycle_PU =
0))..FP(d_pp,d_p)=l=FP.up(d_pp,d_p)*yFP(d_pp,d_p);
eq20(d_pp,d_p)$(ord(d_pp)<>ord(d_p) and (Recycle_PU =
0))..FP.lo(d_pp,d_p)*yFP(d_pp,d_p)=l=FP(d_pp,d_p);

eq21(d_pp,d_p)$((Recycle_PU = 1))..FP(d_pp,d_p)=l=FP.up(d_pp,d_p)*yFP(d_pp,d_p);
eq22(d_pp,d_p)$((Recycle_PU = 1))..FP.lo(d_pp,d_p)*yFP(d_pp,d_p)=l=FP(d_pp,d_p);

*streams from spliter process units to mixer treatment units

eq23(d_p,d_t)..FPT(d_p,d_t)=l=FPT.up(d_p,d_t)*yFPT(d_p,d_t);
eq24(d_p,d_t)..FPT.lo(d_p,d_t)*yFPT(d_p,d_t)=l=FPT(d_p,d_t);

*streams from spliter process units to final mixer

eq25(d_p)..FPO(d_p)=l=FPO.up(d_p)*yFPO(d_p);
eq26(d_p)..FPO.lo(d_p)*yFPO(d_p)=l=FPO(d_p);

*streams from spliter treatment units to final mixer

eq27(d_t)..FTO(d_t)=l=FTO.up(d_t)*yFTO(d_t);
eq28(d_t)..FTO.lo(d_t)*yFTO(d_t)=l=FTO(d_t);

*streams from spliter treatment units to mixer treatment units

eq29(d_tt,d_t)$(ord(d_tt)<>ord(d_t) and (Recycle_TU =
0))..FT(d_tt,d_t)=l=FT.up(d_tt,d_t)*yFT(d_tt,d_t);
eq30(d_tt,d_t)$(ord(d_tt)<>ord(d_t) and (Recycle_TU =
0))..FT.lo(d_tt,d_t)*yFT(d_tt,d_t)=l=FT(d_tt,d_t);

eq31(d_tt,d_t)$((Recycle_TU = 1))..FT(d_tt,d_t)=l=FT.up(d_tt,d_t)*yFT(d_tt,d_t);
eq32(d_tt,d_t)$((Recycle_TU = 1))..FT.lo(d_tt,d_t)*yFT(d_tt,d_t)=l=FT(d_tt,d_t);

*streams from initial spliter to mixer process units

eq33(d_s,d_p)..FIP(d_s,d_p)=l=FIP.up(d_s,d_p)*yFIP(d_s,d_p);
eq34(d_s,d_p)..FIP.lo(d_s,d_p)*yFIP(d_s,d_p)=l=FIP(d_s,d_p);

*streams from initial spliter to mixer treatment units

eq35(d_s,d_t)..FIT(d_s,d_t)=l=FIT.up(d_s,d_t)*yFIT(d_s,d_t);
eq36(d_s,d_t)..FIT.lo(d_s,d_t)*yFIT(d_s,d_t)=l=FIT(d_s,d_t);

*streams from initial spliter to final mixer unit

eq37(d_s)$(card(d_p)=0)..FIF(d_s)=l=FIF.up(d_s)*yFIF(d_s);
eq38(d_s)$(card(d_p)=0)..FIF.lo(d_s)*yFIF(d_s)=l=FIF(d_s);

**Constraint for maximum number of streams in the network**

eq39.. ( sum((d_s,d_p),yFIP(d_s,d_p))
+ sum((d_s,d_t),yFIT(d_s,d_t))
+ sum((d_s)$(card(d_p)=0),yFIF(d_s))

+ sum((d_pp,d_p)$(ord(d_pp)<>ord(d_p) and (Recycle_PU = 0)),yFP(d_pp,d_p))

+ sum((d_pp,d_p)$((Recycle_PU = 1)),yFP(d_pp,d_p))

+ sum((d_p),yFPO(d_p))
+ sum((d_p,d_t),yFPT(d_p,d_t))
 + sum((d_tt,d_t)$(ord(d_tt)<>ord(d_t) and (Recycle_TU = 0)),yFT(d_tt,d_t))
+ sum((d_tt,d_t)$((Recycle_TU = 1)),yFT(d_tt,d_t))

+ sum((d_t),yFTO(d_t))
+ sum((d_t,d_p),yFTP(d_t,d_p))

) =l= N_max_streams;

*Variable bounds
******************Initial Splitter**********************
FW.up(d_s)$(card(d_p)<>0) = sum(d_p,FPUin(d_p));
FW.lo(d_s)$(card(d_p)<>0 and card(d_s)=1)
= smin(d_p,FPUin(d_p));

FWWtotal.fx$(card(d_p)=0) = sum(d_s,FWWin(d_s));
FW.fx(d_s)$(card(d_p)=0) = FWWin(d_s);

FIP.up(d_s,d_p) = FPUin(d_p);
FIT.up(d_s,d_t)$(card(d_p)<>0) = sum(d_p,FPUin(d_p));
FIT.up(d_s,d_t)$(card(d_p)=0) = FWWin(d_s);
FIF.up(d_s)$(card(d_p)=0) = FWWin(d_s);

******************Final Mixer***************************
Fout.lo$(card(d_p)<>0) = (smin(d_p,FPUin(d_p))) ;
Fout.lo$(card(d_p)=0) = (smin(d_s,FWWin(d_s)));
Fout.up$(card(d_p)<>0) = (sum(d_p,FPUin(d_p)));
Fout.up$(card(d_p)=0) = (sum(d_s,FWWin(d_s)));
xout.up(d_j) = xout_max(d_j);

loop((d_j), xout.up(d_j)$(card(d_t)=0)
= smax(d_p,(xPUin_max(d_p,d_j)*FPUin(d_p)+1e03*LPU(d_p,d_j))/
(FPUin(d_p))));

******************Process Units*************************
FPUout.fx(d_p) = FPUin(d_p);
xPUin.up(d_p,d_j) = xPUin_max(d_p,d_j);
xPUout.lo(d_p,d_j) = 1e03*LPU(d_p,d_j)/FPUin(d_p);
xPUout.up(d_p,d_j) = (xPUin_max(d_p,d_j)*FPUin(d_p)+1e03*LPU(d_p,d_j))/
(FPUin(d_p));

******************Splitter Process Units****************

FP.up(d_pp,d_p)$( FPUin(d_pp) <= FPUin(d_p) ) = FPUin(d_pp);
FP.up(d_pp,d_p)$( FPUin(d_pp) >= FPUin(d_p) ) = FPUin(d_p);

FPT.up(d_p,d_t) = FPUin(d_p);
FPO.up(d_p) = FPUin(d_p);
xSPUout.up(d_p,d_j) = xPUout.up(d_p,d_j) ;

******************Treatment Units***********************
FTUin.up(d_t)$(card(d_p)<>0) = sum(d_p,FPUin(d_p)) ;
FTUin.up(d_t)$(card(d_p)=0) = sum(d_s,FWWin(d_s)) ;

FTUout.up(d_t)$(card(d_p)<>0) = sum(d_p,FPUin(d_p));
FTUout.up(d_t)$(card(d_p)=0) = sum(d_s,FWWin(d_s)) ;

loop((d_t,d_j),
xTUin.up(d_t,d_j)$(card(d_p)<>0)
= smax(d_p,(xPUin_max(d_p,d_j)*FPUin(d_p)+1e03*LPU(d_p,d_j))/
 FPUin(d_p)));

xTUin.up(d_t,d_j)$(card(d_p)=0) =smax(d_s,xWin(d_s,d_j));

xTUout.up(d_t,d_j) = betaTU(d_t,d_j)*xTUin.up(d_t,d_j);

******************Splitter Treatment Units****************

FT.up(d_tt,d_t)$(card(d_p)<>0) = sum(d_p,FPUin(d_p));
FT.up(d_tt,d_t)$(card(d_p)=0) = sum(d_s,FWWin(d_s));
FTP.up(d_t,d_p) = FPUin(d_p);
FTO.up(d_t)$(card(d_p)<>0) = sum(d_p,FPUin(d_p));
FTO.up(d_t)$(card(d_p)=0) = sum(d_s,FWWin(d_s));

xSTUout.up(d_t,d_j) = xTUout.up(d_t,d_j);

obj..z=e=
hours*sum(d_s, FW(d_s)*CFW(d_s))

+ AR*sum(d_t,IC(d_t)*FTUout(d_t)**exp(d_t))

+ hours*sum(d_t,OC(d_t)*FTUout(d_t))

+ AR*(
sum((d_s,d_p),CPP(d_p)*yFIP(d_s,d_p)+IPP(d_p)*FIP(d_s,d_p)**expP(d_p))
+ sum((d_s,d_t),CPT(d_t)*yFIT(d_s,d_t)+IPT(d_t)*FIT(d_s,d_t)**expT(d_t))
+ sum((d_s)$(card(d_p)=0),CPF(d_s)*yFIF(d_s)+IPF(d_s)*FIF(d_s)**expF(d_s))

+ sum((d_pp,d_p)$(ord(d_pp)<>ord(d_p) and (Recycle_PU =

0)),CPP(d_pp)*yFP(d_pp,d_p)+IPP(d_pp)*FP(d_pp,d_p)**expP(d_pp))
+ sum((d_pp,d_p)$((Recycle_PU = 1)),CPP(d_pp)*yFP(d_pp,d_p)
+IPP(d_pp)*FP(d_pp,d_p)**expP(d_pp))
+ sum((d_p,d_t),CPP(d_p)*yFPT(d_p,d_t)+IPP(d_p)*FPT(d_p,d_t)**expP(d_p))
+ sum((d_p),CPP(d_p)*yFPO(d_p)+IPP(d_p)*FPO(d_p)**expP(d_p))

+ sum((d_t,d_p),CPT(d_t)*yFTP(d_t,d_p)+IPT(d_t)*FTP(d_t,d_p)**expT(d_t))
+ sum((d_t),CPT(d_t)*yFTO(d_t)+IPT(d_t)*FTO(d_t)**expT(d_t))
+ sum((d_tt,d_t)$(ord(d_tt)<>ord(d_t) and (Recycle_TU =
0)),CPT(d_t)*yFT(d_tt,d_t)+IPT(d_t)*FT(d_tt,d_t)**expT(d_t))
+ sum((d_tt,d_t)$((Recycle_TU = 1)),CPT(d_t)*yFT(d_tt,d_t)
+IPT(d_t)*FT(d_tt,d_t)**expT(d_t))
)

+ hours*(
sum((d_s,d_p),FIP(d_s,d_p)*PMP(d_p))
+ sum((d_s,d_t),FIT(d_s,d_t)*PMT(d_t))
+ sum((d_s)$(card(d_p)=0),FIF(d_s)*PMF(d_s))

+ sum((d_pp,d_p)$(ord(d_pp)<>ord(d_p) and (Recycle_PU =

0)),FP(d_pp,d_p)*PMP(d_pp))
+ sum((d_pp,d_p)$((Recycle_PU = 1)),FP(d_pp,d_p)*PMP(d_pp))
+ sum((d_p,d_t),FPT(d_p,d_t)*PMP(d_p))
+ sum((d_p),FPO(d_p)*PMP(d_p))

+ sum((d_t,d_p),FTP(d_t,d_p)*PMT(d_t))
+ sum((d_t),FTO(d_t)*PMT(d_t))
+ sum((d_tt,d_t)$(ord(d_tt)<>ord(d_t) and (Recycle_TU =
0)),FT(d_tt,d_t)*PMT(d_tt))
 + sum((d_tt,d_t)$((Recycle_TU = 1)),FT(d_tt,d_t)*PMT(d_tt))
);

Option LIMROW = 0;
Option LIMCOL = 0;

Option MINLP = lindoglobal;

Option OPTCR = 0.00;

Option IterLim = 500000000;

Option RESLIM = 500000000;

Model GenNetwork /all/;

Solve GenNetwork using MINLP minimizing z;

Display z.l;