apis/examples_python/transport8_8py_source.html

import sys

from threading import Lock, Thread

from gams import GamsWorkspace, GamsModifier


GAMS_MODEL = """

Set

   i 'canning plants' / seattle,  san-diego /

   j 'markets'        / new-york, chicago, topeka /;


Parameter

   a(i) 'capacity of plant i in cases'

        / seattle    350

          san-diego  600 /


   b(j) 'demand at market j in cases'

        / new-york   325

          chicago    300

          topeka     275 /;


Table d(i,j) 'distance in thousands of miles'

              new-york  chicago  topeka

   seattle         2.5      1.7     1.8

   san-diego       2.5      1.8     1.4;


Scalar

   f     'freight in dollars per case per thousand miles' / 90 /

   bmult 'demand multiplier' / 1 /;


Parameter c(i,j) 'transport cost in thousands of dollars per case';

c(i,j) = f*d(i,j)/1000;


Variable

   x(i,j) 'shipment quantities in cases'

   z      'total transportation costs in thousands of dollars';


Positive Variable x;


Equations

   cost      'define objective function'

   supply(i) 'observe supply limit at plant i'

   demand(j) 'satisfy demand at market j';


cost..      z =e= sum((i,j), c(i,j)*x(i,j));


supply(i).. sum(j, x(i,j)) =l= a(i);


demand(j).. sum(i, x(i,j)) =g= bmult*b(j);


Model transport /all/;

"""


def scen_solve(checkpoint, bmult_list, list_lock, io_lock):

    list_lock.acquire()

    mi = checkpoint.add_modelinstance()

    list_lock.release()

    bmult = mi.sync_db.add_parameter("bmult", 0, "demand multiplier")

    opt = ws.add_options()

    opt.all_model_types = "cplex"


    # instantiate the GamsModelInstance and pass a model definition and GamsModifier to declare bmult mutable

    mi.instantiate("transport use lp min z", GamsModifier(bmult), opt)

    bmult.add_record().value = 1.0


    while True:

        # dynamically get a bmult value from the queue instead of passing it to the different threads at creation time

        list_lock.acquire()

        if not bmult_list:

            list_lock.release()

            return

        b = bmult_list.pop()

        list_lock.release()

        bmult.first_record().value = b

        mi.solve()


        # we need to make the output a critical section to avoid messed up report informations

        io_lock.acquire()

        print(f"Scenario bmult={b}:")

        print(f"  Modelstatus: {mi.model_status}")

        print(f"  Solvestatus: {mi.solver_status}")

        print(f"  Obj: {mi.sync_db['z'].first_record().level}")

        io_lock.release()


if __name__ == "__main__":

    sys_dir = sys.argv[1] if len(sys.argv) > 1 else None

    work_dir = sys.argv[2] if len(sys.argv) > 2 else None

    ws = GamsWorkspace(system_directory=sys_dir, working_directory=work_dir)


    cp = ws.add_checkpoint()


    # initialize a GamsCheckpoint by running a GamsJob

    job = ws.add_job_from_string(GAMS_MODEL)

    job.run(checkpoint=cp)


    bmult_list = [1.3, 1.2, 1.1, 1.0, 0.9, 0.8, 0.7, 0.6]


    # solve multiple model instances in parallel

    list_lock = Lock()

    io_lock = Lock()


    # start 2 threads

    nr_workers = 2

    threads = {}

    for i in range(nr_workers):

        threads[i] = Thread(

            target=scen_solve, args=(cp, bmult_list, list_lock, io_lock)

        )

        threads[i].start()

    for i in range(nr_workers):

        threads[i].join()