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 __init__(self, H, msg):
"""
Pulls information from gdxcc about the last encountered error and appends
it to msg.
Positional Arguments:
- H (pointer or None) - SWIG binding pointer to a GDX object
- msg (str) - gdxpds error message
"""
self.msg = msg + "."
if H:
self.msg += " " + gdxcc.gdxErrorStr(H, gdxcc.gdxGetLastError(H))[1] + "."
super().__init__(self.msg)
def __init__(self, filename: str, mode: str = 'r', gams_dir: str = None):
"""Constructor for GdxFile
Args:
filename: str
mode: File open mode: 'r' for reading, 'w' for writing, 'w+' for appending (replaces existing symbol)
gams_dir (optional): Location of GAMS installation directory
Raises:
RuntimeError: Unable to load gdx library, invalid mode
FileNotFoundError: Input file not found
ValueError: Unsupported mode
OSError: Unable to read/write file
Exception: Other errors
"""
self._h = gdxcc.new_gdxHandle_tp() # Create a gdx handle
if gams_dir is None:
ret, err = gdxcc.gdxCreate(self._h, gdxcc.GMS_SSSIZE)
else:
ret, err = gdxcc.gdxCreateD(self._h, gams_dir, gdxcc.GMS_SSSIZE)
if ret == 0:
raise RuntimeError(err)
creator = 'Python {}'.format(sys.version)
self.filename = os.path.abspath(filename)
if mode == 'r':
ret, errno = gdxcc.gdxOpenRead(self._h, self.filename)
elif mode == 'w':
ret, errno = gdxcc.gdxOpenWrite(self._h, self.filename, creator)
elif mode == 'w+' or mode == 'a':
ret, errno = gdxcc.gdxOpenAppend(self._h, self.filename, creator)
# Fallback to creating a new file if not found
if ret == 0 and errno == -100041:
ret, errno = gdxcc.gdxOpenWrite(self._h, self.filename,
creator)
else:
raise ValueError("Unsupported mode '{}'.".format(mode))
self._mode = mode
# Error checking
if ret == 0:
if errno == 2:
raise FileNotFoundError(self.filename)
else:
raise OSError(gdxcc.gdxErrorStr(self._h, errno)[1])
# Set up unique element map
self._UEL_map = {}
def __init__(self, H, msg):
"""
Pulls information from gdxcc about the last encountered error and appends
it to msg.
Parameters
----------
H : pointer or None
SWIG binding pointer to a GDX object
msg : str
gdxpds error message
Attributes
----------
msg : str
msg that is passed in with a gdxErrorStr appended
"""
if H:
msg += ". " + gdxcc.gdxErrorStr(H,
gdxcc.gdxGetLastError(H))[1] + "."
super().__init__(msg)
def gdx_to_list(gams_dir, filename, varname='all', verbose=False):
"""
This function loads the gdx with the results of the simulation
All results are stored in an unordered list
:param gams_dir: Gams working directory
:param filename: Path to the gdx file to be read
:param varname: In case online one variable is needed, specify it name (otherwise specify 'all')
:returns: Dictionary with all the collected values (within lists)
"""
from gdxcc import gdxSymbolInfo, gdxCreateD, gdxOpenRead, GMS_SSSIZE, gdxDataReadDone, new_gdxHandle_tp, \
gdxDataReadStr, gdxFindSymbol, gdxErrorStr, gdxDataReadStrStart, gdxGetLastError
out = {}
tgdx = tm.time()
gdxHandle = new_gdxHandle_tp()
gdxCreateD(gdxHandle, gams_dir, GMS_SSSIZE)
# make sure the file path is properly formatted:
filename = filename.replace('/', os.path.sep).replace(
'\\\\', os.path.sep).replace('\\', os.path.sep)
filename = str(filename) # removing possible unicode formatting
if not os.path.isfile(filename):
logging.critical('Gdx file "' + filename + '" does not exist')
sys.exit(1)
gdxOpenRead(gdxHandle, filename)
if varname == 'all':
# go through all the symbols one by one and add their data to the dict
symNr = 0
SymbolInfo = gdxSymbolInfo(gdxHandle, 0)
while SymbolInfo[0] > 0:
ret, nrRecs = gdxDataReadStrStart(gdxHandle, symNr)
assert ret, "Error in gdx data string" + gdxErrorStr(
gdxHandle, gdxGetLastError(gdxHandle))[1]
res = []
for i in range(nrRecs):
ret, elements, values, afdim = gdxDataReadStr(gdxHandle)
res.append(elements + [values[0]])
out[SymbolInfo[1]] = res
symNr += 1
SymbolInfo = gdxSymbolInfo(gdxHandle, symNr)
else:
# find the number of the required symbol:
ret, symNr = gdxFindSymbol(gdxHandle, varname)
assert ret, "Symbol not found"
ret, nrRecs = gdxDataReadStrStart(gdxHandle, symNr)
assert ret, "Error in gdx data string" + gdxErrorStr(
gdxHandle, gdxGetLastError(gdxHandle))[1]
res = []
for i in range(nrRecs):
ret, elements, values, afdim = gdxDataReadStr(gdxHandle)
res.append(elements + [values[0]])
out[varname] = res
gdxDataReadDone(gdxHandle)
if verbose:
logging.info("Loading gdx file " + filename +
" took {}s".format(tm.time() - tgdx))
return out
def __init__(self, H, msg):
self.msg = msg
if H:
self.msg += ": " + gdxcc.gdxErrorStr(H, gdxcc.gdxGetLastError(H))[1]
def query(self, name, reshape=RESHAPE_DEFAULT, gamsdir=None, filt=None, idval=None):
if __gdxpy_mode__ == GDX_MODE_API:
gdxHandle = self.gdxHandle
ret, symNr = gdxcc.gdxFindSymbol(gdxHandle, name)
assert ret, "Symbol '%s' not found in GDX '%s'" % (name,self.internal_filename)
sinfo = self.get_sid_info(symNr)
dim = sinfo['dim']
# assert dim>0, "Symbol '%s' is a scalar, not supported" % (name)
symType = sinfo['stype']
ret, nrRecs = gdxcc.gdxDataReadStrStart(gdxHandle, symNr)
assert ret, "Error in gdxDataReadStrStart: "+gdxcc.gdxErrorStr(gdxHandle,gdxGetLastError(gdxHandle))[1]
if idval is None:
if symType == gdxcc.GMS_DT_EQU:
idval = gdxcc.GMS_VAL_MARGINAL
else:
idval = gdxcc.GMS_VAL_LEVEL
ifilt = None
vtable = []
rcounter = 0
rowtype = None
if filt != None:
if isinstance(filt,list):
filt = '^({0})$'.format('|'.join([re.escape(x) for x in filt]))
filt_regex = re.compile(filt, re.IGNORECASE)
for i in range(nrRecs):
vrow = [None]*(dim+1)
ret, elements, values, afdim = gdxcc.gdxDataReadStr(gdxHandle)
assert ret, "Error in gdxDataReadStr: "+gdxcc.gdxErrorStr(gdxHandle,gdxGetLastError(gdxHandle))[1]
if (filt != None):
match_filt = False
for e in elements:
m = filt_regex.match(e)
if m != None:
match_filt = True
break
if not match_filt:
continue
d = -1
for d in range(dim):
try:
vrow[d] = int(elements[d])
except:
vrow[d] = elements[d].lower()
vrow[d+1] = values[idval]
vtable.append(vrow)
rcounter += 1
gdxcc.gdxDataReadDone(gdxHandle)
# ifilt = 1
cols = ['s%d' % x for x in range(dim)]+['val',]
#print vtable[:5]
#print cols
df = pd.DataFrame(vtable,columns=cols)
#print df
#if ifilt != None:
# df = df.drop(df.columns[ifilt], axis=1)
#print "%d / %d records read from <%s>" % (rcounter, nrRecs, self.internal_filename)
elif __gdxpy_mode__ == GDX_MODE_SHELL:
cmdline = r'gdxdump.exe {0} symb={1} Format=csv NoHeader'.format(self.internal_filename, name)
p = subprocess.Popen(cmdline, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
# TODO check for return code
# p = subprocess.Popen(cmdline +' | tr "[:upper:]" "[:lower:]"', stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
strdata = p.communicate()[0] #.replace("'.","',").replace(', \r\n','\r\n').replace(" ",",")
sepchar = ','
strdata = strdata.replace('eps','1e-16')
csvfile = StringIO.StringIO(strdata)
#print strdata[:500]
df = pd.read_csv(csvfile,sep=sepchar,quotechar='"',prefix='s',header=None,error_bad_lines=False).dropna()
else:
raise Exception('Function "get_symbols_list" not available outside GDX API/SHELL mode')
#raise e, None, sys.exc_info()[2]
#print_traceback(e)
#print df.columns.values
#print df.columns.values[-1], list(df.columns.values[:-2]), df.columns.values[-2]
#print df
if symType == gdxcc.GMS_DT_SET:
reshape = RESHAPE_SERIES
df = dfreshape(df, reshape)
if symType == gdxcc.GMS_DT_SET:
df = df.index
self.data = df
return df
def get_last_error(context, gdx_handle):
return "Error in {}: {}".format(context, +gdxcc.gdxErrorStr(gdx_handle,gdxGetLastError(gdx_handle))[1])
def _write_symbol(self, symname: str, symbol: _GAMSSymbol):
"""Write a Pandas series to a GAMS Set symbol
Args:
symbol: GAMS symbol object
Raises:
RuntimeError
"""
# Get number of dimensions
dim = symbol.dimension
try:
recs = len(symbol)
except TypeError:
recs = 1
set_has_text = False # TODO
# Begin writing to a symbol
ret = gdxcc.gdxDataWriteStrStart(
self._h,
symname,
symbol.expl_text,
dim,
GMS_DTYPES[symbol._type],
GMS_USERINFO_SET_PARAMETER,
)
if not ret:
raise RuntimeError(
gdxcc.gdxErrorStr(self._h, gdxcc.gdxGetLastError(self._h))[1])
# Define domain
if symbol.domain is not None:
domain = [(d if d is not None else '*') for d in symbol.domain]
else:
domain = dim * ['*']
ret = gdxcc.gdxSymbolSetDomainX(self._h, self._find_symbol(symname),
domain)
if not ret:
raise RuntimeError(
"Unable to set domain for symbol '{}'".format(symname))
# Init value array
value_arr = gdxcc.doubleArray(gdxcc.GMS_VAL_MAX)
if dim == 0: # It’s a scalar
value_arr[GMS_VAL_LEVEL] = float(symbol)
gdxcc.gdxDataWriteStr(self._h, list(), value_arr)
elif isinstance(symbol, GAMSSet):
for key in symbol:
# For sets, register the associated text in the string table and
# store index number as the value
if set_has_text:
pass # TODO
# assoc_text = copy(values[i])
# ret, value_arr[GMS_VAL_LEVEL] = gdxAddSetText(self._h,
# str(assoc_text))
# if not ret:
# warn("Unable to register string '{}' "
# "to string table".format(assoc_text))
else:
value_arr[GMS_VAL_LEVEL] = 0
gdxcc.gdxDataWriteStr(self._h, list(key), value_arr)
elif isinstance(symbol, GAMSParameter):
for key, value in symbol:
value_arr[GMS_VAL_LEVEL] = value
gdxcc.gdxDataWriteStr(self._h, list(key), value_arr)
gdxcc.gdxDataWriteDone(self._h)
def _read_symbol(self, symno: int):
"""Read a GAMS symbol as a Pandas Series object
Args:
symno: Symbol number
Raises:
RuntimeError
"""
# Get symbol info
ret, _sym, dim, symtype = gdxcc.gdxSymbolInfo(self._h, symno)
if not ret:
warn("Symbol not found!")
return None
# Get domain of symbol
domain = [(d if d != '*' else None) for d in self._get_domain(symno)]
if not any(domain):
domain = None
# Get explanatory text
expl_text = self._get_expl_text(symno)
# Get length of longest label
_label_maxlen = gdxcc.gdxSymbIndxMaxLength(self._h, symno)[0]
# Start reading symbol
ret, recs = gdxcc.gdxDataReadStrStart(self._h, symno)
if not ret:
raise Exception(
gdxcc.gdxErrorStr(self._h, gdxcc.gdxGetLastError(self._h))[1])
# Initialize keys and values arrays
keys = recs * [tuple()]
values = recs * [float()]
if gdxcc.gdxSetHasText(self._h, symno):
assoc_texts = recs * [str()]
else:
assoc_texts = None
# Read GDX data
# Code inside the loop is as small as possible for performance,
# so the if statements are outside.
if symtype == GMS_DT_SET and assoc_texts:
for i in range(recs):
_ret, key_arr, value_arr, _afdim = gdxcc.gdxDataReadStr(
self._h)
keys[i] = (key_arr[0] if dim == 1 else tuple(key_arr)
) # Squeze out dimension of 1-dim keys
assoc_texts[i] = self._get_set_assoc_text(
value_arr[GMS_VAL_LEVEL])
elif symtype == GMS_DT_SET and not assoc_texts:
for i in range(recs):
_ret, key_arr, _value_arr, _afdim = gdxcc.gdxDataReadStr(
self._h)
keys[i] = (key_arr[0] if dim == 1 else tuple(key_arr)
) # Squeze out dimension of 1-dim keys
elif symtype == GMS_DT_PAR:
for i in range(recs):
_ret, key_arr, value_arr, _afdim = gdxcc.gdxDataReadStr(
self._h)
keys[i] = (key_arr[0] if dim == 1 else tuple(key_arr)
) # Squeze out dimension of 1-dim keys
val = value_arr[GMS_VAL_LEVEL]
values[i] = SPECIAL_VALUES.get(val, val)
# Done reading
gdxcc.gdxDataReadDone(self._h)
# Construct GAMS symbols and return
if symtype == GMS_DT_SET:
return GAMSSet(keys,
domain,
expl_text=expl_text,
assoc_texts=assoc_texts)
elif symtype == GMS_DT_PAR:
if dim == 0:
return GAMSScalar(values[0], expl_text=expl_text)
else:
return GAMSParameter(dict(zip(keys, values)),
domain=domain,
expl_text=expl_text)
def __init__(self, H, msg):
self.msg = msg
if H:
self.msg += ": " + gdxcc.gdxErrorStr(H, gdxcc.gdxGetLastError(H))[1]
