apis/examples_python/run__engine_8py_source.html

fromio가져오기문자열IO

가져오기json

가져오기os

가져오기sys

from스레딩가져오기스레드

가져오기시간

from감스가져오기GamsWorkspace, GamsEngineConfiguration, SolveLink


GAMS_DATA ="""

설정

i '통조림 공장' / 시애틀, 샌디에고 /

j 'markets' / 뉴욕, 시카고, 토피카 /;


매개변수

a(i) '경우에 따른 식물 i의 용량'

/시애틀 350

샌디에고 600 /


b(j) '경우에 따라 시장 j의 수요'

/뉴욕 325

시카고 300

토피카 275 /;


테이블 d(i,j) '거리(천 마일)'

뉴욕 시카고 토피카

시애틀 2.5 1.7 1.8

샌디에고 2.5 1.8 1.4;


스칼라

f '1,000마일당 케이스당 운임(달러)' / 90 /

bmult '수요 승수' / 1 /;

"""


GAMS_MODEL ="""

설정

i '통조림 식물'

j '시장';


매개변수

a(i) '경우에 따른 식물 i의 용량'

b(j) '경우에 따라 시장 j의 수요'

d(i,j) '거리(천 마일)';


스칼라

f '1,000마일당 케이스당 달러 단위의 화물'

bmult '수요 승수';


$if 설정되지 않음 gdxincname $abort '제공된 데이터 파일에 대한 포함 파일 이름 없음'

$gdxIn %gdxincname%

$load i j a b d f bmult

$gdxIn


$echo "테스트" > test.txt


매개변수 c(i,j) '케이스당 수천 달러의 운송 비용';

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


변수

x(i,j) '케이스의 배송 수량'

z '총 운송 비용(수천 달러)';


양수 변수 x;


수식

비용 '목적 함수 정의'

supply(i) '공장 i의 공급 제한을 준수하세요'

demand(j) '시장 j의 수요를 충족';


비용.. z =e= 합계((i,j), c(i,j)*x(i,j));


공급(i).. 합계(j, x(i,j)) =l= a(i);


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


모델 전송 /all/;


z를 최소화하는 lp를 사용하여 전송을 해결합니다.


스칼라

ms '모델 상태'

ss '상태 해결';


x.l, x.m 표시;

"""


if__name__ =="__main__":

sys_dir = sys.argv[1]iflen(sys.argv) > 1그밖에 없음

work_dir = sys.argv[2]iflen(sys.argv) > 2그밖에 없음

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


    # 슬롯 사이트 엔진의 모든 작업에 필요한 구성 설정


engine_configuration = GamsEngineConfiguration(

호스트=os.environ["엔진_URL"],

사용자 이름=os.environ["엔진_사용자"],

password=os.environ["엔진_비밀번호"],

네임스페이스=os.environ["ENGINE_NAMESPACE"],

    )


작업 = 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)

작업 = ws.add_job_from_string(GAMS_MODEL)


opt = ws.add_options()

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

opt.all_model_types ="익스프레스"

job.run_engine(

엔진_구성,

extra_model_files=gdx_file_path,

엔진_옵션=

            "inex_string": json.dumps("유형":"포함", "파일": ["*.gdx"]})

},

gams_options=선택,

    )

예상_레벨 =

        ("시애틀", "뉴욕"): 0.0,

        ("시애틀", "시카고"): 300.0,

        ("시애틀", "토피카"): 0.0,

        ("샌디에고", "뉴욕"): 325.0,

        ("샌디에고", "시카고"): 0.0,

        ("샌디에고", "토페카"): 275.0,

}


    forrecinjob.out_db["x"]:

인쇄(

f"x(rec.key(0),rec.key(1)): 레벨=rec.level 한계=rec.marginal"

        )

        ifexpected_levels[tuple(rec.keys)] != Rec.level:

            올림예외("예기치 못한 결과입니다.")


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

        올림예외(

            "원격으로 실행되는 슬롯 사이트 모델로 작성된 'test.txt'를 찾을 것으로 예상하지 못했습니다."

        )


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(

엔진_구성, gams_options=opt, 데이터베이스=job_a.out_db, 체크포인트=cp

    )


    forrecinjob.out_db["x"]:

        ifexpected_levels[tuple(rec.keys)] != Rec.level:

            올림예외("예기치 못한 결과입니다.")


expected_bmult = [

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

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

]


    # GamsCheckpoint에서 초기화되는 새로운 GamsJob 생성

    for장면에expected_bmult:

작업 = ws.add_job_from_string(

f"bmult=scen['bmult']; lp를 사용하여 전송 최소 z 해결; ms=transport.modelstat; ss=transport.solvestat;",

cp,

        )

job.run_engine(engine_configuration)

인쇄(f"시나리오 bmult=scen['bmult']:")

인쇄(f" 모델 상태: job.out_db['ms'].find_record().value")

인쇄(f" 해결 상태: job.out_db['ss'].find_record().value")

인쇄(f" Obj: job.out_db['z'].find_record().level")


        ifjob.out_db["bmult"].find_record().value != 장면["bmult"]:

            올림예외("예기치 못한 bmult.")

        ifjob.out_db["ms"].find_record().value != 장면["ms"]:

            인상예외("예기치 못한 모델 상태입니다.")

        ifjob.out_db["ss"].find_record().value != 장면["ss"]:

            올림예외("예기치 않은 해결 상태입니다.")

        if라운드(job.out_db["z"].find_record().level, 2) != 장면["obj"]:

            올림예외("예기치 않은 개체.")


    # 엔진 작업을 중단하는 방법의 예


ws.gamslib("입은")

작업 = ws.add_job_from_file("입은")


    # 사용할 솔버에 대한 옵션 파일을 정의

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

    와열기(option_file1_path,"w") asf:

        # 처음에는 상대 중지 허용 오차를 0으로 설정

f.write("epgap 0\n")

        # 인터럽트 시 대화형 옵션 설정 활성화

f.write("대화형 1\n")

        # 인터럽트 시 읽을 새 옵션 파일을 정의

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


    # 새 Cplex 옵션 파일 작성

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

    와열기(option_file2_path,"w") asf:

f.write("epgap 0.1")


opt = ws.add_options()

opt.mip ="복합체"

opt.optfile = 1

opt.solvelink = SolveLink.LoadLibrary


sw = StringIO()


    # 별도의 스레드에서 GamsJob 작업 실행

opt_thread = 스레드(

target=job.run_engine,

args=(engine_configuration,),

kwargs=

            "출력": 남,

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

            "gams_options": 선택,

},

    )

opt_thread.start()


    그동안 사실입니다:

        ifsw.tell() == 0:

time.sleep(0.5)

            계속

job.interrupt()

인쇄("새 옵션을 계속하기 위해 Cplex가 중단되었습니다.")

        휴식


    # 작업이 아직 실행 중이면 완료될 때까지 기다리세요

    ifopt_thread.is_alive():

opt_thread.join()

    # 모든 것이 예상대로 작동했는지 확인

로그 = sw.getvalue()

    if 아님 "중단되었습니다..." in로그:

        올림예외("솔버가 적어도 한 번은 중단될 것으로 예상됩니다.")