def read_symbol(self, symbol_name):
if not (self.lazy_load and self.filename):
raise RuntimeError(
"""This feature only works if the gdxdict is initialized in
lazy_load mode, and read has already been called."""
)
if not symbol_name in self:
raise RuntimeError(
"{} is not a symbol in this gdxdict.".format(symbol_name))
H = gdxx.open(self.gams_dir)
assert gdxcc.gdxOpenRead(
H, self.filename)[0], "Couldn't open %s" % filename
sinfo = self.getinfo(symbol_name)
set_map = self.set_map
all_keys = self.all_keys
self.__read_one_symbol(H, sinfo, all_keys)
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
guess_domains(self, set_map, all_keys)
guess_ancestor_domains(self)
self.set_map = set_map
self.all_keys = all_keys
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
if sinfo["dims"] == 0:
read_symbol(H, self, symbol_name, sinfo["typename"], values)
else:
for d in range(sinfo["dims"]-1):
key = elements[d]
keys[d][key] = True
if (len(current_list) < d+2) or (current_list[d+1][0] != key):
current_list = current_list[0:d+1]
if not key in current_list[d][1]:
num_dims_created += 1
current_list[d][1][key] = gdxdim(self)
current_list = current_list + [(key, current_list[d][1][key])]
d = sinfo["dims"]-1
key = elements[d]
keys[d][key] = True
read_symbol(H, current_list[d][1], key, sinfo["typename"], values)
logger.debug("Created {} gdxdims for {} records (ratio = {}). len(current_list) = {}".format(
num_dims_created, records, float(num_dims_created)/float(records), len(current_list)))
#- Write a GDX file ------------------------------------------------------------
def write(self, filename, gams_dir=None):
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenWrite(H, filename, "gdxdict.py")[0], "Couldn't open %s" % filename
# write the universal set
gdxcc.gdxUELRegisterRawStart(H)
for key, key_data in self.universal_items():
def load_specials(gams_dir_finder):
"""
Load special values
Needs to be called after gdxcc is loaded. Populates the module attributes
SPECIAL_VALUES, GDX_TO_NP_SVS, and NP_TO_GDX_SVS.
Parameters
----------
gams_dir_finder : :class:`gdxpds.tools.GamsDirFinder`
"""
global SPECIAL_VALUES
global GDX_TO_NP_SVS
global NP_TO_GDX_SVS
H = gdxcc.new_gdxHandle_tp()
rc = gdxcc.gdxCreateD(H, gams_dir_finder.gams_dir, gdxcc.GMS_SSSIZE)
if not rc:
raise Exception(rc[1])
# get special values
special_values = gdxcc.doubleArray(gdxcc.GMS_SVIDX_MAX)
gdxcc.gdxGetSpecialValues(H, special_values)
SPECIAL_VALUES = []
GDX_TO_NP_SVS = {}
NP_TO_GDX_SVS = {}
for i in range(gdxcc.GMS_SVIDX_MAX):
if i >= len(NUMPY_SPECIAL_VALUES):
break
SPECIAL_VALUES.append(special_values[i])
gdx_val = special_values[i]
GDX_TO_NP_SVS[gdx_val] = NUMPY_SPECIAL_VALUES[i]
NP_TO_GDX_SVS[NUMPY_SPECIAL_VALUES[i]] = gdx_val
gdxcc.gdxFree(H)
def load_gdxcc(gams_dir=None):
if 'pandas' in sys.modules:
logger.warn("Especially on Linux, gdxpds should be imported before " + \
"pandas to avoid a library conflict. Also make sure your " + \
"GAMS directory is listed in LD_LIBRARY_PATH.")
import gdxcc
from gdxpds.tools import GamsDirFinder
finder = GamsDirFinder(gams_dir=gams_dir)
H = gdxcc.new_gdxHandle_tp()
rc = gdxcc.gdxCreateD(H, finder.gams_dir, gdxcc.GMS_SSSIZE)
gdxcc.gdxFree(H)
return
def get_df(file_name, param_name):
ws = gams.GamsWorkspace()
gdxFile = os.path.join(os.getcwd(), file_name)
gdxHandle = gdxcc.new_gdxHandle_tp()
rc = gdxcc.gdxCreate(gdxHandle, gdxcc.GMS_SSSIZE)
assert rc[0],rc[1]
assert gdxcc.gdxOpenRead(gdxHandle, gdxFile)[0]
nrUels = gdxcc.gdxUMUelInfo(gdxHandle)[1]
uelMap = []
for i in range(nrUels+1):
uelMap.append(gdxcc.gdxUMUelGet(gdxHandle, i)[1])
ret, symNr = gdxcc.gdxFindSymbol(gdxHandle, param_name)
assert ret, param_name + " parameter not found"
ret, nrRecs = gdxcc.gdxDataReadRawStart(gdxHandle, symNr)
assert ret, "Error in gdxDataReadRawStart: " + gdxcc.gdxErrorStr(gdxHandle, gdxcc.gdxGetLastError(gdxHandle))[1]
ls = []
for i in range(nrRecs):
ret = gdxcc.gdxDataReadRaw(gdxHandle)
sets = [uelMap[x] for x in ret[1]]
val = ret[2][gdxcc.GMS_VAL_LEVEL]
if val == 5e300:
val = 0
ls.append(sets+[val])
assert not gdxcc.gdxClose(gdxHandle)
assert gdxcc.gdxFree(gdxHandle)
df = pd.DataFrame(ls)
return df
def load_gdxcc(gams_dir=None):
"""
Method to initialize GAMS, especially to load required libraries that can
sometimes conflict with other packages.
Parameters
----------
gams_dir : None or str
if not None, directory containing the GAMS executable
"""
if 'pandas' in sys.modules:
logger.warn("Especially on Linux, gdxpds should be imported before " + \
"pandas to avoid a library conflict. Also make sure your " + \
"GAMS directory is listed in LD_LIBRARY_PATH.")
import gdxcc
from gdxpds.tools import GamsDirFinder
finder = GamsDirFinder(gams_dir=gams_dir)
H = gdxcc.new_gdxHandle_tp()
rc = gdxcc.gdxCreateD(H, finder.gams_dir, gdxcc.GMS_SSSIZE)
gdxcc.gdxFree(H)
return
def write(self, filename, gams_dir=None):
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenWrite(
H, filename, "gdxdict.py")[0], "Couldn't open %s" % filename
# write the universal set
gdxcc.gdxUELRegisterRawStart(H)
for key, key_data in self.universal_items():
gdxcc.gdxUELRegisterRaw(H, key_data['name'])
gdxcc.gdxUELRegisterDone(H)
for k in self:
symbol = self[k]
info = self.getinfo(k)
if info["dims"] == 0:
if not gdxcc.gdxDataWriteStrStart(
H, k, info["description"], 0,
get_type_code(info["typename"]), info["userinfo"]):
raise gdxx.GDX_error(H, "couldn't start writing data")
set_symbol(H, self, k, info["typename"], info["userinfo"],
values, [])
gdxcc.gdxDataWriteDone(H)
else:
if not gdxcc.gdxDataWriteStrStart(
H, k, info["description"], info["dims"],
get_type_code(info["typename"]), info["userinfo"]):
raise gdxx.GDX_error(H, "couldn't start writing data")
domain = []
for d in info["domain"]:
domain.append(d["key"])
if gdxcc.gdxSymbolSetDomain(H, domain) != 1:
raise gdxx.GDX_error(
H, "couldn't set domain for symbol %s to %s" %
(k, domain))
write_symbol(H, info["typename"], info["userinfo"], symbol, [])
gdxcc.gdxDataWriteDone(H)
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
continue
logger.debug("Reading {}. ".format(sinfo['name']) + gdxpds.memory_use_str())
self.__read_one_symbol(H, sinfo, all_keys)
logger.debug("Read {}. ".format(sinfo['name']) + gdxpds.memory_use_str())
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
logger.debug("Closed the gdx file. " + gdxpds.memory_use_str())
guess_domains(self, set_map, all_keys)
guess_ancestor_domains(self)
logger.debug("Finished guessing domains. " + gdxpds.memory_use_str())
if self.lazy_load:
self.set_map = set_map
self.all_keys = all_keys
def read_symbol(self, symbol_name):
if not (self.lazy_load and self.filename):
raise RuntimeError("""This feature only works if the gdxdict is initialized in
lazy_load mode, and read has already been called.""")
def cleanup(self):
gdxcc.gdxFree(self.H)
def read(self, filename, gams_dir=None):
if self.lazy_load:
self.filename = filename
self.gams_dir = gams_dir
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenRead(H, filename)[0], "Couldn't open %s" % filename
logger.debug("Opened the file. " + gdxpds.memory_use_str())
info = gdxx.file_info(H)
for k in info:
if not k in self.file_info:
self.file_info[k] = info[k]
logger.debug("Retrieved the file info. " + gdxpds.memory_use_str())
# read the universal set
uinfo = gdxx.symbol_info(H, 0)
for k in uinfo:
if not k in self.universal_info:
self.universal_info[k] = uinfo[k]
logger.debug("Read the universal set. " + gdxpds.memory_use_str())
ok, records = gdxcc.gdxDataReadStrStart(H, 0)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
key = elements[0]
ret, description, node = gdxcc.gdxGetElemText(
H, int(values[gdxcc.GMS_VAL_LEVEL]))
if ret == 0: description = None
self.add_key(key, description)
all_keys = {}
# Read all the 1-D sets
# Map backwards so we have a map from every set key back to all the sets it's in
set_map = {}
for i in range(1, info["symbol_count"] + 1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1:
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = [{}]
keys = all_keys[symbol_name]
symbol = self[symbol_name]
symbol._gdxdim__read_in = True
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok:
raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
e = elements[0]
read_symbol(H, symbol, e, sinfo["typename"], values)
if not e in set_map: set_map[e] = {}
set_map[e][symbol_name] = True
keys[0][e] = True
# Read all the other symbols
for i in range(1, info["symbol_count"] + 1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1: continue
self.add_symbol(sinfo)
if self.lazy_load and sinfo["dims"] > 0:
continue
logger.debug("Reading {}. ".format(sinfo['name']) +
gdxpds.memory_use_str())
self.__read_one_symbol(H, sinfo, all_keys)
logger.debug("Read {}. ".format(sinfo['name']) +
gdxpds.memory_use_str())
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
logger.debug("Closed the gdx file. " + gdxpds.memory_use_str())
guess_domains(self, set_map, all_keys)
guess_ancestor_domains(self)
logger.debug("Finished guessing domains. " + gdxpds.memory_use_str())
if self.lazy_load:
self.set_map = set_map
self.all_keys = all_keys
def close(self):
h = self.gdxHandle
gdxcc.gdxClose(h)
gdxcc.gdxFree(h)
def close(self):
'''Close Gdx file and free up resources.'''
h = self.gdx_handle
gdxcc.gdxClose(h)
gdxcc.gdxFree(h)
info["type"] = typecode
info["typename"] = typename
# -- Read a gdx file -----------------------------------------------------------
def read(self, filename, gams_dir=None):
if self.lazy_load:
self.filename = filename
self.gams_dir = gams_dir
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenRead(H, filename)[0], "Couldn't open %s" % filename
logger.debug("Opened the file. " + gdxpds.memory_use_str())
info = gdxx.file_info(H)
for k in info:
if not k in self.file_info:
self.file_info[k] = info[k]
logger.debug("Retrieved the file info. " + gdxpds.memory_use_str())
# read the universal set
uinfo = gdxx.symbol_info(H, 0)
for k in uinfo:
if not k in self.universal_info:
self.universal_info[k] = uinfo[k]
logger.debug("Read the universal set. " + gdxpds.memory_use_str())
ok, records = gdxcc.gdxDataReadStrStart(H, 0)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
key = elements[0]
ret, description, node = gdxcc.gdxGetElemText(H, int(values[gdxcc.GMS_VAL_LEVEL]))
if ret == 0: description = None
self.add_key(key, description)
all_keys = {}
# Read all the 1-D sets
# Map backwards so we have a map from every set key back to all the sets it's in
set_map = {}
for i in range(1, info["symbol_count"]+1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1:
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = [{}]
keys = all_keys[symbol_name]
symbol = self[symbol_name]
symbol._gdxdim__read_in = True
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
e = elements[0]
read_symbol(H, symbol, e, sinfo["typename"], values)
if not e in set_map: set_map[e] = {}
set_map[e][symbol_name] = True
keys[0][e] = True
# Read all the other symbols
for i in range(1, info["symbol_count"]+1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1: continue
self.add_symbol(sinfo)
def read(self, filename, gams_dir=None):
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenRead(H, filename)[0], "Couldn't open %s" % filename
info = gdxx.file_info(H)
for k in info:
if not k in self.file_info:
self.file_info[k] = info[k]
# read the universal set
uinfo = gdxx.symbol_info(H, 0)
for k in uinfo:
if not k in self.universal_info:
self.universal_info[k] = uinfo[k]
ok, records = gdxcc.gdxDataReadStrStart(H, 0)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
key = elements[0]
ret, description, node = gdxcc.gdxGetElemText(H, int(values[gdxcc.GMS_VAL_LEVEL]))
if ret == 0: description = None
self.add_key(key, description)
all_keys = {}
# Read all the 1-D sets
# Map backwards so we have a map from every set key back to all the sets it's in
set_map = {}
for i in range(1, info["symbol_count"]+1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1:
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = [{}]
keys = all_keys[symbol_name]
symbol = self[symbol_name]
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
e = elements[0]
read_symbol(H, symbol, e, sinfo["typename"], values)
if not e in set_map: set_map[e] = {}
set_map[e][symbol_name] = True
keys[0][e] = True
# Read all the other symbols
for i in range(1, info["symbol_count"]+1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1: continue
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = []
keys = all_keys[symbol_name]
for d in range(sinfo["dims"]): keys.append({})
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
if sinfo["dims"] == 0:
read_symbol(H, self, symbol_name, sinfo["typename"], values)
else:
symbol = self[sinfo["name"]]
current = symbol
for d in range(sinfo["dims"]-1):
key = elements[d]
keys[d][key] = True
if not key in current:
current[key] = gdxdim(self)
current = current[key]
d = sinfo["dims"]-1
key = elements[d]
keys[d][key] = True
read_symbol(H, current, key, sinfo["typename"], values)
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
guess_domains(self, set_map, all_keys)
guess_ancestor_domains(self)
def __del__(self):
gdxcc.gdxFree(self._h)
def read(self, filename, gams_dir=None):
H = gdxx.open(gams_dir)
assert gdxcc.gdxOpenRead(H, filename)[0], "Couldn't open %s" % filename
info = gdxx.file_info(H)
for k in info:
if not k in self.file_info:
self.file_info[k] = info[k]
# read the universal set
uinfo = gdxx.symbol_info(H, 0)
for k in uinfo:
if not k in self.universal_info:
self.universal_info[k] = uinfo[k]
ok, records = gdxcc.gdxDataReadStrStart(H, 0)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
key = elements[0]
ret, description, node = gdxcc.gdxGetElemText(
H, int(values[gdxcc.GMS_VAL_LEVEL]))
if ret == 0: description = None
self.add_key(key, description)
all_keys = {}
# Read all the 1-D sets
# Map backwards so we have a map from every set key back to all the sets it's in
set_map = {}
for i in range(1, info["symbol_count"] + 1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1:
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = [{}]
keys = all_keys[symbol_name]
symbol = self[symbol_name]
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok:
raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
e = elements[0]
read_symbol(H, symbol, e, sinfo["typename"], values)
if not e in set_map: set_map[e] = {}
set_map[e][symbol_name] = True
keys[0][e] = True
# Read all the other symbols
for i in range(1, info["symbol_count"] + 1):
sinfo = gdxx.symbol_info(H, i)
if sinfo["typename"] == "Set" and sinfo["dims"] == 1: continue
self.add_symbol(sinfo)
symbol_name = sinfo["name"]
all_keys[symbol_name] = []
keys = all_keys[symbol_name]
for d in range(sinfo["dims"]):
keys.append({})
ok, records = gdxcc.gdxDataReadStrStart(H, i)
for i in range(records):
ok, elements, values, afdim = gdxcc.gdxDataReadStr(H)
if not ok: raise gdxx.GDX_error(H, "Error in gdxDataReadStr")
if sinfo["dims"] == 0:
read_symbol(H, self, symbol_name, sinfo["typename"],
values)
else:
symbol = self[sinfo["name"]]
current = symbol
for d in range(sinfo["dims"] - 1):
key = elements[d]
keys[d][key] = True
if not key in current:
current[key] = gdxdim(self)
current = current[key]
d = sinfo["dims"] - 1
key = elements[d]
keys[d][key] = True
read_symbol(H, current, key, sinfo["typename"], values)
gdxcc.gdxClose(H)
gdxcc.gdxFree(H)
guess_domains(self, set_map, all_keys)
guess_ancestor_domains(self)
