apis/examples_python/run__engine_8py_source.html

from io import StringIO

import json

import os

import sys

from threading import Thread

import time

from gams import GamsWorkspace, GamsEngineConfiguration, SolveLink


GAMS_DATA = """

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 /;

"""


GAMS_MODEL = """

Set

   i 'canning plants'

   j 'markets';


Parameter

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

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

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


Scalar

   f     'freight in dollars per case per thousand miles'

   bmult 'demand multiplier';


$if not set gdxincname $abort 'no include file name for data file provided'

$gdxIn %gdxincname%

$load i j a b d f bmult

$gdxIn


$echo "test" > test.txt


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/;


solve transport using lp minimizing z;


Scalar

   ms 'model status'

   ss 'solve status';


display x.l, x.m;

"""


if __name__ == "__main__":

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

    ws = GamsWorkspace(system_directory=sys_dir)


    # set up configuration required for any job on GAMS Engine


    engine_configuration = GamsEngineConfiguration(

        host=os.environ["ENGINE_URL"],

        username=os.environ["ENGINE_USER"],

        password=os.environ["ENGINE_PASSWORD"],

        namespace=os.environ["ENGINE_NAMESPACE"],

    )


    job = ws.add_job_from_string(GAMS_DATA)

    job.run_engine(engine_configuration)

    gdx_file_path = os.path.join(ws.working_directory, "tdata.gdx")

    job.out_db.export(gdx_file_path)

    job = ws.add_job_from_string(GAMS_MODEL)


    opt = ws.add_options()

    opt.defines["gdxincname"] = "tdata"

    opt.all_model_types = "xpress"

    job.run_engine(

        engine_configuration,

        extra_model_files=gdx_file_path,

        engine_options={

            "inex_string": json.dumps({"type": "include", "files": ["*.gdx"]})

        },

        gams_options=opt,

    )

    expected_levels = {

        ("seattle", "new-york"): 0.0,

        ("seattle", "chicago"): 300.0,

        ("seattle", "topeka"): 0.0,

        ("san-diego", "new-york"): 325.0,

        ("san-diego", "chicago"): 0.0,

        ("san-diego", "topeka"): 275.0,

    }


    for rec in job.out_db["x"]:

        print(

            f"x({rec.key(0)},{rec.key(1)}): level={rec.level} marginal={rec.marginal}"

        )

        if expected_levels[tuple(rec.keys)] != rec.level:

            raise Exception("Unexpected results.")


    if os.path.exists(os.path.join(ws.working_directory, "test.txt")):

        raise Exception("Did not expected to find 'test.txt' written by GAMS model supposed to run remotely.")


    cp = ws.add_checkpoint()


    job_a = ws.add_job_from_string(GAMS_DATA)

    job_a.run_engine(engine_configuration)

    opt.defines["gdxincname"] = job_a.out_db.name


    job_b = ws.add_job_from_string(GAMS_MODEL)

    job_b.run_engine(

        engine_configuration, gams_options=opt, databases=job_a.out_db, checkpoint=cp

    )


    for rec in job.out_db["x"]:

        if expected_levels[tuple(rec.keys)] != rec.level:

            raise Exception("Unexpected results.")


    expected_bmult = [

        {"bmult": 0.9, "ms": 1, "ss": 1, "obj": 138.31},

        {"bmult": 1.2, "ms": 4, "ss": 1, "obj": 184.41},

    ]


    # create a new GamsJob that is initialized from the GamsCheckpoint

    for scen in expected_bmult:

        job = ws.add_job_from_string(

            f"bmult={scen['bmult']}; solve transport min z use lp; ms=transport.modelstat; ss=transport.solvestat;",

            cp,

        )

        job.run_engine(engine_configuration)

        print(f"Scenario bmult={scen['bmult']}:")

        print(f"  Modelstatus: {job.out_db['ms'].find_record().value}")

        print(f"  Solvestatus: {job.out_db['ss'].find_record().value}")

        print(f"  Obj: {job.out_db['z'].find_record().level}")


        if job.out_db["bmult"].find_record().value != scen["bmult"]:

            raise Exception("Unexpected bmult.")

        if job.out_db["ms"].find_record().value != scen["ms"]:

            raise Exception("Unexpected model status.")

        if job.out_db["ss"].find_record().value != scen["ss"]:

            raise Exception("Unexpected solve status.")

        if round(job.out_db["z"].find_record().level, 2) != scen["obj"]:

            raise Exception("Unexpected obj.")


    # example how to interrupt Engine job


    ws.gamslib("clad")

    job = ws.add_job_from_file("clad")


    # define an option file for the solver to be used

    option_file1_path = os.path.join(ws.working_directory, "cplex.opt")

    with open(option_file1_path, "w") as f:

        # set relative stopping tolerance to 0 initially

        f.write("epgap 0\n")

        # activate interactive option setting on interrupt

        f.write("interactive 1\n")

        # define new option file to read on interrupt

        f.write("iafile cplex.op2\n")


    # write new Cplex option file

    option_file2_path = os.path.join(ws.working_directory, "cplex.op2")

    with open(option_file2_path, "w") as f:

        f.write("epgap 0.1")


    opt = ws.add_options()

    opt.mip = "cplex"

    opt.optfile = 1

    opt.solvelink = SolveLink.LoadLibrary


    sw = StringIO()


    # run GamsJob job in separate thread

    opt_thread = Thread(

        target=job.run_engine,

        args=(engine_configuration,),

        kwargs={

            "output": sw,

            "extra_model_files": [option_file1_path, option_file2_path, "claddat.gdx"],

            "gams_options": opt,

        },

    )

    opt_thread.start()


    while True:

        if sw.tell() == 0:

            time.sleep(0.5)

            continue

        job.interrupt()

        print("Interrupted Cplex to continue with new option")

        break


    # if job is still running, wait until it is finished

    if opt_thread.is_alive():

        opt_thread.join()

    # check if everything worked as expected

    log = sw.getvalue()

    if not "Interrupted..." in log:

        raise Exception("Expected the solver to be interrupted at least once.")