[Scip] scip ipopt memory consumption

sct see_chuenteck at yahoo.com.sg
Thu May 21 15:15:27 CEST 2015 

Hi, Scip,

I am using scip-ipopt windows binary provided by ZIB as well as linux 
version to solve a bilinear problem with about 120 variables. I observed 
that it consumes memory very fast, it uses up 16GB of RAM in around 
4000s. Set sep emphasis off slows down the RAM consumption but it still 
uses up all 16 GB.

I have attached the zimpl file.

Is this behaviour normal? If I only wish to use ipopt part of scip, is 
there any settings required?

Thanks a lot
-------------- next part --------------
#Based on Extended Pooling Problem with the Summer Time (EPA) by Misener
#Zimpl syntax

set Source := {1..10};
set Pool := {1..5};
set Prod := {1..10};
set Bound := {1..11};
#For direct source
set SourceD := {11..14};

param L_a[Source] := <1> 0, <2> 0, <3> 0, <4> 0, <5> 0, <6> 0, <7> 0, <8> 100, <9> 50, <10> 10;
param L_ad[SourceD] :=  <11> 0, <12> 0, <13> 0, <14> 0;
param U_a[Source] := <1> 175, <2> 150, <3> 375, <4> 375, <5> 900, <6> 350, <7> 250, <8> 600, <9> 500, <10> 200;
param U_ad[SourceD]:=  <11> 50, <12> 100, <13> 100, <14> 400;
param cost[Source] := <1> 3.0, <2> 2.0, <3> 3.5, <4> 2.0, <5> 1.0, <6> 3.0, <7> 0.7, <8> 0.5, <9> 0.3, <10> 2.5;
param costd[SourceD] := <11> 7.5, <12> 10.5, <13> 8.5, <14> 5.5;

param price[Prod] := <1> 8.0, <2> 7.5, <3> 6.5, <4> 6.0, <5> 6.5, <6> 5.5, <7> 5.0, <8> 5.5, <9> 5.5, <10> 5.0;
param L_demand[Prod] := <1> 100, <2> 0, <3> 50, <4> 50, <5> 50, <6> 50, <7> 50, <8> 50, <9> 100, <10> 40;
param U_demand[Prod] := <1> 700, <2> 800, <3> 400, <4> 400, <5> 300, <6> 200, <7> 400, <8> 300, <9> 200, <10> 400;
param L_quality[Prod*Bound] :=
    | 1 , 2 , 3 ,  4 ,  5 , 6 , 7 , 8 , 9 , 10 , 11 |
| 1 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 2.0|
| 2 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 2.0|
| 3 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 2.0|
| 4 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 2.0|
| 5 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 2.0|
| 6 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 1.0|
| 7 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 1.0|
| 8 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 1.0|
| 9 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 1.0|
|10 |0.0,0.0,6.4,30.0,70.0,0.0,0.0,0.0,0.0,0.0 , 1.0|;

param U_quality[Prod*Bound] :=
    | 1 , 2 , 3 , 4 ,  5, 6 , 7, 8 , 9 , 10 , 11 |
| 1 |3.7,130,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 2 |3.7,150,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 3 |3.7,170,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 4 |3.7,190,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 5 |3.7,150,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 6 |3.7,150,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 7 |3.7,150,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 8 |3.7,200,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
| 9 |3.7,200,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |
|10 |3.7,250,10 ,70 ,100,50 , 2,25 ,3.7,3.7 ,3.7 |;

param conc[Source*Bound] :=

    |  1  , 2 , 3  , 4 ,  5,  6  , 7, 8 ,  9  ,  10 ,  11  |
| 1 | 0.0 , 0 ,60.0,100,100, 0.0 , 0, 0 , 0.0 , 0.0 , 0.0  |
| 2 | 0.0 , 0 ,21.0,100,100, 0.0 , 0, 0 , 0.0 , 0.0 , 0.0  |
| 3 | 0.0 , 0 , 7.4, 50, 95, 0.0 , 0, 0 , 0.0 , 0.0 , 0.0  |
| 4 | 0.0 , 50,10.0,100,100, 0.0 , 0, 0 , 0.0 , 0.0 , 0.0  |
| 5 | 0.0 ,100, 9.0, 70,100, 7.5 , 2,37 , 0.0 , 0.0 , 0.0  |
| 6 | 0.0 , 15, 3.4, 60, 85, 3.2 , 0,12 , 0.0 , 0.0 , 0.0  |
| 7 | 0.0 ,200,10.2, 85,100,10.0 , 1,60 , 0.0 , 0.0 , 0.0  |
| 8 | 0.0 ,400, 8.2, 45, 80,35.0 , 3,20 , 0.0 , 0.0 , 0.0  |
| 9 | 0.0 ,700, 2.1, 15, 60,65.0 , 4,15 , 0.0 , 0.0 , 0.0  |
|10 | 0.0 , 10, 7.4, 30, 70,60.0 , 5, 3 , 0.0 , 0.0 , 0.0  |;

param concd[SourceD*Bound] :=
    |  1  , 2 , 3  , 4 ,  5,  6  , 7, 8 ,  9  ,  10 ,  11  |
|11 |18.15, 0 , 8.8,100,100, 0.0 , 0, 0 ,18.15, 0.0 , 0.0  |
|12 |15.66, 0 , 5.7, 95,100, 0.0 , 0, 0 , 0.0 ,15.66, 0.0  |
|13 |15.66, 0 , 2.7, 70,100, 0.0 , 0, 0 , 0.0 , 0.0 , 0.0  |
|14 |34.73, 0 ,23.0,100,100, 0.0 , 0, 0 , 0.0 , 0.0 ,34.73 |;

param cap[Pool] := <1> 900, <2> 575, <3> 500, <4> 800, <5> 900;

var x[Source cross Pool] >= 0;
var y[Pool cross Prod] >= 0;
var b[Pool cross Bound] >= 0;

# for source direct to product
var xd[SourceD] >= 0;
var yd[SourceD cross Prod] >= 0;

#auxillary var
#var z[Pool cross Prod] >= 0;

#auxillary param
#param L_y[Pool cross Prod] := 0;
#param U_y[Pool cross Prod] := 100;
#param L_b[Pool] := 1;
#param U_b[Pool] := 2;


maximize profit:
sum<k> in Prod:( price[k] * sum <q> in SourceD: yd[q,k] + price[k] * sum<j> in Pool:y[j,k])
- sum<d> in SourceD: costd[d] * xd[d]
- sum<i> in Source: cost[i] * sum<j> in Pool:x[i,j];


subto noFlow1:
      forall <j> in (Pool without {1}): x[1,j] == 0;

subto noFlow2:
      forall <j> in (Pool without {1}): x[2,j] == 0;

subto noFlow3:
      forall <j> in (Pool without {1,2}): x[3,j] == 0;

subto noFlow4:
      forall <j> in (Pool without {2,3}): x[4,j] == 0;

subto noFlow5:
      forall <j> in (Pool without {3}): x[5,j] == 0;

subto noFlow6:
      forall <j> in (Pool without {3}): x[6,j] == 0;

subto noFlow7:
      forall <j> in (Pool without {3,4}): x[7,j] == 0;

subto noFlow8:
      forall <j> in (Pool without {4,5}): x[8,j] == 0;

subto noFlow9:
      forall <j> in (Pool without {5}): x[9,j] == 0;

subto noFlow10:
      forall <j> in (Pool without {5}): x[10,j] == 0;

#subto noFlow11:
#      forall <j> in Pool: x[11,j] == 0;

#subto noFlow12:
#      forall <j> in Pool: x[12,j] == 0;

#subto noFlow13:
#      forall <j> in Pool: x[13,j] == 0;

#subto noFlow14:
#      forall <j> in Pool: x[14,j] == 0;

subto min_availability:
      forall<i> in Source: sum<j> in Pool: x[i,j]  >= L_a[i];

subto min_availability_d:
      forall<i> in SourceD: xd[i] >= L_ad[i];

subto Max_availability:
      forall<i> in Source: sum<j> in Pool: x[i,j] <= U_a[i];

subto max_availability_d:
      forall<i> in SourceD: xd[i] <= U_ad[i];

subto poolBalance:
      forall<j> in Pool: sum<i> in Source: x[i,j] == sum<k> in Prod: y[j,k];

subto Balance:
      forall<i> in SourceD: xd[i] == sum <k> in Prod: yd[i,k];
      
subto poolCapacity:
      forall<j> in Pool: sum<i> in Source: x[i,j] <= cap[j];

subto mixPool1:
      forall<j,l> in Pool*Bound: sum<i> in Source: conc[i,l] * x[i,j] == b[j,l]* sum <i> in Source: x[i,j];  #sum<k> in Prod: z[j,k];

subto demand1:
      forall<k> in Prod: sum<j> in Pool: y[j,k] + sum <i> in SourceD: yd[i,k]>= L_demand[k];

subto demand2:
      forall<k> in Prod: sum<j> in Pool: y[j,k] + sum <i> in SourceD: yd[i,k]<= U_demand[k];

subto mixProd1:
      forall<k,l> in Prod*Bound: sum<j> in Pool: b[j,l] * y[j,k] + sum<i> in SourceD: concd[i,l]*xd[i] <= U_quality[k,l] * (sum<j> in Pool: y[j,k] + sum<p> in SourceD: yd[p,k]);
      
subto mixProd2:
      forall<k,l> in Prod*Bound: sum<j> in Pool: b[j,l] * y[j,k] + sum<i> in SourceD: concd[i,l]*xd[i] >= L_quality[k,l] * (sum<j> in Pool: y[j,k] + sum<p> in SourceD: yd[p,k]);

More information about the Scip mailing list