$Title Kapazitaetsallokation und Lagerplatzzuweisung bei Zonung
$Ontext

Vorlesung: Modellierung und Planung von Logistiksystemen
Abschnitt: 4.2 Konfigurationsplanung von Lagersystemen
Problemstellung: Dekompositionsheuristik zur Auslegung von Zonenkapazitaeten und Zuordnung von Artikeln zu Zonen
                 fuer normalverteilte Lagerplatzbedarfe der Artikel

 - Model -

Author: Christoph Schwindt
Date: 26/12/2019

$Offtext

$eolcom//

$include class-based-storage_data.gms

***** capacity allocation problem *****

variables
   alpha  Vollstaendige Einlagerverfuegbarkeit (Zielfunktion)
   a(l)   Anzahl der Zone l zugeteilten Lagerplaetze ;

integer variables a ;

equations
   def_alpha   Definition der vollstaendigen Einlagerverfuegbarkeit
   aufteilung  Aufteilung von p Lagerplaetzen auf die Zonen ;

   def_alpha..   alpha =e= prod(l, errorf([a(l)-sum(j$j_in_l(l,j), mu(j))]/[sqrt(sum(j$j_in_l(l,j), sqr(cv(j)*mu(j))))+epsilon])) ;
   aufteilung..  sum(l, a(l)) =e= p ;

   a.up(l) = p ;

model capacity_allocation / def_alpha, aufteilung / ;

   capacity_allocation.solprint = 2 ; // Unterdrueckung der Eintraege im Listing-File

***************************************
***** storage location assignment *****


variables
   aufwand  Gesamter Foerderaufwand (Zielfunktion)
   x(j,l)   gleich 1 falls Artikel j Zone l zugewiesen wird

binary variables x ;

equations
   def_aufwand      Definition Foerderaufwand
   verfuegbarkeit   Einhaltung der vorgegebenen vollstaendigen Einlagerverfuegbarkeit
   artikel_zone(j)  Zuweisung von Artikel j zu einer Zone ;

   def_aufwand..      aufwand =e= sum(j, sum(l, r(j)*(d_I(l)+d_O(l))*x(j,l))) ;
   verfuegbarkeit..   prod(l, errorf([a.l(l)-sum(j, mu(j)*x(j,l))]/[sqrt(sum(j, sqr(cv(j)*mu(j))*x(j,l)))+epsilon])) =g= (1-theta)*alpha.l ;
   artikel_zone(j)..  sum(l, x(j,l)) =e= 1 ;

model location_assignment / def_aufwand, verfuegbarkeit, artikel_zone / ;

   location_assignment.solprint = 2 ; // Unterdrueckung der Eintraege im Listing-File

***********************************
***** decomposition heuristic *****

set i  Iterationen / i1*i100 / ;

parameters
   report(i,*)  Dokumentation der Iterationen
   x_best(j,l)  Beste Zuweisung von Artikeln zu Zonen
   a_best(l)    Beste Zonenkapazitaeten ;

scalars
   aufwand_ca  aufwand-Wert nach capacity allocation
   alpha_la    alpha-Wert nach location assignment
   phi_ca      Zielfunktionswert nach capacity allocation
   phi_la      Zielfunktionswert nach location assignment
   ctr         Zaehler / 0 /
   stop        Flag fuer Abbruch ;

options minlp = lindoglobal
        optcr = 1e-6
        reslim = 120 ;

   x.l(j,l) = 0 ;
   x.l(j,l)$(ord(l)=ceil(ord(j)/card(j)*card(l))) = 1 ;
   phi_la = inf ;
   stop = no ;

   repeat(
         ctr = ctr + 1 ;
         j_in_l(l,j) = no ; j_in_l(l,j)$x.l(j,l) = yes ;
         solve capacity_allocation maximizing alpha using minlp ;
         d_I(l) = gangtiefe/2 + sum(lPrime$(ord(lPrime)<ord(l)), a.l(lPrime))/(2*gangtiefe) + a.l(l)/(4*gangtiefe) ; d_O(l) = d_I(l) ;
         report(i,'alpha ca')$(ord(i)=ctr) = alpha.l ;
         aufwand_ca = sum(j, sum(l, r(j)*(d_I(l)+d_O(l))*x.l(j,l))) ;
         report(i,'aufwand ca')$(ord(i)=ctr) = aufwand_ca ;
         phi_ca = aufwand_ca/alpha.l ;
         report(i,'phi ca')$(ord(i)=ctr) = phi_ca ;
         if (phi_ca ge phi_la,
                 stop = yes ;
         else
                 x_best(j,l) = x.l(j,l) ;
                 a_best(l) = a.l(l) ;
                 ctr = ctr + 1 ;
                 solve location_assignment minimzing aufwand using minlp ;
                 alpha_la = prod(l, errorf([a.l(l)-sum(j, mu(j)*x.l(j,l))]/[sqrt(sum(j, sqr(cv(j)*mu(j))*x.l(j,l)))+epsilon])) ;
                 report(i,'alpha la')$(ord(i)=ctr) = alpha_la ;
                 report(i,'aufwand la')$(ord(i)=ctr) = aufwand.l ;
                 phi_la = aufwand.l/alpha_la ;
                 report(i,'phi la')$(ord(i)=ctr) = phi_la ;
                 if (phi_la ge phi_ca, stop = yes;
                 else
                         x_best(j,l) = x.l(j,l) ;
                         a_best(l) = a.l(l) ;
                 ) ;
         ) ;
   until stop) ;

display report, x_best, a_best ;