def config_test_1(self):
'''Set config after-creation of format'''
ff = FortranRecordWriter('(2I10)')
result = ff.write([0, 0, 0, 0])
self.assertEqual(result, ' 0 0\n 0 0')
config.RECORD_SEPARATOR = '|'
result = ff.write([0, 0, 0, 0])
self.assertEqual(result, ' 0 0| 0 0')
def __init__(self, name, fmt, default, type_, docstring):
self.name = name
if fmt is None: self.fmt = DummyRecordWriter()
else: self.fmt = FortranRecordWriter(fmt)
self.type_ = type_
self.__doc__ = docstring
# Duplicate None if element is multivalued
if default is None and isinstance(type_, tuple):
default = (None,)*len(type_)
self.default = default
def write_to_file(self, output_fn, molecule, write_coords_in_bohr=True):
# Numeric formats specified in resp input specification
# http://upjv.q4md-forcefieldtools.org/RED/resp/#other3
header_format = FortranRecordWriter('2I5')
atoms_format = FortranRecordWriter('17X,3E16.7')
esp_points_format = FortranRecordWriter('1X,4E16.7')
with open(output_fn, 'x') as f:
f.write(
header_format.write([len(molecule),
len(self.points)]) + "\n")
for atom in molecule:
if write_coords_in_bohr:
coords = [
atom_coord / angstrom_per_bohr
for atom_coord in atom.coords
]
else:
coords = atom.coords
f.write(atoms_format.write(coords) + "\n")
for point_coords, esp_val in zip(self.points, self.values):
if write_coords_in_bohr:
point_coords = [
point_coord / angstrom_per_bohr
for point_coord in point_coords
]
f.write(
esp_points_format.write([esp_val] + point_coords) + "\n")
def _write_modified_respin(respin_type, molecule, ivary_list, charge, iuniq,
fn_out, read_input_charges):
with open(fn_out, 'w') as out:
out.write(_get_respin_content(respin_type, read_input_charges))
numbers = FortranRecordWriter('2I5')
# `charge, iuniq` line
print(numbers.write([charge, iuniq]), file=out)
for atom, ivary in zip(molecule, ivary_list):
print(numbers.write([atom.atomic_no, ivary]), file=out)
print(file=out)
def _write_modified_respin(respin_type, molecule, ivary_list, charge, iuniq,
fn_out, read_input_charges):
with open(fn_out, 'w') as out:
out.write(_get_respin_content(respin_type, read_input_charges))
numbers = FortranRecordWriter('2I5')
# `charge, iuniq` line
print(numbers.write([charge, iuniq]), file=out)
for atom, ivary in zip(molecule, ivary_list):
print(numbers.write([atom.atomic_no, ivary]), file=out)
print(file=out)
def _read_top(self, fn, f, line):
top_line_format_in_esp = FortranRecordWriter('2I5')
if line == " ESP FILE - ATOMIC UNITS":
return 'Gaussian'
try:
_a, _b = line.split()
except ValueError:
self.raiseInputFormatError(fn)
if line == top_line_format_in_esp.write([int(_a), int(_b)]):
return 'repESP'
else:
self.raiseInputFormatError(fn)
def _read_top(self, fn, f, line):
top_line_format_in_esp = FortranRecordWriter('2I5')
if line == " ESP FILE - ATOMIC UNITS":
return 'Gaussian'
try:
_a, _b = line.split()
except ValueError:
self.raiseInputFormatError(fn)
if line == top_line_format_in_esp.write([int(_a), int(_b)]):
return 'repESP'
else:
self.raiseInputFormatError(fn)
def main():
# T [GeV] partitions for piecewise function
T = np.linspace(0.005, 0.800, 1000)
Tlo = T[T < 0.155]
#Tlo = T[T < 0.110]
Tmid = T[(T >= 0.155) & (T < 0.18)]
#Tmid = T[(T >= 0.110) & (T < 0.130)]
Thi = T[T >= 0.18]
#Thi = T[T >= 0.130]
# evaluate trace anomaly (e-3p)/T**4 on temperature intervals
e3p_T4_lo = urqmd_e3p_T4(Tlo)
z = np.linspace(0, 1, Tmid.size)
s = 6*z**5 - 15*z**4 + 10*z**3
e3p_T4_mid = (1-s)*urqmd_e3p_T4(Tmid) + s*s95_e3p_T4(Tmid)
e3p_T4_hi = s95_e3p_T4(Thi)
e3p_T4 = np.concatenate([e3p_T4_lo, e3p_T4_mid, e3p_T4_hi])
# (e-3p)/T**4, p/T**4, e/T**4 and s/T**3
p_T4_interp = Spline(T, e3p_T4/T).antiderivative()
e_T4 = e3p_T4 + 3*p_T4_interp(T)
s_T3 = e_T4 + p_T4_interp(T)
# e [GeV/fm**3], p [GeV/fm**3], s [1/fm**3]
e = e_T4*T**4/hbarc**3
p = p_T4_interp(T)*T**4/hbarc**3
s = s_T3*T**3/hbarc**3
# express as functions of energy density
p_interp = Spline(e, p)
s_interp = Spline(e, s)
T_interp = Spline(e, T)
# e output mesh: GeV/fm**3
#e_table = np.arange(1,311000,2)*1e-3
e_table = np.exp(np.linspace(-6.9078,6.476972,1000))
p_table = p_interp(e_table)
s_table = s_interp(e_table)
T_table = T_interp(e_table)
# print to file in fortran format
line = FortranRecordWriter('(4E15.6)')
with open('s95.dat','w') as wf:
for i in range(len(e_table)):
wf.write(line.write([e_table[i], p_table[i], s_table[i], T_table[i]])+"\n")
def fort_write(fobj, formatstr, values, debug=False):
vals = list(flatten(values))
vals = [v for v in vals if v is not None]
if debug:
print('--- writing ---')
try:
print('file: ' + fobj.name)
except AttributeError:
print('file: console')
print('fmt: ' + formatstr)
print('values: ')
print(vals)
frw = FortranRecordWriter(formatstr)
line = frw.write(vals)
if fobj is None:
print(line)
else:
fobj.write(line + '\n')
def __init__(self, format, fields, fixed_fields=(), name=None,
post_read_hook=None):
self._fields = fields
self._fixed_fields = tuple(fixed_fields)
self._reader = FortranRecordReader(format)
self._writer = FortranRecordWriter(format)
self.name = name
self.post_read_hook = post_read_hook
self.data = {}
for f in fields:
if f is not None:
self.data[f] = None
def write_to_file(self, output_fn, molecule, write_coords_in_bohr=True):
# Numeric formats specified in resp input specification
# http://upjv.q4md-forcefieldtools.org/RED/resp/#other3
header_format = FortranRecordWriter('2I5')
atoms_format = FortranRecordWriter('17X,3E16.7')
esp_points_format = FortranRecordWriter('1X,4E16.7')
with open(output_fn, 'x') as f:
f.write(header_format.write([len(molecule),
len(self.points)]) + "\n")
for atom in molecule:
if write_coords_in_bohr:
coords = [atom_coord/angstrom_per_bohr for atom_coord in
atom.coords]
else:
coords = atom.coords
f.write(atoms_format.write(coords) + "\n")
for point_coords, esp_val in zip(self.points, self.values):
if write_coords_in_bohr:
point_coords = [point_coord/angstrom_per_bohr for
point_coord in point_coords]
f.write(esp_points_format.write([esp_val] + point_coords)+"\n")
def fortranWriteLine(data, stream, fformat):
"Write `data` to `stream` according to Fortran format `fformat`."
fmt = FortranRecordWriter(fformat)
stream.write(fmt.write(data))
stream.write('\n')
return
def generate_fort_2(polytropic_index, jmax, kmax, jout, kout, log_central_density, iteration, mass_star, xcut,
xwidth, xnorm, type):
"""
Generate fort.2 model file for CHYMERA Code
:param polytropic_index: Polytropic index of star
:param jmax: radial grid size
:param kmax: vertical grid size
:param jout: radial size of star+disk. negative for just the disk
:param kout: polar radius of star
:param log_central_density: log of central density
:param iteration: iteration parameter for model
:param mass_star: point mass in center of star
:param xcut: width of star in model
:param xwidth: percentage of mass in the disk
:param xnorm: TODO: Figure these x things out
:param type: Currently either 'RWI' for Rossby Wave Instability, anything else for general disk model
:return: A model file for input into the CHYMERA computational fluid dynamics code to run
"""
jmax2 = jmax + 2
jmax1 = jmax + 1
if type == 'RWI':
print('Using Rossby Wave equations for disk')
denny = [[0 for x in range(jmax2)] for x in range(jmax2)]
anggy = [[0 for x in range(jmax1)] for x in range(jmax1)]
constants_array = []
header_line = ""
with open("fort.2", "r") as example_file:
header_line = example_file.readline()
print(header_line)
constants_array = header_line.split(" ")
# Remove the first empty parts that come from the '3X' Fortran Formatting
del constants_array[0]
del constants_array[0]
del constants_array[0]
del constants_array[0]
print(constants_array)
# Convert to floats
for element in range(len(constants_array)):
constants_array[element] = float(constants_array[element])
print(constants_array)
'''
Format of first line in fort.2 file
PINDEX,CON2,RRR2,OMCEN,DENCEN,TOVERW,ROF3N,ZOF3N,
& A1NEWZ,JREQ,KZPOL
'''
# Get the density array
for column in range(jmax2):
for row in range(jmax2):
denny[row][column] = surface_density_profile(amplitude, row + 1, r_nought, delta_r, h, column + 1, alpha,
constants_array[0], jout, constants_array[6],
constants_array[7])
# Get angular momentum array
for column in range(jmax1):
for row in range(jmax1):
anggy[row][column] = angular_momentum(row + 1, constants_array[6], column + 1, constants_array[7],
denny[row][column], g, mass_star, h=h)
print("Length of Anggy: " + str(len(anggy)))
with open("temp", 'w') as model_file:
model_file.write(header_line)
fortran_writer = FortranRecordWriter('8(1PE10.3,2X)')
# Write header line
# Fortran saves out arrays column first, so first row in file would be the first entry in each row in array
# Each line is composed of 8 floating point with 22 spaces with 15 after the decimal place, then two spaces
# Writing density array to fort.2
temp_denny = []
for column in range(jmax2):
for row in range(jmax2):
temp_denny.append(denny[column][row])
''' if len(temp_denny) == 8:
writer.writerow(temp_denny)
temp_denny = []
if row == jmax1 and column == jmax1:
writer.writerow(temp_denny)
temp_denny = []'''
output_text = fortran_writer.write(temp_denny)
output_text += "\n"
model_file.write(output_text)
# Writing the angular momentum array to fort.2
# Repeat what was done for the denny array
temp_anggy = []
for column in range(jmax1):
for row in range(jmax1):
temp_anggy.append(anggy[column][row])
print("Length of Temp Anggy: " + str(len(temp_anggy)))
output_text = fortran_writer.write(temp_anggy)
output_text += "\n"
model_file.write(output_text)
# TODO Input coordinates of points into RWI equations and output them with 8 density points per line
# TODO Then for specific angular momentum, same thing
else:
print('Using normal equations for disk')
def config_test_2(self):
'''RECORD_SEPARATOR = |'''
config.RECORD_SEPARATOR = '|'
result = FortranRecordWriter('(2I10)').write([0, 0, 0, 0])
self.assertEqual(result, ' 0 0| 0 0')
def dump_charges_to_qout(molecule, charge_type, filename):
line = FortranRecordWriter("8F10.6")
charges = [atom.charges[charge_type] for atom in molecule]
with open(filename, 'w') as f:
print(line.write(charges), file=f)
def __init__(self, format_string, strip_strings=True):
"""
Sets the format string and determines how we will read and write
strings using this format
"""
self.format = format_string
self.strip_strings = strip_strings # for ease of copying
# Define a function that processes all arguments prior to adding them to
# the returned list. By default, do nothing, but this allows us to
# optionally strip whitespace from strings.
self.process_method = lambda x: x
if FortranFormat.strre.match(format_string):
rematch = FortranFormat.strre.match(format_string)
# replace our write() method with write_string to force left-justify
self.type, self.write = str, self._write_string
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%s'
# See if we want to strip the strings
if strip_strings: self.process_method = lambda x: x.strip()
elif FortranFormat.intre.match(format_string):
self.type = int
rematch = FortranFormat.intre.match(format_string)
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%%%dd' % self.itemlen
elif FortranFormat.floatre.match(format_string):
self.type = float
rematch = FortranFormat.floatre.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
elif FortranFormat.floatre2.match(format_string):
self.type = float
rematch = FortranFormat.floatre2.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
else:
# We tried... now just use the fortranformat package
self._reader = FortranRecordReader(format_string)
self._writer = FortranRecordWriter(format_string)
self.write = self._write_ffwriter
self.read = self._read_ffreader
def __init__(self, format_string, strip_strings=True):
"""
Sets the format string and determines how we will read and write
strings using this format
"""
self.format = format_string
self.strip_strings = strip_strings # for ease of copying
# Define a function that processes all arguments prior to adding them to
# the returned list. By default, do nothing, but this allows us to
# optionally strip whitespace from strings.
self.process_method = lambda x: x
if FortranFormat.strre.match(format_string):
rematch = FortranFormat.strre.match(format_string)
# replace our write() method with write_string to force left-justify
self.type, self.write = str, self._write_string
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%s'
# See if we want to strip the strings
if strip_strings: self.process_method = lambda x: x.strip()
elif FortranFormat.intre.match(format_string):
self.type = int
rematch = FortranFormat.intre.match(format_string)
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%%%dd' % self.itemlen
elif FortranFormat.floatre.match(format_string):
self.type = float
rematch = FortranFormat.floatre.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
elif FortranFormat.floatre2.match(format_string):
self.type = float
rematch = FortranFormat.floatre2.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
else:
# We tried... now just use the fortranformat package
self._reader = FortranRecordReader(format_string)
self._writer = FortranRecordWriter(format_string)
self.write = self._write_ffwriter
self.read = self._read_ffreader
class DataCard:
""" Class to implement a line of generalized ATP/Fortran style input records
format is a format string suitable for the fortranformat module.
fields is a list of field names for indexing the data dict. Field names
will usually be strings, but could be integers or floats in the
case of matching fixed_fields.
fixed_fields is an iterable of field indices that have fixed values.
The expected value for the field should be the field name in the
fields list.
post_read_hook is an optional parameter indicating a function to be
called after reading lines into the DataCard.
Data in the line is internally represented using a dict.
format and fields should not be changed after initialization.
Reads only one line, but should be passed an interable of lines.
"""
def __init__(self, format, fields, fixed_fields=(), name=None,
post_read_hook=None):
self._fields = fields
self._fixed_fields = tuple(fixed_fields)
self._reader = FortranRecordReader(format)
self._writer = FortranRecordWriter(format)
self.name = name
self.post_read_hook = post_read_hook
self.data = {}
for f in fields:
if f is not None:
self.data[f] = None
def read(self, lines):
""" Read in datalines with validation prior to populating data. """
if not self.match(lines):
# This should raise an exception and will help
# identify where in the stack the exception occured.
tmp = copy.deepcopy(self)
tmp._read(lines)
self._read(lines)
def _read(self, lines):
line = lines[0]
data = self._reader.read(line)
for f in self._fixed_fields:
if data[f] != self._fields[f]:
raise ValueError('Fixed field with wrong value: ' + data[f] +
'/' + self._fields[f])
for f, d in zip(self._fields, data):
if f is not None:
self.data[f] = d
if self.post_read_hook is not None:
self.post_read_hook(self)
return self
def write(self):
data = [self.data[f] if f is not None else None for f in self._fields]
return self._writer.write(data)
def match(self, lines):
""" Checks if text lines match record type. Does not modify card data.
"""
tmp = copy.deepcopy(self)
try:
tmp._read(lines)
except ValueError:
return False
return True
def num_lines(self):
return 1
def dump_charges_to_qout(molecule, charge_type, filename):
line = FortranRecordWriter("8F10.6")
charges = [atom.charges[charge_type] for atom in molecule]
with open(filename, 'w') as f:
print(line.write(charges), file=f)
class ValueDescriptor:
def __init__(self, name, fmt, default, type_, docstring):
self.name = name
if fmt is None: self.fmt = DummyRecordWriter()
else: self.fmt = FortranRecordWriter(fmt)
self.type_ = type_
self.__doc__ = docstring
# Duplicate None if element is multivalued
if default is None and isinstance(type_, tuple):
default = (None,)*len(type_)
self.default = default
def __get__(self, instance, owner):
"""Return with formatting applied."""
if self.name in instance._values:
value = instance._values[self.name]
else:
value = self.default
if self.ismultivalue:
return "".join(map(self._str_value, value))
return self._str_value(value)
def __set__(self, instance, value):
self._check_type(value)
instance._values[self.name] = value
def _check_type(self, value):
"""Typecheck for values. Every type accepts None."""
def isok(v, t):
return (v is None
or (isinstance(t, set) and v in t)
or (isinstance(t, range) and t.start <= v < t.stop)
or isinstance(v, t)
)
# All types must match for a tuple
if self.ismultivalue:
matches = all(isok(v, t) for v, t in zip(value, self.type_))
else:
matches = isok(value, self.type_)
if not matches:
err = "Value {} is not of type {} or None.".format(
value, self.type_)
raise TypeError(err)
@property
def ismultivalue(self):
return isinstance(self.type_, tuple)
def _str_value(self, value):
if value is None:
return " "*self._format_width()
return self.fmt.write([value])
def _format_width(self):
"""With of the Fortran format.
Necessary for blank fields. Implementation is more of a guess than
anything but good enough for this application.
"""
total = 0
for item in self.fmt._eds:
repeat = getattr(item, "num_chars", None)
if repeat is None: repeat = getattr(item, "repeat", 1)
if repeat is None: repeat = 1
total = total + repeat*getattr(item, "width", 1)
return total
def reversion_output_test_4(self):
line = FortranRecordWriter("('[', 3F4.1, ']')")
result = """[ 1.0 1.0 1.0]
[ 1.0 1.0 1.0]"""
self.assertEqual(line.write([1.0, 1.0, 1.0, 1.0, 1.0, 1.0]), result)
class FortranFormat(object):
"""
Processes Fortran format strings according to the Fortran specification for
such formats. This object handles reading and writing data with any valid
Fortran format. It does this by using the `fortranformat` project
[https://bitbucket.org/brendanarnold/py-fortranformat].
However, while `fortranformat` is very general and adheres well to the
standard, it is very slow. As a result, simple, common format strings have
been optimized and processes reads and writes between 3 and 5 times faster.
The format strings (case-insensitive) of the following form (where # can be
replaced by any number) are optimized:
- #E#.#
- #D#.#
- #F#.#
- #(F#.#)
- #a#
- #I#
Parameters
----------
format_string : str
The Fortran Format string to process
strip_strings : bool=True
If True, strings are stripped before being processed by stripping
(only) trailing whitespace
"""
strre = re.compile(r'(\d+)?a(\d+)$', re.I)
intre = re.compile(r'(\d+)?i(\d+)$', re.I)
floatre = re.compile(r'(\d+)?[edf](\d+)\.(\d+)$', re.I)
floatre2 = re.compile(r'(\d+)?\([edf](\d+)\.(\d+)\)$', re.I)
#===================================================
def __init__(self, format_string, strip_strings=True):
"""
Sets the format string and determines how we will read and write
strings using this format
"""
self.format = format_string
self.strip_strings = strip_strings # for ease of copying
# Define a function that processes all arguments prior to adding them to
# the returned list. By default, do nothing, but this allows us to
# optionally strip whitespace from strings.
self.process_method = lambda x: x
if FortranFormat.strre.match(format_string):
rematch = FortranFormat.strre.match(format_string)
# replace our write() method with write_string to force left-justify
self.type, self.write = str, self._write_string
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%s'
# See if we want to strip the strings
if strip_strings: self.process_method = lambda x: x.strip()
elif FortranFormat.intre.match(format_string):
self.type = int
rematch = FortranFormat.intre.match(format_string)
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%%%dd' % self.itemlen
elif FortranFormat.floatre.match(format_string):
self.type = float
rematch = FortranFormat.floatre.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
elif FortranFormat.floatre2.match(format_string):
self.type = float
rematch = FortranFormat.floatre2.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
else:
# We tried... now just use the fortranformat package
self._reader = FortranRecordReader(format_string)
self._writer = FortranRecordWriter(format_string)
self.write = self._write_ffwriter
self.read = self._read_ffreader
#===================================================
def __copy__(self):
return type(self)(self.format, self.strip_strings)
#===================================================
def __str__(self):
return self.format
#===================================================
def write(self, items, dest):
"""
Writes an iterable of data (or a single item) to the passed file-like
object
Parameters
----------
items : iterable or single float/str/int
These are the objects to write in this format. The types of each
item should match the type specified in this Format for that
argument
dest : file or file-like
This is the file to write the data to. It must have a `write` method
or an AttributeError will be raised
Notes
-----
This method may be replaced with _write_string (for #a#-style formats)
or _write_ffwriter in the class initializer if no optimization is
provided for this format, but the call signatures and behavior are the
same for each of those functions.
"""
if hasattr(items, '__iter__') and not isinstance(items, string_types):
mod = self.nitems - 1
for i, item in enumerate(items):
dest.write(self.fmt % item)
if i % self.nitems == mod:
dest.write('\n')
if i % self.nitems != mod:
dest.write('\n')
else:
dest.write(self.fmt % item)
dest.write('\n')
#===================================================
def _write_string(self, items, dest):
""" Writes a list/tuple of strings """
if hasattr(items, '__iter__') and not isinstance(items, string_types):
mod = self.nitems - 1
for i, item in enumerate(items):
dest.write((self.fmt % item).ljust(self.itemlen))
if i % self.nitems == mod:
dest.write('\n')
if i % self.nitems != mod:
dest.write('\n')
else:
dest.write((self.fmt % item).ljust(self.itemlen))
dest.write('\n')
#===================================================
def _read_nostrip(self, line):
"""
Reads the line and returns converted data. Special-cased for flags that
may contain 'blank' data. ugh.
"""
line = line.rstrip('\n')
nitems = int(ceil(len(line) / self.itemlen))
ret = [0 for i in range(nitems)]
start, end = 0, self.itemlen
for i in range(nitems):
ret[i] = self.process_method(self.type(line[start:end]))
start = end
end += self.itemlen
return ret
#===================================================
def read(self, line):
""" Reads the line and returns the converted data """
line = line.rstrip()
nitems = int(ceil(len(line) / self.itemlen))
ret = [0 for i in range(nitems)]
start, end = 0, self.itemlen
for i in range(nitems):
ret[i] = self.process_method(self.type(line[start:end]))
start = end
end += self.itemlen
return ret
#===================================================
def _read_ffreader(self, line):
""" Reads the line and returns the converted data """
return self._reader.read(line.rstrip())
#===================================================
def _write_ffwriter(self, items, dest):
dest.write('%s\n' % self._writer.write(items))
def fortranWriteLine(data, stream, fformat):
"Write `data` to `stream` according to Fortran format `fformat`."
fmt = FortranRecordWriter(fformat)
stream.write(fmt.write(data))
stream.write('\n')
return
class FortranFormat(object):
"""
Processes Fortran format strings according to the Fortran specification for
such formats. This object handles reading and writing data with any valid
Fortran format. It does this by using the `fortranformat` project
[https://bitbucket.org/brendanarnold/py-fortranformat].
However, while `fortranformat` is very general and adheres well to the
standard, it is very slow. As a result, simple, common format strings have
been optimized and processes reads and writes between 3 and 5 times faster.
The format strings (case-insensitive) of the following form (where # can be
replaced by any number) are optimized:
- #E#.#
- #D#.#
- #F#.#
- #(F#.#)
- #a#
- #I#
Parameters
----------
format_string : str
The Fortran Format string to process
strip_strings : bool=True
If True, strings are stripped before being processed by stripping
(only) trailing whitespace
"""
strre = re.compile(r'(\d+)?a(\d+)$', re.I)
intre = re.compile(r'(\d+)?i(\d+)$', re.I)
floatre = re.compile(r'(\d+)?[edf](\d+)\.(\d+)$', re.I)
floatre2 = re.compile(r'(\d+)?\([edf](\d+)\.(\d+)\)$', re.I)
#===================================================
def __init__(self, format_string, strip_strings=True):
"""
Sets the format string and determines how we will read and write
strings using this format
"""
self.format = format_string
self.strip_strings = strip_strings # for ease of copying
# Define a function that processes all arguments prior to adding them to
# the returned list. By default, do nothing, but this allows us to
# optionally strip whitespace from strings.
self.process_method = lambda x: x
if FortranFormat.strre.match(format_string):
rematch = FortranFormat.strre.match(format_string)
# replace our write() method with write_string to force left-justify
self.type, self.write = str, self._write_string
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%s'
# See if we want to strip the strings
if strip_strings: self.process_method = lambda x: x.strip()
elif FortranFormat.intre.match(format_string):
self.type = int
rematch = FortranFormat.intre.match(format_string)
nitems, itemlen = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.fmt = '%%%dd' % self.itemlen
elif FortranFormat.floatre.match(format_string):
self.type = float
rematch = FortranFormat.floatre.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
elif FortranFormat.floatre2.match(format_string):
self.type = float
rematch = FortranFormat.floatre2.match(format_string)
nitems, itemlen, num_decimals = rematch.groups()
if nitems is None:
self.nitems = 1
else:
self.nitems = int(nitems)
self.itemlen = int(itemlen)
self.num_decimals = int(num_decimals)
if 'F' in format_string.upper():
self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
else:
self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)
else:
# We tried... now just use the fortranformat package
self._reader = FortranRecordReader(format_string)
self._writer = FortranRecordWriter(format_string)
self.write = self._write_ffwriter
self.read = self._read_ffreader
#===================================================
def __copy__(self):
return type(self)(self.format, self.strip_strings)
#===================================================
def __str__(self):
return self.format
#===================================================
def write(self, items, dest):
"""
Writes an iterable of data (or a single item) to the passed file-like
object
Parameters
----------
items : iterable or single float/str/int
These are the objects to write in this format. The types of each
item should match the type specified in this Format for that
argument
dest : file or file-like
This is the file to write the data to. It must have a `write` method
or an AttributeError will be raised
Notes
-----
This method may be replaced with _write_string (for #a#-style formats)
or _write_ffwriter in the class initializer if no optimization is
provided for this format, but the call signatures and behavior are the
same for each of those functions.
"""
if hasattr(items, '__iter__') and not isinstance(items, basestring):
mod = self.nitems - 1
for i, item in enumerate(items):
dest.write(self.fmt % item)
if i % self.nitems == mod:
dest.write('\n')
if i % self.nitems != mod:
dest.write('\n')
else:
dest.write(self.fmt % item)
dest.write('\n')
#===================================================
def _write_string(self, items, dest):
""" Writes a list/tuple of strings """
if hasattr(items, '__iter__') and not isinstance(items, basestring):
mod = self.nitems - 1
for i, item in enumerate(items):
dest.write((self.fmt % item).ljust(self.itemlen))
if i % self.nitems == mod:
dest.write('\n')
if i % self.nitems != mod:
dest.write('\n')
else:
dest.write((self.fmt % item).ljust(self.itemlen))
dest.write('\n')
#===================================================
def _read_nostrip(self, line):
"""
Reads the line and returns converted data. Special-cased for flags that
may contain 'blank' data. ugh.
"""
line = line.rstrip('\n')
nitems = int(ceil(len(line) / self.itemlen))
ret = [0 for i in xrange(nitems)]
start, end = 0, self.itemlen
for i in xrange(nitems):
ret[i] = self.process_method(self.type(line[start:end]))
start = end
end += self.itemlen
return ret
#===================================================
def read(self, line):
""" Reads the line and returns the converted data """
line = line.rstrip()
nitems = int(ceil(len(line) / self.itemlen))
ret = [0 for i in xrange(nitems)]
start, end = 0, self.itemlen
for i in xrange(nitems):
ret[i] = self.process_method(self.type(line[start:end]))
start = end
end += self.itemlen
return ret
#===================================================
def _read_ffreader(self, line):
""" Reads the line and returns the converted data """
return self._reader.read(line.rstrip())
#===================================================
def _write_ffwriter(self, items, dest):
dest.write('%s\n' % self._writer.write(items))
def config_test_1(self):
'''Default RECORD_SEPARATOR ('\n')'''
ff = FortranRecordWriter('(2I10)')
result = ff.write([0, 0, 0, 0])
self.assertEqual(result, ' 0 0\n 0 0')
def default_hitran(ExoCrossline):
"""
Function formats line into default HITRAN format
:param line: input line from file that comes from ExoMol to HITRAN format (ExoCross)
:return: line in HITRAN format
"""
# Following lines get parameters
molecule_id, iso_id = get_id(ExoCrossline)
frequency = get_freq_exo(ExoCrossline)
intensity = get_intensity_exo(ExoCrossline)
einstein_coeff = get_einstein_coeff(ExoCrossline)
broadening_air, broadeing_self = get_broadening(ExoCrossline)
energy = get_exo_energy(ExoCrossline)
n_air = get_n_air(ExoCrossline)
delta_air = get_delta_air(ExoCrossline)
global_upper, global_lower = get_global_qn(ExoCrossline)
local_upper, local_lower = get_local_qn(ExoCrossline)
branch = get_branch_exo(ExoCrossline)
upper_parity, lower_parity = get_parity_exo(ExoCrossline)
error_indices1, error_indices2, error_indices3, error_indices4, error_indices5, error_indices6 = set_error(
2, 5, 0, 0, 0, 0, 0)
ref1, ref2, ref3, ref4, ref5, ref6 = set_ref(10, 4, 0, 0, 0, 0)
g_upper, g_lower = get_g(ExoCrossline)
space1 = ' '
space2 = ' '
line_mixing_flag = ' '
newline = FortranRecordWriter(
'(I2,I1,F12.6,E10.3,E10.3,F5.4,F5.3,F10.4,F4.2,F8.6,A15,A15,10X,A5,5X,A1,I3,A1,A5,6I1,6I2,A1,F7.1,F7.1)'
)
# Set up line with chosen parameters (order and type are important)
line1 = molecule_id, iso_id, frequency, intensity, einstein_coeff, broadening_air, broadeing_self, energy, n_air,\
delta_air, global_upper,global_lower,space1,branch,local_lower,lower_parity,space2,error_indices1, error_indices2,\
error_indices3, error_indices4, error_indices5, error_indices6,ref1, ref2, ref3, ref4,\
ref5, ref6, line_mixing_flag, g_upper,g_lower
# #
string1 = str(newline.write(line1))
new_string = string1 + '\n'
return new_string
emis7 = 0
emis8 = df_emissions.ix[idx, 'ETHYLBENZEN ']
emis9 = df_emissions.ix[idx, 'FORMALDEHYD ']
emis10 = df_emissions.ix[idx, 'LEAD ']
emis11 = df_emissions.ix[idx, 'MANGANESE']
emis12 = df_emissions.ix[idx, 'NAPHTHALENE']
emis13 = df_emissions.ix[idx, ' NH3 ']
emis14 = df_emissions.ix[idx, 'NOX ']
emis15 = df_emissions.ix[idx, 'PAH']
emis16 = df_emissions.ix[idx, ' PM10']
emis17 = df_emissions.ix[idx, ' PM2_5 ']
emis18 = df_emissions.ix[idx, 'SO2']
emis19 = df_emissions.ix[idx, ' TOLUENE ']
emis20 = df_emissions.ix[idx, 'VOC']
emis21 = df_emissions.ix[idx, ' XYLENE']
line = FortranRecordWriter('(I2, A3, A15, 41X, A40, A10, 8X, I4, F6.2, I4, 10X, F9.2, 74X, I4, F9.5, F9.5, 1X, 20(E13.7, 39X), E13.7, 39X)')
# line = FortranRecordWriter('(I2, A3, A15, 81X, A10, 8X, I4, F6.2, I4, 10X, F9.2, 74X, I4, F9.5, F9.5, 1X, E13.7, 39X, E13.7, 39X,E13.7, 39X, E13.7, 39X, E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X,E13.7, 39X, E13.7, 39X,E13.7, 39X)\n')
lineOut = line.write([int(state_id), county_id, plant_id, plant_nm, scc_code, stkHeight, stkDia, stkGasTmp, stkGasVel, sic_code,\
latitude, longitude, emis1, emis2, emis3, emis4, emis5, emis6, emis7, emis8, emis9, emis10, emis11, \
emis12, emis13, emis14, emis15, emis16, emis17, emis18, emis19, emis20, emis21])
lineOut = lineOut + ' '*39 + '\n'
outFile.write(lineOut)
outFile.close()
#%%
outputFile = "C:/Users/vik/Documents/Projects/NARA/NARA_files_4_Biorefinery/pt_NARA_biorefinery_2xEmis_tpy.txt"
outFile = open(outputFile, 'w')
lineOut = '%s\n'*6%("#IDA",
"#TYPE Point Source Inventory",
"#COUNTRY US",
"#YEAR 2011",
"#DESC NARA Biorefinery Point Source Inventory with twice original emissions",
