# MOD file for the plain model of Yee and Grossman 

set HP_Tout_var; 
set CP_Tout_var;
set HP_Tout_fixed; 
set CP_Tout_fixed;
set SC_CU; # set of cold streams of the steam cycle (with same flow rate)
set SC_HU; # set of hot stream of the steam cycle (same flow rate)
set MP_CU; # set of cold streams of the steam cycle (with same flow rate)
set MP_HU; # set of hot stream of the steam cycle (same flow rate)
set LP_CU; # set of cold streams of the steam cycle (with same flow rate)
set LP_HU; # set of hot stream of the steam cycle (same flow rate)
set SCU;  # set of cold utilities with only one stream and variable flow rate
set SHU;  # set of hot utilities with only one stream and variable flow rate
#set HP_tot_Tout_fixed:= HP_Tout_fixed union SC_HU union MP_HU union LP_HU union SHU;
#set CP_tot_Tout_fixed:= CP_Tout_fixed union SC_CU union MP_CU union LP_CU union SCU;
set HP:= HP_Tout_var union HP_Tout_fixed;
set CP:= CP_Tout_var union CP_Tout_fixed;

set SC_EV;
set SC_CO;
set MP_EV;
set MP_CO;
set LP_EV;
set LP_CO;
set PR_EV within CP;
set PR_CO within HP;
set SCU_EV;
set SHU_CO;
set RCU:= SC_CU union SCU union SCU_EV union MP_CU union LP_CU union SC_EV union MP_EV union LP_EV; # set of cold utilities streams involved in the HEN with variable mCp 
set RHU:= SC_HU union SHU union SHU_CO union MP_HU union LP_HU union SC_CO union MP_CO union LP_CO; # set of  hot utility streams in the HEN with variable mCp
set EV = SC_EV union MP_EV union LP_EV union PR_EV union SCU_EV;
set CO = SC_CO union MP_CO union LP_CO union PR_CO union SHU_CO;

set SC:= SC_CU union SC_HU union SC_EV union SC_CO; # set of streams with same flow rate of HP level
set MP:= MP_CU union MP_HU union MP_EV union MP_CO; # set of streams with same flow rate of MP level
set LP:= LP_CU union LP_HU union LP_EV union LP_CO; # set of streams with same flow rate of LP level

set CP_nosplit;
set HP_nosplit;

set HPtotal:= HP union RHU union CO;
set CPtotal:= CP union RCU union EV;

set SPILL;

param  DTMIN>=0;
param Frhu0 {RHU};
param Frcu0 {RCU};
param FH {HPtotal} >= 0;
param FC {CPtotal} >= 0;
param qcu_tot >= 0;
param qhu_tot >= 0;

param TH_IN {HPtotal};
param TH_OUT {j in HPtotal} <= TH_IN[j];
param UH{HPtotal};

param TC_IN {CPtotal};
param TC_OUT {j in CPtotal} >= TC_IN[j];
param UC{j in CPtotal};

param Penalty {HPtotal,CPtotal} default 1;
param Penalty_HU {CPtotal} default 1;
param Penalty_CU {HPtotal} default 1;

param THU_IN ;
param THU_OUT <= THU_IN;
param UHU;
param COSTHU;

param TCU_IN ;
param TCU_OUT>= TCU_IN;
param UCU;
param COSTCU;

param CFA;
param CA;
param BA;
param CFH;
param CH ;
param BH ;
#param NOK;
param CFC; 
param CC; 
param BC; 
param Ue_ij{i in HPtotal, j in CPtotal}:= (1/UH[i]+1/UC[j])**(-1);
param Ui_cu{i in HPtotal}:=(1/UH[i]+1/UCU)**(-1);
param Uj_hu{j in CPtotal}:=(1/UC[j]+1/UHU)**(-1);

param DTmin_cu;
param DTmin_hu;
param DT_H {HPtotal};
param DT_C {CPtotal};

param DT_ij {i in HPtotal, j in CPtotal}:= DT_H[i] + DT_C[j];
param DTmin_new {HPtotal, CPtotal}, default 100;
param DT_ij_new {i in HPtotal, j in CPtotal}:= min(DT_ij[i,j],DTmin_new[i,j]);

param DTcu {i in HPtotal}:= DT_H[i] + DTmin_cu;
param DTmin_i_new {HPtotal}, default 100;
param DTcu_new {i in HPtotal} := min(DTcu[i],DTmin_i_new[i]);

param DThu {j in CPtotal}:= DTmin_hu + DT_C[j];

param max_HU;
param max_CU;

# Auxiliary Big-M parameters
param Omega_ij{i in HPtotal diff CO, j in CPtotal diff EV} := 
if FH[i]*(TH_IN[i]-TH_OUT[i]) < FC[j]*(TC_OUT[j]-TC_IN[j]) then FH[i]*(TH_IN[i]-TH_OUT[i]) else FC[j]*(TC_OUT[j]-TC_IN[j]); #  prendere minimo dei due Q flussi
param Omega_ij_COND{i in CO, j in CPtotal diff EV} := if max{ii in HPtotal diff RHU}FH[ii]*(TH_IN[ii]-TH_OUT[ii]) < FC[j]*(TC_OUT[j]-TC_IN[j]) then max{ii in HPtotal diff RHU}FH[ii]*(TH_IN[ii]-TH_OUT[ii]) else FC[j]*(TC_OUT[j]-TC_IN[j]);
param Omega_ij_EVAP{i in HPtotal diff CO, j in EV} := if FH[i]*(TH_IN[i]-TH_OUT[i]) < max{jj in CPtotal diff RCU}FC[jj]*(TC_OUT[jj]-TC_IN[jj]) then FH[i]*(TH_IN[i]-TH_OUT[i]) else max{jj in CPtotal diff RCU}FC[jj]*(TC_OUT[jj]-TC_IN[jj]); 
param Omega_ij_COND_EVAP{i in CO, j in EV} := if max{ii in HPtotal diff RHU}FH[ii]*(TH_IN[ii]-TH_OUT[ii]) < max{jj in CPtotal diff RCU}FC[jj]*(TC_OUT[jj]-TC_IN[jj]) then max{ii in HPtotal diff RHU}FH[ii]*(TH_IN[ii]-TH_OUT[ii]) else max{jj in CPtotal diff RCU}FC[jj]*(TC_OUT[jj]-TC_IN[jj]);
param Omega_icu{i in HPtotal diff CO}:=FH[i]*(TH_IN[i]-TH_OUT[i]);
param Omega_icu_COND{i in CO}:=max{ii in HPtotal diff RHU}FH[ii]*(TH_IN[ii]-TH_OUT[ii]);
param Omega_jhu{j in CPtotal diff EV}:=FC[j]*(TC_OUT[j]-TC_IN[j]);
param Omega_jhu_EVAP{j in EV}:=max{jj in CPtotal diff RCU}FC[jj]*(TC_OUT[jj]-TC_IN[jj]);
param Tau{ii in HPtotal, jj in CPtotal}:= (max{i in HPtotal} TH_IN[i])-(min{j in CPtotal} TC_IN[j]) + (max{i in HPtotal,j in CPtotal}DT_ij[i,j]); #TH_IN[i] - TC_IN[j];
param Tau_hu{jj in CPtotal}:= THU_IN-(min{j in CPtotal} TC_IN[j])+max{j in CPtotal}DThu[j]; #THU_IN-TC_IN[j];
param Tau_cu{ii in HPtotal}:= (max{i in HPtotal} TH_IN[i])-TCU_IN +max{i in HPtotal}DTcu[i]; #TH_IN[i]-TCU_IN;

set Tstages; # = 1 .. NOK; # set of stages 
param NOK:= card(Tstages);
set Tloc=1 .. (NOK+1); # set of  temperature locations (one for each temperature variable)
set Forb_matches dimen 2;
set Req_matches dimen 2;
set Restr_matches dimen 2;
set Forb_matches_HU;
set Forb_matches_CU;
set Restr_matches_HU;
set Restr_matches_CU;
set Req_matches_HU;
set Req_matches_CU;
param Qmax_HU{Restr_matches_HU};
param Qmax_CU{Restr_matches_CU};
param Qmin_HU{Req_matches_HU};
param Qmin_CU{Req_matches_CU};
param Qmin {Req_matches};
param Qmax{Restr_matches};

var Dt {i in HPtotal, j in CPtotal, k in Tloc}:>=0;
var Dtcu {i in HPtotal}:>=0; # temp approach between cold utility and hot process stream
var Dthu {j in CPtotal}:>=0 ;# temp approach between hot utility and cold process stream
var q {i in HPtotal, j in CPtotal, k in Tstages}:>=0 ;# heat exch between i and j in stage k
var qcu{i in HPtotal}:>=0 ;
var qhu{j in CPtotal}:>=0 ;
var th{i in HPtotal diff CO, k in Tloc} :<=TH_IN[i] :>=TH_OUT[i]; # temp of hot stream i at the hot end side of T location k (exit)
var tc{j in CPtotal diff EV, k in Tloc} :<=TC_OUT[j] :>=TC_IN[j]; # temp of cold stream j at the hot end side of T location k (inlet)
var z {i in HPtotal, j in CPtotal, k in Tstages} binary; # binary variable to denote the existence of  HX i j k
var zcu{i in HPtotal} binary;
var zhu{j in CPtotal} binary;
var Frhu{i in RHU}:>=0, <=(sum{j in CP diff PR_EV} FC[j]*(TC_OUT[j]-TC_IN[j])+sum{j in PR_EV} FC[j])/(TH_IN[i]-TH_OUT[i]); #  :=FH[i]*Frhu0[i]/(TH_IN[i]-TH_OUT[i]); #  mass flow rates of utility streams and steam cycle tube banks which are active
var Frcu{j in RCU}:>=0, <=(sum{i in HP diff PR_CO} FH[i]*(TH_IN[i]-TH_OUT[i])+sum{i in PR_CO} FH[i])/(TC_OUT[j]-TC_IN[j]); #  :=FC[j]*Frcu0[j]/(TC_OUT[j]-TC_IN[j]); #  mass flow rates of utility streams and steam cycle tube banks which are active
#var zSC binary; #activation of the HP steam level
#var zMP binary; #activation of the MP steam level
#var zLP binary; #activation of the LP steam level
#var zSCU binary;
#var zSHU binary;

var THP_out_var{i in HP_Tout_var}:>=TH_OUT[i] :<=TH_IN[i];# variable outlet temperature for streams with variable outlet temp
var TCP_out_var{i in CP_Tout_var}:<=TC_OUT[i] :>=TC_IN[i];# variable outlet temperature for streams with variable outlet temp

### Parametri che servono solo al NLP
param ENTOL;
param MTOL;
param FSC0;
param FMP0;
param FLP0;
param FPO_0;
param FSCMIN;
param FMPMIN;
param FLPMIN;
param FSCMAX;
param FMPMAX;
param FLPMAX;
param costSC;
param AcostSC;
param costMP;
param AcostMP;
param costLP;
param AcostLP;
param costSCU{i in SCU union SCU_EV};
param AcostSCU{i in SCU union SCU_EV};
param costSHU{i in SHU union SHU_CO};
param AcostSHU{i in SHU union SHU_CO};
param CFA_ij{HPtotal,CPtotal}:= CFA; # equipment costs (to be corrected with CCR and MF, see o.f.)
param CA_ij{HPtotal,CPtotal}:= CA; # equipment costs (to be corrected with CCR and MF, see o.f.)
param CFH_j{CPtotal}:= CFH; # equipment costs (to be corrected with CCR and MF, see o.f.)
param CH_j{CPtotal}:= CH; # equipment costs (to be corrected with CCR and MF, see o.f.)
param CFC_i{HPtotal}:= CFC; # equipment costs (to be corrected with CCR and MF, see o.f.)
param CC_i{HPtotal}:= CC; # equipment costs (to be corrected with CCR and MF, see o.f.)
param Aref{HPtotal,CPtotal} default 1;
param Fscale{HPtotal,CPtotal}:= BA;
param Aref_i{HPtotal} default 1;
param Fscale_i{HPtotal}:= BC;
param Aref_j{CPtotal} default 1;
param Fscale_j{CPtotal}:= BH;
param F_P{HPtotal,CPtotal} default 1;
param F_mat{HPtotal,CPtotal} default 1;
param F_P_i{HPtotal} default 1;
param F_mat_i{HPtotal} default 1;
param F_P_j{CPtotal} default 1;
param F_mat_j{CPtotal} default 1;

param CCR; # capital Carrying Charge Rate
param MF; # Multiplication Factor for investment costs
param h_equiv; # equivalent hours h/year
param p_el; # price for selling electricity in $/kWh

param DhSC;
param RefSC;
param DhMP;
param RefMP;
param DhLP;
param RefLP;
param DhLLP;
param RefLLP;

param F_turb_HP; #scale factor for HP and MP turbines
param F_turb_LP; #scale factor for LP and LLP turbines

param FshSC;
param FshMP;
param FshLP;
param FshLLP;
param Fshift{i in RHU union RCU} default 0;
param CostTMP;
param CostTLP;
param CostTLLP;


minimize total_cost: (sum{i in HPtotal} qcu[i]*COSTCU)+ (sum{j in CPtotal} qhu[j]*COSTHU) 
+ (sum{i in SHU: i not in SHU_CO} Frhu[i]*FH[i]*(TH_IN[i]-TH_OUT[i])*costSHU[i]) + (sum{i in SHU_CO} Frhu[i]*FH[i]*costSHU[i])
+ (sum{j in SCU: j not in SCU_EV} Frcu[j]*FC[j]*(TC_OUT[j]-TC_IN[j])*costSCU[j]) + (sum{j in SCU_EV} Frcu[j]*FC[j]*costSCU[j]) 
+ (sum{i in HPtotal, j in CPtotal, k in Tstages} z[i,j,k]*CFA_ij[i,j]*CCR*MF) 
+ (sum{i in HPtotal} zcu[i]*CFC_i[i]*CCR*MF) + (sum{j in CPtotal} zhu[j]*CFH_j[j]*CCR*MF)
+ (sum{i in HPtotal, j in CPtotal, k in Tstages} 
    (CA_ij[i,j]*Aref[i,j]*CCR*MF*F_P[i,j]*F_mat[i,j])*
	(((0.01+q[i,j,k]/(Ue_ij[i,j]*(0.001 + Dt[i,j,k]*Dt[i,j,k+1]*(Dt[i,j,k]+Dt[i,j,k+1])/2)**(1/3))))/Aref[i,j])**Fscale[i,j]) #
+ (sum{i in HPtotal diff (HP_Tout_var union CO): TH_OUT[i] > TCU_IN} 
    (CC_i[i]*Aref_i[i]*CCR*MF*F_P_i[i]*F_mat_i[i])*
	(0.001+((.01+qcu[i]/(Ui_cu[i]*(Dtcu[i]*(TH_OUT[i]-TCU_IN)*(Dtcu[i]+(TH_OUT[i]-TCU_IN))/2)**(1/3))))/Aref_i[i])**Fscale_i[i]) #
+ (sum{i in HP_Tout_var: TH_OUT[i] > TCU_IN} 
    (CC_i[i]*Aref_i[i]*CCR*MF*F_P_i[i]*F_mat_i[i])*
	(0.001+((0.01+qcu[i]/(Ui_cu[i]*(Dtcu[i]*(THP_out_var[i]-TCU_IN)*(Dtcu[i]+(THP_out_var[i]-TCU_IN))/2)**(1/3))))/Aref_i[i])**Fscale_i[i]) #
+ (sum{i in CO: TH_IN[i] > TCU_IN} 
    (CC_i[i]*Aref_i[i]*CCR*MF*F_P_i[i]*F_mat_i[i])*
	(0.001+((.01+qcu[i]/(Ui_cu[i]*(Dtcu[i]*(TH_IN[i]-TCU_IN)*(Dtcu[i]+(TH_IN[i]-TCU_IN))/2)**(1/3))))/Aref_i[i])**Fscale_i[i]) #
+ (sum{j in CPtotal diff (CP_Tout_var union EV): THU_IN > TC_OUT[j]} 
    (CH_j[j]*Aref_j[j]*CCR*MF*F_P_j[j]*F_mat_j[j])*
	(0.001+((0.01+qhu[j]/(Uj_hu[j]*(Dthu[j]*(THU_IN-TC_OUT[j])*(Dthu[j]+(THU_IN-TC_OUT[j]))/2)**(1/3))))/Aref_j[j])**Fscale_j[j]) #
+ (sum{j in CP_Tout_var: THU_IN > TC_OUT[j]} 
    (CH_j[j]*Aref_j[j]*CCR*MF*F_P_j[j]*F_mat_j[j])*
	(0.001+((0.01+qhu[j]/(Uj_hu[j]*(Dthu[j]*(THU_IN-TCP_out_var[j])*(Dthu[j]+(THU_IN-TCP_out_var[j]))/2)**(1/3))))/Aref_j[j])**Fscale_j[j]) #
+ (sum{j in EV: THU_IN > TC_IN[j]} 
    (CH_j[j]*Aref_j[j]*CCR*MF*F_P_j[j]*F_mat_j[j])*
	(0.001+((0.01+qhu[j]/(Uj_hu[j]*(Dthu[j]*(THU_IN-TC_OUT[j])*(Dthu[j]+(THU_IN-TC_IN[j]))/2)**(1/3))))/Aref_j[j])**Fscale_j[j]) #
;

subject to streamHOT_Q_balance_Tfixed {i in HPtotal diff (RHU union HP_Tout_var union CO)}:
   FH[i]*(TH_IN[i]-TH_OUT[i]) - (sum {k in Tstages, j in CPtotal} q[i,j,k]) - qcu[i]=0;
subject to streamHOT_Q_balance_Tvar {i in HP_Tout_var}:
   FH[i]*(TH_IN[i]-THP_out_var[i]) - (sum {k in Tstages, j in CPtotal} q[i,j,k]) - qcu[i]=0;
subject to streamHOT_Q_balance_Tfixed_RHU {i in RHU diff (HP_Tout_var union CO)}:
   FH[i]*Frhu[i]*(TH_IN[i]-TH_OUT[i]) - (sum {k in Tstages, j in CPtotal} q[i,j,k]) - qcu[i]=0;
subject to streamHOT_Q_balance_Tfixed_COND {i in CO diff RHU}:
   FH[i] - (sum {k in Tstages, j in CPtotal} q[i,j,k]) - qcu[i]=0;
subject to streamHOT_Q_balance_Tfixed_COND_RHU {i in CO inter RHU}:
   FH[i]*Frhu[i] - (sum {k in Tstages, j in CPtotal} q[i,j,k]) - qcu[i]=0;
   
subject to streamCOLD_Q_balance_Tfixed {j in CPtotal diff (RCU union CP_Tout_var union EV)}:
   FC[j]*(TC_OUT[j]-TC_IN[j]) - (sum {k in Tstages, i in HPtotal} q[i,j,k]) - qhu[j]=0;
subject to streamCOLD_Q_balance_Tvar {j in CP_Tout_var}:
   FC[j]*(TCP_out_var[j]-TC_IN[j]) - (sum {k in Tstages, i in HPtotal} q[i,j,k]) - qhu[j]=0;
subject to streamCOLD_Q_balance_Tfixed_RCU {j in RCU diff (CP_Tout_var union EV)}:
   FC[j]*Frcu[j]*(TC_OUT[j]-TC_IN[j]) - (sum {k in Tstages, i in HPtotal} q[i,j,k]) - qhu[j]=0;
subject to streamCOLD_Q_balance_Tfixed_EVAP {j in EV diff RCU}:
   FC[j] - (sum {k in Tstages, i in HPtotal} q[i,j,k]) - qhu[j]=0;
subject to streamCOLD_Q_balance_Tfixed_EVAP_RCU {j in EV inter RCU}:
   FC[j]*Frcu[j] - (sum {k in Tstages, i in HPtotal} q[i,j,k]) - qhu[j]=0;

subject to stage_streamHOT_heat_balance{i in HPtotal diff (RHU union CO), k in Tstages}:
   FH[i]*(th[i,k]-th[i,k+1])- (sum { j in CPtotal} q[i,j,k])=0;
subject to stage_streamHOT_heat_balance_RHU{i in RHU diff CO, k in Tstages}:
   -ENTOL <= Frhu[i]*FH[i]*(th[i,k]-th[i,k+1])- (sum { j in CPtotal} q[i,j,k]) <= ENTOL;
   
subject to stage_streamCOLD_heat_balance{j in CPtotal diff (RCU union EV), k in Tstages}:
   FC[j]*(tc[j,k]-tc[j,k+1])- (sum {i in HPtotal} q[i,j,k])=0;
subject to stage_streamCOLD_heat_balance_RCU{j in RCU diff EV, k in Tstages}:
   -ENTOL <= Frcu[j]*FC[j]*(tc[j,k]-tc[j,k+1])- (sum {i in HPtotal} q[i,j,k]) <= ENTOL;
   
subject to assigning_inlet_TH_IN{i in HPtotal diff CO}:
   th[i,1]-TH_IN[i]=0;
subject to assigning_inlet_TC_IN{j in CPtotal diff EV}:
   tc[j,NOK+1]-TC_IN[j]=0;
   
subject to feasibility_of_temperatures_hot{i in HPtotal diff CO, k in Tstages}:
    -th[i,k]+th[i,k+1] <= 0;
subject to feasibility_of_temperatures_cold{j in CPtotal diff EV, k in Tstages}:
    -tc[j,k]+tc[j,k+1] <= 0;
    
subject to 	bounding_outlet_temp_hot_Tfixed{i in HPtotal diff (HP_Tout_var union CO)}:
    -th[i,NOK+1]+TH_OUT[i]<=0;
subject to 	bounding_outlet_temp_hot_Tvar{i in HP_Tout_var}:
    -th[i,NOK+1]+THP_out_var[i]<=0;
    
subject to 	bounding_outlet_temp_cold_Tfixed{j in CPtotal diff (CP_Tout_var union EV)}:
    tc[j,1]-TC_OUT[j]<=0;
subject to 	bounding_outlet_temp_cold_Tvar{j in CP_Tout_var}:
    tc[j,1]-TCP_out_var[j]<=0;
    
subject to cold_utility_load_calculation_Tfixed{i in HPtotal diff (RHU union HP_Tout_var union CO)}:
	FH[i]*(th[i,NOK+1]-TH_OUT[i])-qcu[i]=0;
subject to cold_utility_load_calculation_Tvar{i in HP_Tout_var}:
	FH[i]*(th[i,NOK+1]-THP_out_var[i])-qcu[i]=0;
subject to cold_utility_load_calculation_RHU{i in RHU diff (HP_Tout_var union CO)}:
	-ENTOL <= FH[i]*Frhu[i]*(th[i,NOK+1]-TH_OUT[i])-qcu[i] <= ENTOL;

subject to hot_utility_load_calculation_Tfixed{j in CPtotal diff (RCU union CP_Tout_var union EV)}:
	FC[j]*(-tc[j,1]+TC_OUT[j])-qhu[j]=0;
subject to hot_utility_load_calculation_Tvar{j in CP_Tout_var}:
	FC[j]*(-tc[j,1]+TCP_out_var[j])-qhu[j]=0;
subject to hot_utility_load_calculation_RCU{j in RCU diff (CP_Tout_var union EV)}:
	-ENTOL <= FC[j]*Frcu[j]*(-tc[j,1]+TC_OUT[j])-qhu[j] <= ENTOL;
	
subject to logical_exsist_HXs{i in HPtotal diff CO,j in CPtotal diff EV, k in Tstages}:
   q[i,j,k]-Omega_ij[i,j]*z[i,j,k]<=0;   
subject to logical_exsist_HXs_COND{i in CO,j in CPtotal diff EV, k in Tstages}:
   q[i,j,k]-Omega_ij_COND[i,j]*z[i,j,k]<=0;
subject to logical_exsist_HXs_EVAP{i in HPtotal diff CO,j in EV, k in Tstages}:
   q[i,j,k]-Omega_ij_EVAP[i,j]*z[i,j,k]<=0;
subject to logical_exsist_HXs_COND_EVAP{i in CO,j in EV, k in Tstages}:
   q[i,j,k]-Omega_ij_COND_EVAP[i,j]*z[i,j,k]<=0;
subject to logical_exsist_HXs_coldutility{i in HPtotal diff CO}:
   qcu[i]-Omega_icu[i]*zcu[i]<=0;
subject to logical_exsist_HXs_coldutility_COND{i in CO}:
   qcu[i]-Omega_icu_COND[i]*zcu[i]<=0;
subject to logical_exsist_HXs_hotutility{j in CPtotal diff EV}:
   qhu[j]-Omega_jhu[j]*zhu[j]<=0;
subject to logical_exsist_HXs_hotutility_EVAP{j in EV}:
   qhu[j]-Omega_jhu_EVAP[j]*zhu[j]<=0;
   
subject to logical_dtaproachT_HXs_left{i in HPtotal diff CO, j in CPtotal diff EV, k in Tstages}: 
   Dt[i,j,k]-th[i,k]+tc[j,k]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_left_COND{i in CO, j in CPtotal diff EV, k in Tstages}: 
   Dt[i,j,k]-TH_IN[i]+tc[j,k]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_left_EVAP{i in HPtotal diff CO, j in EV, k in Tstages}: 
   Dt[i,j,k]-th[i,k]+TC_IN[j]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_left_COND_EVAP{i in CO, j in EV, k in Tstages}: 
   Dt[i,j,k]-TH_IN[i]+TC_IN[j]-Tau[i,j]*(1-z[i,j,k])<=0;

subject to logical_dtaproachT_HXs_right{i in HPtotal diff CO, j in CPtotal diff EV, k in Tstages}: 
  Dt[i,j,k+1]-th[i,k+1]+tc[j,k+1]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_right_COND{i in CO, j in CPtotal diff EV, k in Tstages}: 
  Dt[i,j,k+1]-TH_IN[i]+tc[j,k+1]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_right_EVAP{i in HPtotal diff CO, j in EV, k in Tstages}: 
  Dt[i,j,k+1]-th[i,k+1]+TC_IN[j]-Tau[i,j]*(1-z[i,j,k])<=0;
subject to logical_dtaproachT_HXs_right_COND_EVAP{i in CO, j in EV, k in Tstages}: 
  Dt[i,j,k+1]-TH_IN[i]+TC_IN[j]-Tau[i,j]*(1-z[i,j,k])<=0;
  
subject to logical_dtaproach_left_coldut{i in HPtotal diff (HP_Tout_var union CO)}: 
   Dtcu[i]-th[i,NOK+1]+TCU_OUT-Tau_cu[i]*(1-zcu[i])<=0;
subject to logical_dtaproach_left_coldut_COND{i in CO}: 
   Dtcu[i]-TH_IN[i]+TCU_OUT-Tau_cu[i]*(1-zcu[i])<=0;
subject to logical_dtaproachT_right_hotutility{j in CPtotal diff EV}: 
   Dthu[j]-THU_OUT+tc[j,1]-Tau_hu[j]*(1-zhu[j])<=0;
subject to logical_dtaproachT_right_hotutility_EVAP{j in EV}: 
   Dthu[j]-THU_OUT+TC_IN[j]-Tau_hu[j]*(1-zhu[j])<=0;
   
subject to min_temp_difference{i in HPtotal,j in CPtotal,k in Tloc}: 
   -Dt[i,j,k]+ DTMIN <=0;
 subject to min_temp_difference_hot_ut{j in CPtotal}: 
   -Dthu[j]+ DTMIN <=0;  
 subject to min_temp_difference_cold_ut{i in HPtotal}: 
   -Dtcu[i]+ DTMIN <=0;  
   
subject to no_stream_split_hot{i in HP_nosplit, k in Tstages}:
   (sum{j in CPtotal} z[i,j,k])<=1;
 subject to no_stream_split_cold{j in CP_nosplit, k in Tstages}:
   (sum{i in HPtotal} z[i,j,k])<=1; 
   
 subject to forbidden_matches_streams{(i,j)in Forb_matches, k in Tstages }:
   z[i,j,k]<=0;
 subject to forbidden_matches_HU{j in Forb_matches_HU}:
   zhu[j]=0;
 subject to forbidden_matches_CU{i in Forb_matches_CU}:
   zhu[i]=0;
   
 subject to required_matches {(i,j)in Req_matches }:
  (sum{k in Tstages} q[i,j,k])>=Qmin[i,j];
  subject to required_matches_HU {j in Req_matches_HU }:
   qhu[j]>=Qmin_HU[j];
  subject to required_matches_CU {i in Req_matches_CU }:
   qcu[i]>=Qmin_CU[i];
   
 subject to restricted_matches {(i,j)in Restr_matches }:
  (sum{k in Tstages} q[i,j,k])<=Qmax[i,j];
   subject to restricted_matches_HU {j in Restr_matches_HU }:
   qhu[j]<=Qmax_HU[j];
  subject to restricted_matches_CU {i in Restr_matches_CU }:
   qcu[i]<=Qmax_CU[i];
   
 subject to max_qcu_tot:
   sum{i in HPtotal} qcu[i] <= qcu_tot;
   
 subject to max_qhu_tot:
   sum{i in CPtotal} qhu[i] <= qhu_tot;