apis/examples_python/transport__gt_8py_source.html

import os

import sys

from gams import GamsWorkspace, GamsModifier, UpdateAction, VarType

import gams.transfer as gt

import numpy as np


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


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

$gdxIn %gdxincname%

$load i j a b d f

$gdxIn


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


Scalar bmult 'demand multiplier' / 1 /;


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;

"""


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)


    m = gt.Container(system_directory=sys_dir)

    i = m.addSet("i", records=["Seattle", "San-Diego"])

    j = m.addSet("j", records=["New-York", "Chicago", "Topeka"])

    m.addParameter("a", [i], records=np.array([350, 600]))

    m.addParameter("b", [j], records=np.array([325, 300, 275]))

    m.addParameter("d", [i, j], records=np.array([[2.5, 1.7, 1.8], [2.5, 1.8, 1.4]]))

    m.addParameter("f", records=90)


    job = ws.add_job_from_string(GAMS_MODEL)

    opt = ws.add_options()

    opt.defines["gdxincname"] = "gtin.gdx"

    opt.all_model_types = "xpress"

    opt.gdx = "gtout.gdx"


    m.write(os.path.join(ws.working_directory, opt.defines["gdxincname"]))

    cp = ws.add_checkpoint()

    job.run(gams_options=opt, checkpoint=cp, create_out_db=False)

    job_out = gt.Container(os.path.join(ws.working_directory, opt.gdx), sys_dir)


    # create a GamsModelInstance and solve it multiple times with different scalar bmult

    mi = cp.add_modelinstance()

    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

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


    m = gt.Container(system_directory=sys_dir)

    gt_bmult = m.addParameter("bmult", records=1.0)

    for b in bmultlist:

        gt_bmult.setRecords(b)

        m.write(mi.sync_db)

        mi.solve()

        m_out = gt.Container(mi.sync_db, sys_dir)

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

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

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

        print(f"  Obj: {m_out.data['z'].records['level'].iloc[0]}")


    # create a GamsModelInstance and solve it with single links in the network blocked

    mi = cp.add_modelinstance()

    x = mi.sync_db.add_variable("x", 2, VarType.Positive)

    xup = mi.sync_db.add_parameter("xup", 2, "upper bound on x")


    # instantiate the GamsModelInstance and pass a model definition and GamsModifier to declare upper bound of X mutable

    mi.instantiate("transport use lp min z", GamsModifier(x, UpdateAction.Upper, xup))

    mi.solve()


    m = gt.Container(system_directory=sys_dir)

    gt_xup = m.addParameter("xup", ["i", "j"])

    for i in job_out.data["i"].records["uni"]:

        for j in job_out.data["j"].records["uni"]:

            gt_xup.setRecords([(i, j, -0.0)])  # -0.0 turns the 0 into an EPS

            m.write(mi.sync_db)

            mi.solve()

            m_out = gt.Container(mi.sync_db, sys_dir)

            print(f"Scenario link blocked: {i} - {j}")

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

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

            print(f"  Obj: {m_out.data['z'].records['level'].iloc[0]}")