apis/examples_python/warehouse_8py_source.html

from gams import GamsWorkspace, GamsException, GamsExceptionExecution, GamsExitCode

import threading

import sys

import os


def get_model_text():

    return '''

$title Warehouse.gms


$eolcom //

$SetDDList warehouse store fixed disaggregate // acceptable defines

$if not set warehouse    $set warehouse   10

$if not set store        $set store       50

$if not set fixed        $set fixed       20

$if not set disaggregate $set disaggregate 1 // indicator for tighter bigM constraint

$ife %store%<=%warehouse% $abort Increase number of stores (>%warehouse)


set res respond codes  / 0 Normal

                         1 License Error

                         2 No solution

                         3 Other Error   /

    ares(res)          / 3 /;


Sets Warehouse  /w1*w%warehouse% /

     Store      /s1*s%store%     /

Alias (Warehouse,w), (Store,s);

Scalar

     fixed        fixed cost for opening a warehouse / %fixed% /

Parameter

     capacity(WareHouse)

     supplyCost(Store,Warehouse);


$eval storeDIVwarehouse trunc(card(store)/card(warehouse))

capacity(w)     =   %storeDIVwarehouse% + mod(ord(w),%storeDIVwarehouse%);

supplyCost(s,w) = 1+mod(ord(s)+10*ord(w), 100);


Variables

    open(Warehouse)

    supply(Store,Warehouse)

    obj;

Binary variables open, supply;


Equations

    defobj

    oneWarehouse(s)

    defopen(w);


defobj..  obj =e= sum(w, fixed*open(w)) + sum((w,s), supplyCost(s,w)*supply(s,w));


oneWarehouse(s).. sum(w, supply(s,w)) =e= 1;


defopen(w)..      sum(s, supply(s,w)) =l= open(w)*capacity(w);


$ifthen %disaggregate%==1

Equations

     defopen2(s,w);

defopen2(s,w).. supply(s,w) =l= open(w);

$endif


model distrib /all/;

solve distrib min obj using mip;


$macro setResult(n) option clear=ares; ares(n) = yes;

if (distrib.modelstat=%ModelStat.LicensingProblem% or

    distrib.solvestat=%Solvestat.LicensingProblems%,

  setResult('1');

  abort 'License Error';

);

if (distrib.solvestat<>%SolveStat.NormalCompletion% or

    distrib.modelstat<>%ModelStat.Optimal% and

    distrib.modelstat<>%ModelStat.IntegerSolution%,

  setResult('2');

  abort 'No solution';

);

setResult('0'); '''


def solve_warehouse(workspace, number_of_warehouses, result, db_lock):

    global status

    global status_string

    try:

        # instantiate GAMSOptions and define some scalars

        opt = workspace.add_options()

        opt.all_model_types = "cplex"

        opt.defines["Warehouse"] = str(number_of_warehouses)

        opt.defines["Store"] = "65"

        opt.defines["fixed"] = "22"

        opt.defines["disaggregate"] = "0"

        opt.optcr = 0.0 # Solve to optimality


        # create a GAMSJob from string and write results to the result database

        job = workspace.add_job_from_string(get_model_text())

        job.run(opt)


        # need to lock database write operations

        db_lock.acquire()

        result["objrep"].add_record(str(number_of_warehouses)).value = job.out_db["obj"][()].level

        db_lock.release()

        for supply_rec in job.out_db["supply"]:

            if supply_rec.level > 0.5:

                db_lock.acquire()

                result["supplyMap"].add_record((str(number_of_warehouses), supply_rec.key(0), supply_rec.key(1)))

                db_lock.release()

    except GamsExceptionExecution as e:

        # Check if we see a User triggered abort and look for the user defined result

        if e.rc == GamsExitCode.ExecutionError:

            db_lock.acquire()

            status_string = job.out_db["res"]

            status_string = status_string.find_record(job.out_db["ares"].first_record().key(0)).text

            db_lock.release()

        db_lock.acquire()

        status = e.rc

        db_lock.release()

    except GamsException as e:

        print(e)

        db_lock.acquire()

        status = -1

        db_lock.release()

    except Exception as e:

        print(e)

        db_lock.acquire()

        status = -2

        db_lock.release()


if __name__ == "__main__":

    if len(sys.argv) > 1:

        ws = GamsWorkspace(system_directory = sys.argv[1])

    else:

        ws = GamsWorkspace()


    # create a GAMSDatabase for the results

    result_db = ws.add_database()

    result_db.add_parameter("objrep" ,1 ,"Objective value")

    result_db.add_set("supplyMap" ,3 ,"Supply connection with level")


    status_string = ""

    status = 0


    try:

        # run multiple parallel jobs

        db_lock = threading.Lock()

        threads = {}

        for i in range(10,22):

            threads[i] = threading.Thread(target=solve_warehouse, args=(ws, i, result_db, db_lock))

            threads[i].start()

        for t in threads.values():

            t.join()

        if status > 0:

            raise GamsExceptionExecution("Error when running GAMS: " + str(status) + " " + status_string, status);

        elif status == -1:

            raise GamsException("Error in GAMS API")

        elif status == -2:

            raise Exception()


        # export the result database to a GDX file

        result_db.export("/tmp/result.gdx")


    except GamsException as e:

        print("GamsException occured: " , e)

    except Exception as e:

        print(e)