def testExportWithDerivative(self):
print(os.getcwd())
exportnet(self.net, 'tmpffnet.f')
## THE BELOW IS PLATFORM AND ffnet.f FILE DEPENDENT
## SHOULD BE COMMENTED FOR RELEASES ???
from numpy import f2py, array
f = open('tmpffnet.f', 'r')
source = f.read()
f.close()
f = open(ffnetpath + 'fortran/ffnet.f', 'r')
source += f.read()
f.close()
import sys
if sys.platform == 'win32':
eargs = '--compiler=mingw32'
else:
eargs = ''
if sys.version[0] == '3':
source = bytes(source, "utf-8")
f2py.compile(source,
modulename='tmpffnet',
extra_args=eargs,
verbose=0)
import tmpffnet
resA1 = tmpffnet.ffnet([1, 2, 3, 4, 5.])
resB1 = tmpffnet.dffnet([1, 2, 3, 4, 5.])
del tmpffnet
resA = self.net([1, 2, 3, 4, 5.])
resB = self.net.derivative([1, 2, 3, 4, 5.])
for i in range(5):
self.assertAlmostEqual(resA[i], resA1[i], 15)
for j in range(5):
self.assertAlmostEqual(resB[i][j], resB1[i][j], 15)
def compile_fortran_routine(fortran_likelihood_code, modname, template):
"Used by compile_metropolis_sweep and compile_EP_sweep."
def fortran_indent(s):
return '\n'.join([' ' * 6 + l for l in s.splitlines()])
# Instantiate the template with the likelihood code snippet.
fortran_likelihood_code = fortran_likelihood_code.replace(
'{X}', '(xp+M(i))')
fortran_code = template.replace('{LIKELIHOOD_CODE}',
fortran_indent(fortran_likelihood_code))
lpf_hash = hashlib.sha1(fortran_code).hexdigest()
# Compile the generated code and import it.
try:
exec('import %s_%s as %s' % (modname, lpf_hash, modname))
except ImportError:
for l in fortran_likelihood_code.splitlines():
if len(l) > 72 - 6:
raise RuntimeError, 'Line "%s" in your log-likelihood code snippet is too long, Fortran will hurl.' % l
f2py.compile(fortran_code, modulename='%s_%s' % (modname, lpf_hash))
exec('import %s_%s as %s' % (modname, lpf_hash, modname))
# Store the generated code on the function and return it.
exec('%s.code = fortran_code' % modname)
exec('mod = %s' % modname)
return mod
def testExportNoDerivative(self):
exportnet(self.net, 'tmpffnet.f', derivative=False)
## THE BELOW IS PLATFORM AND ffnet.f FILE DEPENDENT
## SHOULD BE COMMENTED FOR RELEASES ???
from numpy import f2py
f = open('tmpffnet.f', 'r')
source = f.read()
f.close()
f = open(ffnetpath + 'fortran/ffnet.f', 'r')
source += f.read()
f.close()
import sys
if sys.platform == 'win32':
eargs = '--compiler=mingw32'
else:
eargs = ''
if sys.version[0] == '3':
source = bytes(source, "utf-8")
f2py.compile(source,
modulename='tmpffnet2',
extra_args=eargs,
verbose=0)
import tmpffnet2
resA1 = tmpffnet2.ffnet([1, 2, 3, 4, 5.])
resA = self.net([1, 2, 3, 4, 5.])
for i in range(5):
self.assertAlmostEqual(resA[i], resA1[i], 15)
self.assertRaises(AttributeError,
lambda: tmpffnet2.dffnet([1, 2, 3, 4, 5.]))
def testExportWithDerivative(self):
print os.getcwd()
exportnet(self.net, 'tmpffnet.f')
## THE BELOW IS PLATFORM AND ffnet.f FILE DEPENDENT
## SHOULD BE COMMENTED FOR RELEASES ???
from numpy import f2py, array
f = open( 'tmpffnet.f', 'r' ); source = f.read(); f.close()
f = open( ffnetpath + 'fortran/ffnet.f', 'r' ); source += f.read(); f.close()
import sys
if sys.platform == 'win32':
eargs = '--compiler=mingw32'
else: eargs = ''
if sys.version[0] == '3':
source = bytes(source, "utf-8")
f2py.compile(source, modulename = 'tmpffnet', extra_args = eargs, verbose = 0)
import tmpffnet
resA1 = tmpffnet.ffnet( [ 1, 2, 3, 4, 5. ] )
resB1 = tmpffnet.dffnet( [ 1, 2, 3, 4, 5. ] )
del tmpffnet
resA = self.net ( [ 1, 2, 3, 4, 5. ] )
resB = self.net.derivative( [ 1, 2, 3, 4, 5. ] )
for i in xrange(5):
self.assertAlmostEqual(resA[i], resA1[i], 15)
for j in xrange(5):
self.assertAlmostEqual(resB[i][j], resB1[i][j], 15)
def compile_fortran_routine(fortran_likelihood_code, modname, template):
"Used by compile_metropolis_sweep and compile_EP_sweep."
def fortran_indent(s):
return '\n'.join([' '*6+l for l in s.splitlines()])
# Instantiate the template with the likelihood code snippet.
fortran_likelihood_code = fortran_likelihood_code.replace('{X}','(xp+M(i))')
fortran_code = template.replace('{LIKELIHOOD_CODE}', fortran_indent(fortran_likelihood_code))
lpf_hash = hashlib.sha1(fortran_code).hexdigest()
# Compile the generated code and import it.
try:
exec('import %s_%s as %s'%(modname, lpf_hash, modname))
except ImportError:
for l in fortran_likelihood_code.splitlines():
if len(l)>72-6:
raise RuntimeError, 'Line "%s" in your log-likelihood code snippet is too long, Fortran will hurl.'%l
f2py.compile(fortran_code, modulename='%s_%s'%(modname,lpf_hash))
exec('import %s_%s as %s'%(modname, lpf_hash, modname))
# Store the generated code on the function and return it.
exec('%s.code = fortran_code'%modname)
exec('mod = %s'%modname)
return mod
def __init__(self,default_bounds,stl_bounds_file=None,num_faces=0):
'''
Initialize Bounds object.
Args:
default_bounds: Default_bounds is a description of a boundary surface.
It may be superceded by other boundary conditions such as solid
walls defined in an STL file. It is an object containing one
element for each Face.
stl_bounds_file: Filename string of an ASCII .stl file describing any
solid wall geometries present. Will eventually support the results
of an stl_read command (a list of arrays of nodes and faces).
num_faces: Integer number of individual faces in the .stl file. Must
be present if an STL file is given.
Returns:
self.left_face
self.right_face
self.top_face
self.bottom_face
self.back_face
self.front_face
Raises:
STLError: There was an error reading the .stl file.
'''
# Read STL file, returning lists of triangulation vertices, indices of
# the vertices associated with triangles, and the normal vectors of
# those triangles.
if stl_bounds_file:
print " Warning: STL boundaries are not yet implemented."
sysexit()
num_nodes = num_faces*3
[self.stl_nodes,self.stl_face_nodes,self.stl_face_normal,
error]=stl.stla_read(stl_bounds_file,num_nodes,num_faces)
if error:
try:
str="STLError: stla_read failed in BoundaryConditions.__init__"
raise STLError(str)
except STLError as e:
print e.msg
sysexit()
# Isolate the parts of the boundary specification pertaining to each
# Side and pass them on.
self.left_face = Face('left',default_bounds.left_face)
self.right_face = Face('right',default_bounds.right_face)
self.bottom_face = Face('bottom',default_bounds.bottom_face)
self.top_face = Face('top',default_bounds.top_face)
self.back_face = Face('back',default_bounds.back_face)
self.front_face = Face('front',default_bounds.front_face)
fortran_normal_src = "! -*- f90 -*-\n"
for face in self:
for patch in face:
try:
fortran_normal_src += patch.gradsrc
except AttributeError: # Some patches don't have normal vectors
pass
f2py.compile(fortran_normal_src,modulename='FortranNormalVectors',
verbose=False,source_fn='FortranNormalVectors.f90',
extra_args='--quiet')
def main():
from scipy.weave import inline
import numpy.f2py as f2py
with open('Pspline.f', 'r') as f:
code = f.read()
#inline(code)
f2py.compile(code, modulename='pspline')
def compile_f2py():
"""This function compiles the F2PY interface."""
base_path = os.getcwd()
os.chdir(PACKAGE_DIR)
args = '--f90flags="-ffree-line-length-0 -O3"'
src = open('replacements_f2py.f90', 'rb').read()
f2py.compile(src, 'replacements_f2py', args, extension='.f90')
os.chdir(base_path)
def main():
import numpy.f2py as f2py
with open('Pspline.f', 'r') as f:
code = f.read()
f2py.compile(code, modulename='pspline')
import pspline
help(pspline.pspline)
def __install_disort(self) -> None:
folder_name = 'disort4.0.99'
module_name = 'disort'
disort_source_dir = os.path.join(self.__project_path, folder_name)
mods = [
'BDREF.f', 'DISOBRDF.f', 'ERRPACK.f', 'LAPACK.f', 'LINPAK.f',
'RDI1MACH.f'
]
paths = [os.path.join(disort_source_dir, m) for m in mods]
# I'm disgusted to say I'm adding a comment. I want to compile DISORT.f
# as a module, and I can do that by adding the other modules it needs
# in extra_args (this wasn't clear in f2py documentation).
with open(os.path.join(disort_source_dir, 'DISORT.f')) as mod:
f2py.compile(mod.read(), modulename=module_name, extra_args=paths)
def compile_radex(fcompiler='gfortran',f77exec=None):
#r1 = os.system('f2py -h pyradex/radex/radex.pyf Radex/src/*.f --overwrite-signature > radex_build.log')
pwd = os.getcwd()
os.chdir('Radex/src/')
files = glob.glob('*.f')
include_path = '--include-paths {0}'.format(os.getcwd())
f2py.run_main(' -h radex.pyf --overwrite-signature'.split()+include_path.split()+files)
if f77exec is None:
f77exec=''
else:
f77exec = '--f77exec=%s' % f77exec
#cmd = '-m radex -c %s --fcompiler=%s %s' % (" ".join(files), fcompiler, f77exec)
#f2py.run_main(['-m','radex','-c','--fcompiler={0}'.format(fcompiler), f77exec,] + files)
source_list = []
for fn in files:
with open(fn, 'rb') as f:
source_list.append(f.read())
source = b"\n".join(source_list)
include_path = '-I{0}'.format(os.getcwd())
r2 = f2py.compile(source=source, modulename='radex',
extra_args='--fcompiler={0} {1} {2}'.format(fcompiler,
f77exec,
include_path),)
os.chdir(pwd)
if r2 != 0:
raise SystemError("f2py failed with error %i" % r2)
outfile = glob.glob("Radex/src/radex.*so")
if len(outfile) != 1:
print("outfile = {0}".format(outfile))
raise OSError("Did not find the correct .so file(s)! Compilation has failed.")
sofile = outfile[0]
r3 = shutil.move(sofile, 'pyradex/radex/radex.so')
def ext_gridloop2_compile(self, fstr):
if not isinstance(fstr, str):
raise TypeError, \
'fstr must be string expression, not', type(fstr)
# generate Fortran source for gridloop2:
source = """
subroutine gridloop2(a, xcoor, ycoor, nx, ny)
integer nx, ny
real*8 a(nx,ny), xcoor(nx), ycoor(ny)
Cf2py intent(out) a
Cf2py depend(nx,ny) a
integer i,j
real*8 x, y
do j = 1,ny
y = ycoor(j)
do i = 1,nx
x = xcoor(i)
a(i,j) = %s
end do
end do
return
end
""" % fstr
f2py_args = "--fcompiler=Gnu --build-dir tmp1"\
" -DF2PY_REPORT_ON_ARRAY_COPY=1"
r = f2py.compile(source, modulename='ext_gridloop2',
extra_args=f2py_args, verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'; sys.exit(1)
import ext_gridloop2 # see if we can import successfully
def compile_radex(fcompiler="gfortran", f77exec=None):
# r1 = os.system('f2py -h pyradex/radex/radex.pyf Radex/src/*.f --overwrite-signature > radex_build.log')
pwd = os.getcwd()
os.chdir("Radex/src/")
files = glob.glob("*.f")
include_path = "--include-paths {0}".format(os.getcwd())
f2py.run_main(" -h radex.pyf --overwrite-signature".split() + include_path.split() + files)
if f77exec is None:
f77exec = ""
else:
f77exec = "--f77exec=%s" % f77exec
# cmd = '-m radex -c %s --fcompiler=%s %s' % (" ".join(files), fcompiler, f77exec)
# f2py.run_main(['-m','radex','-c','--fcompiler={0}'.format(fcompiler), f77exec,] + files)
source_list = []
for fn in files:
with open(fn, "rb") as f:
source_list.append(f.read())
source = b"\n".join(source_list)
include_path = "-I{0}".format(os.getcwd())
r2 = f2py.compile(
source=source, modulename="radex", extra_args="--fcompiler={0} {1} {2}".format(fcompiler, f77exec, include_path)
)
os.chdir(pwd)
if r2 != 0:
raise SystemError("f2py failed with error %i" % r2)
r3 = shutil.move("Radex/src/radex.so", "pyradex/radex/radex.so")
def compile_radex(fcompiler='gfortran', f77exec=None):
#r1 = os.system('f2py -h pyradex/radex/radex.pyf Radex/src/*.f --overwrite-signature > radex_build.log')
pwd = os.getcwd()
os.chdir('Radex/src/')
files = glob.glob('*.f')
include_path = '--include-paths {0}'.format(os.getcwd())
f2py.run_main(' -h radex.pyf --overwrite-signature'.split() +
include_path.split() + files)
if f77exec is None:
f77exec = ''
else:
f77exec = '--f77exec=%s' % f77exec
#cmd = '-m radex -c %s --fcompiler=%s %s' % (" ".join(files), fcompiler, f77exec)
#f2py.run_main(['-m','radex','-c','--fcompiler={0}'.format(fcompiler), f77exec,] + files)
source_list = []
for fn in files:
with open(fn, 'rb') as f:
source_list.append(f.read())
source = b"\n".join(source_list)
include_path = '-I{0}'.format(os.getcwd())
r2 = f2py.compile(
source=source,
modulename='radex',
extra_args='--fcompiler={0} {1} {2}'.format(fcompiler, f77exec,
include_path),
)
os.chdir(pwd)
if r2 != 0:
raise SystemError("f2py failed with error %i" % r2)
r3 = shutil.move('Radex/src/radex.so', 'pyradex/radex/radex.so')
def build(f2py_opts):
try:
import f77_ext_return_real
except ImportError:
assert not f2py2e.compile('''\
function t0(value)
real value
real t0
t0 = value
end
function t4(value)
real*4 value
real*4 t4
t4 = value
end
function t8(value)
real*8 value
real*8 t8
t8 = value
end
function td(value)
double precision value
double precision td
td = value
end
subroutine s0(t0,value)
real value
real t0
cf2py intent(out) t0
t0 = value
end
subroutine s4(t4,value)
real*4 value
real*4 t4
cf2py intent(out) t4
t4 = value
end
subroutine s8(t8,value)
real*8 value
real*8 t8
cf2py intent(out) t8
t8 = value
end
subroutine sd(td,value)
double precision value
double precision td
cf2py intent(out) td
td = value
end
''',
'f77_ext_return_real',
f2py_opts,
source_fn='f77_ret_real.f')
from f77_ext_return_real import t0, t4, t8, td, s0, s4, s8, sd
test_functions = [t0, t4, t8, td, s0, s4, s8, sd]
return test_functions
def testExportNoDerivative(self):
exportnet(self.net, 'tmpffnet.f', derivative = False)
## THE BELOW IS PLATFORM AND ffnet.f FILE DEPENDENT
## SHOULD BE COMMENTED FOR RELEASES ???
from numpy import f2py
f = open( 'tmpffnet.f', 'r' ); source = f.read(); f.close()
f = open( ffnetpath + 'fortran/ffnet.f', 'r' ); source += f.read(); f.close()
import sys
if sys.platform == 'win32':
eargs = '--compiler=mingw32'
else: eargs = ''
f2py.compile(source, modulename = 'tmpffnet2', extra_args = eargs, verbose = 0)
import tmpffnet2
resA1 = tmpffnet2.ffnet( [ 1, 2, 3, 4, 5. ] )
resA = self.net ( [ 1, 2, 3, 4, 5. ] )
for i in xrange(5):
self.assertAlmostEqual(resA[i], resA1[i], 15)
self.assertRaises(AttributeError, lambda: tmpffnet2.dffnet([ 1, 2, 3, 4, 5. ]))
def import_selected_kind():
"""Tries to import the module which provides
processor dependent kind values. If the module
is not available it is compiled from a here-document
and imported afterwards.
Warning: creates both the source file and the
compiled module in the current directory.
"""
try:
import f2py_selected_kind
except:
from numpy.f2py import compile
# quick'n'dirty workaround for windoze
if os.name == 'nt':
f = open('f2py_selected_kind.f90', 'w')
f.write(FCODE)
f.close()
from copy import deepcopy
# save for later
true_argv = deepcopy(sys.argv)
sys.argv = (('%s -c --fcompiler=gnu95 --compiler=mingw32'
' -m f2py_selected_kind'
' f2py_selected_kind.f90') %
sys.executable).split()
from numpy import f2py as f2py2e
f2py2e.main()
sys.argv = true_argv
else:
fcompiler = os.environ.get('F2PY_FCOMPILER', 'gfortran')
compile(FCODE,
source_fn='f2py_selected_kind.f90',
modulename='f2py_selected_kind',
extra_args='--fcompiler=%s' % fcompiler)
try:
import f2py_selected_kind
except Exception as e:
raise Exception('Could not create selected_kind module\n' +
'%s\n' % os.path.abspath(os.curdir) +
'%s\n' % os.listdir('.') + '%s\n' % e)
return f2py_selected_kind.kind
def import_selected_kind():
"""Tries to import the module which provides
processor dependent kind values. If the module
is not available it is compiled from a here-document
and imported afterwards.
Warning: creates both the source file and the
compiled module in the current directory.
"""
try:
import f2py_selected_kind
except:
from numpy.f2py import compile
# quick'n'dirty workaround for windoze
if os.name == 'nt':
f = open('f2py_selected_kind.f90', 'w')
f.write(FCODE)
f.close()
from copy import deepcopy
# save for later
true_argv = deepcopy(sys.argv)
sys.argv = (('%s -c --fcompiler=gnu95 --compiler=mingw32'
' -m f2py_selected_kind'
' f2py_selected_kind.f90')
% sys.executable).split()
from numpy import f2py as f2py2e
f2py2e.main()
sys.argv = true_argv
else:
fcompiler = os.environ.get('F2PY_FCOMPILER', 'gfortran')
compile(FCODE, source_fn='f2py_selected_kind.f90',
modulename='f2py_selected_kind',
extra_args='--fcompiler=%s' % fcompiler)
try:
import f2py_selected_kind
except Exception as e:
raise Exception('Could not create selected_kind module\n'
+ '%s\n' % os.path.abspath(os.curdir)
+ '%s\n' % os.listdir('.')
+ '%s\n' % e)
return f2py_selected_kind.kind
def build(f2py_opts):
try:
import f77_ext_return_real
except ImportError:
assert not f2py2e.compile('''\
function t0(value)
real value
real t0
t0 = value
end
function t4(value)
real*4 value
real*4 t4
t4 = value
end
function t8(value)
real*8 value
real*8 t8
t8 = value
end
function td(value)
double precision value
double precision td
td = value
end
subroutine s0(t0,value)
real value
real t0
cf2py intent(out) t0
t0 = value
end
subroutine s4(t4,value)
real*4 value
real*4 t4
cf2py intent(out) t4
t4 = value
end
subroutine s8(t8,value)
real*8 value
real*8 t8
cf2py intent(out) t8
t8 = value
end
subroutine sd(td,value)
double precision value
double precision td
cf2py intent(out) td
td = value
end
''','f77_ext_return_real',f2py_opts,source_fn='f77_ret_real.f')
from f77_ext_return_real import t0,t4,t8,td,s0,s4,s8,sd
test_functions = [t0,t4,t8,td,s0,s4,s8,sd]
return test_functions
def generate_func(self, return_key='f', omit_assign=False, return_dim=None, return_intent='out'):
"""Generates a function from operator value and arguments"""
global module_counter
# function head
func_dict = {}
func = FortranGen()
func.add_linebreak()
func.add_indent()
fname = self.short_name.lower()
func.add_code_line(f"subroutine {fname}({return_key}")
for arg in self._op_dict['arg_names']:
if arg != return_key:
func.add_code_line(f",{arg}")
func.add_code_line(")")
func.add_linebreak()
# argument type definition
for arg, name in zip(self._op_dict['args'], self._op_dict['arg_names']):
if name != return_key:
dtype = "integer" if "int" in str(arg.vtype) else "double precision"
dim = f"dimension({','.join([str(s) for s in arg.shape])}), " if arg.shape else ""
func.add_code_line(f"{dtype}, {dim}intent(in) :: {name}")
func.add_linebreak()
out_dim = f"({','.join([str(s) for s in return_dim])})" if return_dim else ""
func.add_code_line(f"double precision, intent({return_intent}) :: {return_key}{out_dim}")
func.add_linebreak()
func.add_code_line(f"{self._op_dict['value']}" if omit_assign else f"{return_key} = {self._op_dict['value']}")
func.add_linebreak()
func.add_code_line("end")
func.add_linebreak()
func.remove_indent()
module_counter += 1
fn = f"pyrates_func_{module_counter}"
f2py.compile(func.generate(), modulename=fn, extension=".f", verbose=False,
source_fn=f"{self.build_dir}/{fn}.f" if self.build_dir else f"{fn}.f")
exec(f"from pyrates_func_{module_counter} import {fname}", globals())
func_dict[self.short_name] = globals().pop(fname)
return func_dict
def ext_gridloop2_fcb_ptr_compile(self, fstr):
if not isinstance(fstr, StringFunction):
raise TypeError, \
'fstr must be StringFunction, not %s', type(fstr)
source = fstr.F77_code('fcb')
f2py_args = "--fcompiler=Gnu --build-dir=tmp2"
r = f2py.compile(source, modulename='callback',
extra_args=f2py_args, verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'; sys.exit(1)
import callback # see if we can import successfully
def ext_gridloop2_fcb_ptr_compile(self, fstr):
if not isinstance(fstr, StringFunction):
raise TypeError, \
'fstr must be StringFunction, not %s', type(fstr)
source = fstr.F77_code('fcb')
f2py_args = "--fcompiler=Gnu --build-dir=tmp2"
r = f2py.compile(source,
modulename='callback',
extra_args=f2py_args,
verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'
sys.exit(1)
import callback # see if we can import successfully
def ext_gridloop2_fcb_compile(self, fstr):
if not isinstance(fstr, str):
raise TypeError, \
'fstr must be string expression, not %s', type(fstr)
# generate Fortran source
source = """
real*8 function fcb(x, y)
real*8 x, y
fcb = %s
return
end
subroutine gridloop2_fcb(a, xcoor, ycoor, nx, ny)
integer nx, ny
real*8 a(nx,ny), xcoor(nx), ycoor(ny)
Cf2py intent(out) a
Cf2py intent(in) xcoor
Cf2py intent(in) ycoor
Cf2py depend(nx,ny) a
real*8 fcb
external fcb
call gridloop2(a, xcoor, ycoor, nx, ny, fcb)
return
end
""" % fstr
# compile callback code and link with ext_gridloop.so:
f2py_args = "--fcompiler=Gnu --build-dir=tmp2"\
" -DF2PY_REPORT_ON_ARRAY_COPY=1 "\
" ./ext_gridloop.so"
r = f2py.compile(source,
modulename='callback',
extra_args=f2py_args,
verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'
sys.exit(1)
import callback # see if we can import successfully
def _compile(self):
modulename = self._source_path.stem
dir_path = str(Path(self._source_path).parent)
suffix = self._source_path.suffix
complie_result = f2py.compile(self.source,
modulename=modulename,
verbose=False,
extra_args="--quiet",
extension=suffix)
if complie_result != 0:
raise ImportError("complie failed")
else:
root = Path(dir_path).resolve()
find_files = [
i for i in root.iterdir() if i.match(f"{modulename}*.pyd")
or i.match(f"{modulename}*.so")
]
if len(find_files) != 1:
raise ImportError(
f"find {len(find_files)} Dynamic Link Library")
file = find_files[0]
target_path = self._source_path.with_name(file.name)
if file != target_path:
try:
shutil.move(str(file), str(target_path))
except shutil.SameFileError as sfe:
pass
except Exception as e:
raise e
del_target = [
i for i in root.iterdir() if i.match(str(file) + ".*")
]
for i in del_target:
try:
i.chmod(0o777)
i.unlink()
except Exception as e:
warnings.warn(f'can not delete file {i}:{type(e)}--{e}',
UserWarning)
return target_path
def ext_gridloop2_fcb_compile(self, fstr):
if not isinstance(fstr, str):
raise TypeError, \
'fstr must be string expression, not %s', type(fstr)
# generate Fortran source
source = """
real*8 function fcb(x, y)
real*8 x, y
fcb = %s
return
end
subroutine gridloop2_fcb(a, xcoor, ycoor, nx, ny)
integer nx, ny
real*8 a(nx,ny), xcoor(nx), ycoor(ny)
Cf2py intent(out) a
Cf2py intent(in) xcoor
Cf2py intent(in) ycoor
Cf2py depend(nx,ny) a
real*8 fcb
external fcb
call gridloop2(a, xcoor, ycoor, nx, ny, fcb)
return
end
""" % fstr
# compile callback code and link with ext_gridloop.so:
f2py_args = "--fcompiler=Gnu --build-dir=tmp2"\
" -DF2PY_REPORT_ON_ARRAY_COPY=1 "\
" ./ext_gridloop.so"
r = f2py.compile(source, modulename='callback',
extra_args=f2py_args, verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'; sys.exit(1)
import callback # see if we can import successfully
def compileSourceCode(self):
source = self.buildSourceCode()
if source is None:
return None
if self.currentPreset in ["", None]:
title = f"No preset defined. Create new preset by clicking add!"
QMessageBox.critical(self, "No preset", f"<p>{title}</p>")
return None
print(">> SOURCE")
print(source)
modulename = f"module_{uuid.uuid4().hex}"
result = f2py.compile(
source,
modulename=modulename,
verbose=True,
extension=".f90",
source_fn=f"mod_{self.currentPreset}.f90",
)
if result != 0:
title = f"Cannot compile Fortran code! Check console for output!"
raise ValueError(title)
m = importlib.import_module(modulename)
def maskFn(x, y, z=0):
mask = getattr(m, self.currentPreset).mask(float(x), float(y), float(z))
return mask
for p in glob.glob(f"{modulename}*.so"):
os.remove(p)
self.maskFunction = maskFn
return True
def ext_gridloop2_compile(self, fstr):
if not isinstance(fstr, str):
raise TypeError, \
'fstr must be string expression, not', type(fstr)
# generate Fortran source for gridloop2:
source = """
subroutine gridloop2(a, xcoor, ycoor, nx, ny)
integer nx, ny
real*8 a(nx,ny), xcoor(nx), ycoor(ny)
Cf2py intent(out) a
Cf2py depend(nx,ny) a
integer i,j
real*8 x, y
do j = 1,ny
y = ycoor(j)
do i = 1,nx
x = xcoor(i)
a(i,j) = %s
end do
end do
return
end
""" % fstr
f2py_args = "--fcompiler=Gnu --build-dir tmp1"\
" -DF2PY_REPORT_ON_ARRAY_COPY=1"
r = f2py.compile(source,
modulename='ext_gridloop2',
extra_args=f2py_args,
verbose=True,
source_fn='_cb.f')
if r:
print 'unsuccessful compilation'
sys.exit(1)
import ext_gridloop2 # see if we can import successfully
a2 = (-x + 0.5d0) * 0.25d0 / eps
a3 = (-x + 0.375d0) * 0.5 / eps
expa1 = 0.d0
expa2 = 0.d0
expa3 = 0.d0
temp = max(a1, a2, a3)
if ((a1-temp) .ge. -35.d0) expa1 = exp(a1-temp)
if ((a2-temp) .ge. -35.d0) expa2 = exp(a2-temp)
if ((a3-temp) .ge. -35.d0) expa3 = exp(a3-temp)
u(1) = (0.1d0*expa1+0.5d0*expa2+expa3) / (expa1+expa2+expa3)
return
end
"""
f2py.compile(prob_def_f, modulename='problemdef', verbose=0)
"""
Part 2
Using the compiled callback routines to solve the problem.
"""
import bacoli_py
import numpy
import time
from problemdef import f, bndxa, bndxb, uinit
# Initialize the Solver object.
solver = bacoli_py.Solver()
# Specify the number of PDE's in this system.
from numpy import f2py
with open("wspro88.f") as sourcefile:
sourcecode = sourcefile.read()
f2py.compile(sourcecode)
# import wspro
from numpy import f2py
with open("rungeadd.f") as sourcefile:
sourcecode=sourcefile.read()
f2py.compile(sourcecode,modulename='coefs')
def import_selected_kind():
"""Tries to import the module which provides
processor dependent kind values. If the module
is not available it is compiled from a here-document
and imported afterwards.
Warning: creates both the source file and the
compiled module in the current directory.
"""
try:
import f2py_selected_kind
except:
from numpy.f2py import compile
fcode = """module kind
implicit none
contains
subroutine real_kind(p, r, kind_value)
integer, intent(in), optional :: p, r
integer, intent(out) :: kind_value
if(present(p).and.present(r)) then
kind_value = selected_real_kind(p=p, r=r)
else
if (present(r)) then
kind_value = selected_real_kind(r=r)
else
if (present(p)) then
kind_value = selected_real_kind(p)
endif
endif
endif
end subroutine real_kind
subroutine int_kind(p, r, kind_value)
integer, intent(in), optional :: p, r
integer, intent(out) :: kind_value
if(present(p).and.present(r)) then
kind_value = selected_int_kind(p)
else
if (present(r)) then
kind_value = selected_int_kind(r=r)
else
if (present(p)) then
kind_value = selected_int_kind(p)
endif
endif
endif
end subroutine int_kind
end module kind
"""
# quick'n'dirty workaround for windoze
if os.name == 'nt':
with open('f2py_selected_kind.f90', 'w') as f:
f.write(fcode)
from copy import deepcopy
# save for later
true_argv = deepcopy(sys.argv)
sys.argv = ('%s -c --fcompiler=gnu95 --compiler=mingw32 -m f2py_selected_kind f2py_selected_kind.f90' % sys.executable).split()
from numpy import f2py as f2py2e
f2py2e.main()
sys.argv = true_argv
else:
compile(fcode, source_fn='f2py_selected_kind.f90',
modulename='f2py_selected_kind')
try:
import f2py_selected_kind
except:
print(os.path.abspath(os.curdir))
print(os.listdir('.'))
raise
return f2py_selected_kind.kind
def eval(self, x, globals=None, locals=None):
"""
EXAMPLES::
sage: from sage.misc.inline_fortran import InlineFortran, _example
sage: fortran = InlineFortran(globals())
sage: fortran(_example)
sage: import numpy
sage: n = numpy.array(range(10),dtype=float)
sage: fib(n,int(10))
sage: n
array([ 0., 1., 1., 2., 3., 5., 8., 13., 21., 34.])
TESTS::
sage: os.chdir(SAGE_ROOT)
sage: fortran.eval("SYNTAX ERROR !@#$")
Traceback (most recent call last):
...
RuntimeError: failed to compile Fortran code:...
sage: os.getcwd() == SAGE_ROOT
True
"""
if len(x.splitlines()) == 1 and os.path.exists(x):
filename = x
x = open(x).read()
if filename.lower().endswith('.f90'):
x = '!f90\n' + x
from numpy import f2py
# Create everything in a temporary directory
mytmpdir = tmp_dir()
try:
old_cwd = os.getcwd()
os.chdir(mytmpdir)
old_import_path = os.sys.path
os.sys.path.append(mytmpdir)
name = "fortran_module" # Python module name
# if the first line has !f90 as a comment, gfortran will
# treat it as Fortran 90 code
if x.startswith('!f90'):
fortran_file = name + '.f90'
else:
fortran_file = name + '.f'
s_lib_path = ""
s_lib = ""
for s in self.library_paths:
s_lib_path = s_lib_path + "-L%s "
for s in self.libraries:
s_lib = s_lib + "-l%s " % s
log = name + ".log"
extra_args = '--quiet --f77exec=sage-inline-fortran --f90exec=sage-inline-fortran %s %s >"%s" 2>&1' % (
s_lib_path, s_lib, log)
f2py.compile(x,
name,
extra_args=extra_args,
source_fn=fortran_file)
log_string = open(log).read()
# f2py.compile() doesn't raise any exception if it fails.
# So we manually check whether the compiled file exists.
# NOTE: the .so extension is used expect on Cygwin,
# that is even on OS X where .dylib might be expected.
soname = name
uname = os.uname()[0].lower()
if uname[:6] == "cygwin":
soname += '.dll'
else:
soname += '.so'
if not os.path.isfile(soname):
raise RuntimeError("failed to compile Fortran code:\n" +
log_string)
if self.verbose:
print(log_string)
m = __builtin__.__import__(name)
finally:
os.sys.path = old_import_path
os.chdir(old_cwd)
try:
import shutil
shutil.rmtree(mytmpdir)
except OSError:
# This can fail for example over NFS
pass
for k, x in m.__dict__.iteritems():
if k[0] != '_':
self.globals[k] = x
def build(f2py_opts):
try:
import f77_ext_return_integer
except ImportError:
assert not f2py2e.compile('''\
function t0(value)
integer value
integer t0
t0 = value
end
function t1(value)
integer*1 value
integer*1 t1
t1 = value
end
function t2(value)
integer*2 value
integer*2 t2
t2 = value
end
function t4(value)
integer*4 value
integer*4 t4
t4 = value
end
function t8(value)
integer*8 value
integer*8 t8
t8 = value
end
subroutine s0(t0,value)
integer value
integer t0
cf2py intent(out) t0
t0 = value
end
subroutine s1(t1,value)
integer*1 value
integer*1 t1
cf2py intent(out) t1
t1 = value
end
subroutine s2(t2,value)
integer*2 value
integer*2 t2
cf2py intent(out) t2
t2 = value
end
subroutine s4(t4,value)
integer*4 value
integer*4 t4
cf2py intent(out) t4
t4 = value
end
subroutine s8(t8,value)
integer*8 value
integer*8 t8
cf2py intent(out) t8
t8 = value
end
''','f77_ext_return_integer',f2py_opts,source_fn='f77_ret_int.f')
from f77_ext_return_integer import t0,t1,t2,t4,t8,s0,s1,s2,s4,s8
test_functions = [t0,t1,t2,t4,t8,s0,s1,s2,s4,s8]
return test_functions
def __init__(self, varlist, grid, outDim='xy',
suffix='xy', path='.',
output=False):
"""
:type varlist: list
:param varlist:
:type grid: planetHydro.parseData.gridReader.gridReader
:param grid:
:type outDim: int
:param outDim:
:type suffix: str
:param suffix:
:type path: str
:param path:
:type output: bool
:param output:
"""
self.grid = grid
if (outDim == 'xy'):
self.ndims = 2
self.gridsig = (['x', 'y'], 'nxtot, nytot')
self.nztot = 1
self.shape = self.nxtot, self.nytot = grid.nxtot, grid.nytot + 1
elif (outDim == 'rphi'):
self.ndims = 2
self.gridsig = (['x', 'y'], 'nxtot, nytot')
self.nztot = 1
self.shape = self.nxtot, self.nytot = grid.nxtot, grid.nytot
elif (outDim == 'xz') | (outDim == 'rz'):
self.ndims = 2
self.gridsig = (['x', 'y'], 'nxtot, nytot')
self.nztot = 1
self.shape = self.nxtot, self.nytot = grid.nxtot, grid.nztot
elif (outDim == 'xyz') | (outDim == '3D'):
self.ndims = 3
self.gridsig = (['x', 'y', 'z'], 'nxtot, nytot, nztot')
self.shape = self.nxtot, self.nytot, self.nztot = grid.nxtot, grid.nytot + 1, grid.nztot
else:
assert False, "Error: {0} is not a valid output dimension".format(outDim)
self.varlist = varlist
self.suffix = suffix + '.dat'
self.varstring = ','.join(varlist)
self.fortranvarlist = (',\n' + self.nxt + ' ').join(self.gridsig[0] + varlist)
self.path = path
self.source = self.genSource()
if output:
with open(path + "/tecout" + suffix + ".f", "w") as txt_file:
txt_file.write(self.source)
try:
import os
os.remove(path + '/tecout' + suffix + '.so')
except OSError:
print "No previous output lib detected."
pass
# paths set for M10
self.modulename = 'tecout' + suffix
f2py.compile(self.source, modulename=self.modulename,
extra_args='-I/data/programs/local/src/tecio-wrap/ ' + \
'--f90exec=/opt/intel/composer_xe_2011_sp1.8.273/bin/intel64/ifort ' + \
'-L/data/programs/local/lib/ -ltecio -lstdc++')
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 6 10:32:17 2019
Modified by Rohit Goswami (HaoZeke) <*****@*****.**>
@author: mhumbert
"""
from numpy import f2py
import os, glob
os.chdir('src')
f = open('calcdistances.f90', 'r').read()
f2py.compile(f,
modulename='calcdistances',
source_fn='calcdistances.f90',
verbose=False)
f = open('calcCOM.f90', 'r').read()
f2py.compile(f, modulename='calccomf', source_fn='calcCOM.f90', verbose=False)
f = open('ipcorr.f90', 'r').read()
f2py.compile(f, modulename='ipcorr', source_fn='ipcorr.f90', verbose=False)
os.symlink(glob.glob('ipcorr.*.so')[0], 'ipcorr.so')
os.symlink(glob.glob('calcdistances.*.so')[0], 'calcdistances.so')
os.symlink(glob.glob('calccomf.*.so')[0], 'calccomf.so')
os.chdir('..')
"""
import sys
try:
n_points = int(sys.argv[1]) # Read from input
except:
n_points = 200 # default number of time-steps
t0, tn, u0 = 1., 6., 1.0
time_points = np.linspace(t0, tn, n_points)
atol, rtol, ng = 1e-8, 1e-8, 2
ng = 2 # number of constraint functions in g
# Compile these Fortran subroutines
from numpy import f2py
f2py.compile(f_str+'\n'+g_str, modulename='callback', verbose=False)
import callback
f_f77, g_f77 = callback.f_f77, callback.g_f77
st.figure()
method = Lsodar
# Test case: Lsodar, with f & g
m = method(None, f_f77=f_f77, rtol=rtol, atol=atol, g_f77=g_f77, ng=ng)
m.set_initial_condition(u0)
u,t = m.solve(time_points)
st.plot(t, u, 'o',
title="Lsodar with Fortran subroutines",
legend="with f & g", hold="on")
# Exact solution: u(t) = exp(-t**2+5*t-4)
st.plot(t, u_solution(time_points), '-',
def compile(self, build_dir: Optional[str] = None, decorator: Optional[Callable] = None, **kwargs) -> tuple:
"""Compile the graph layers/operations. Creates python files containing the functions in each layer.
Parameters
----------
build_dir
Directory in which to create the file structure for the simulation.
decorator
Decorator function that should be applied to the right-hand side evaluation function.
kwargs
decorator keyword arguments
Returns
-------
tuple
Contains tuples of layer run functions and their respective arguments.
"""
# preparations
##############
# remove empty layers and operators
new_layer_idx = 0
for layer_idx, layer in enumerate(self.layers.copy()):
for op in layer.copy():
if op is None:
layer.pop(layer.index(op))
if len(layer) == 0:
self.layers.pop(new_layer_idx)
else:
new_layer_idx += 1
# remove previously imported rhs_funcs from system
if 'rhs_func' in sys.modules:
del sys.modules['rhs_func']
# collect state variable and parameter vectors
state_vars, params, var_map = self._process_vars()
# update state variable getter operations to include the full state variable vector as first argument
y = self.get_var('y')
for key, (vtype, idx) in var_map.items():
var = self.get_var(key)
if vtype == 'state_var' and var.short_name != 'y':
var.args[0] = y
var.build_op(var.args)
# create rhs evaluation function
################################
# set up file header
func_gen = FortranGen()
for import_line in self._imports:
func_gen.add_code_line(import_line)
func_gen.add_linebreak()
func_gen.add_linebreak()
# define function head
func_gen.add_indent()
if self.pyauto_compat:
func_gen.add_code_line("subroutine func(ndim,y,icp,args,ijac,y_delta,dfdu,dfdp)")
func_gen.add_linebreak()
func_gen.add_code_line("implicit none")
func_gen.add_linebreak()
func_gen.add_code_line("integer, intent(in) :: ndim, icp(*), ijac")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(in) :: y(ndim), args(*)")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(out) :: y_delta(ndim)")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(inout) :: dfdu(ndim,ndim), dfdp(ndim,*)")
func_gen.add_linebreak()
else:
func_gen.add_code_line("subroutine func(ndim,t,y,args,y_delta)")
func_gen.add_linebreak()
func_gen.add_code_line("implicit none")
func_gen.add_linebreak()
func_gen.add_code_line("integer, intent(in) :: ndim")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(in) :: t, y(ndim)")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(in) :: args(*)")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(out) :: y_delta(ndim)")
func_gen.add_linebreak()
# declare variable types
func_gen.add_code_line("double precision ")
for key in var_map:
var = self.get_var(key)
if "float" in str(var.dtype) and var.short_name != 'y_delta':
func_gen.add_code_line(f"{var.short_name},")
if "," in func_gen.code[-1]:
func_gen.code[-1] = func_gen.code[-1][:-1]
else:
func_gen.code.pop(-1)
func_gen.add_linebreak()
func_gen.add_code_line("integer ")
for key in var_map:
var = self.get_var(key)
if "int" in str(var.dtype):
func_gen.add_code_line(f"{var.short_name},")
if "," in func_gen.code[-1]:
func_gen.code[-1] = func_gen.code[-1][:-1]
else:
func_gen.code.pop(-1)
func_gen.add_linebreak()
# declare constants
args = [None for _ in range(len(params))]
func_gen.add_code_line("! declare constants")
func_gen.add_linebreak()
updates, indices = [], []
i = 0
for key, (vtype, idx) in var_map.items():
if vtype == 'constant':
var = params[idx-self.idx_start][1]
if var.short_name != 'y_delta':
func_gen.add_code_line(f"{var.short_name} = args({idx})")
func_gen.add_linebreak()
args[idx-1] = var
updates.append(f"{var.short_name}")
indices.append(i)
i += 1
func_gen.add_linebreak()
# extract state variables from input vector y
func_gen.add_code_line("! extract state variables from input vector")
func_gen.add_linebreak()
for key, (vtype, idx) in var_map.items():
var = self.get_var(key)
if vtype == 'state_var':
func_gen.add_code_line(f"{var.short_name} = {var.value}")
func_gen.add_linebreak()
func_gen.add_linebreak()
# add equations
func_gen.add_code_line("! calculate right-hand side update of equation system")
func_gen.add_linebreak()
arg_updates = []
for i, layer in enumerate(self.layers):
for j, op in enumerate(layer):
lhs = op.value.split("=")[0]
lhs = lhs.replace(" ", "")
find_arg = [arg == lhs for arg in updates]
if any(find_arg):
idx = find_arg.index(True)
arg_updates.append((updates[idx], indices[idx]))
func_gen.add_code_line(op.value)
func_gen.add_linebreak()
func_gen.add_linebreak()
# update parameters where necessary
# func_gen.add_code_line("! update system parameters")
# func_gen.add_linebreak()
# for upd, idx in arg_updates:
# update_str = f"args{self.idx_l}{idx}{self.idx_r} = {upd}"
# if f" {update_str}" not in func_gen.code:
# func_gen.add_code_line(update_str)
# func_gen.add_linebreak()
# end function
func_gen.add_code_line(f"end subroutine func")
func_gen.add_linebreak()
func_gen.remove_indent()
# save rhs function to file
fname = f'{self._build_dir}/rhs_func'
f2py.compile(func_gen.generate(), modulename='rhs_func', extension='.f', source_fn=f'{fname}.f', verbose=False)
# create additional subroutines in pyauto compatibility mode
gen_def = kwargs.pop('generate_auto_def', True)
if self.pyauto_compat and gen_def:
self.generate_auto_def(self._build_dir)
# import function from file
fname_import = fname.replace('/', '.')
exec(f"from rhs_func import rhs_eval", globals())
rhs_eval = globals().pop('func')
# apply function decorator
if decorator:
rhs_eval = decorator(rhs_eval, **kwargs)
return rhs_eval, args, state_vars, var_map
import os
# os.environ["CC"] = "/usr/bin/gfortran"
# os.environ["CXX"] = "/usr/bin/gfortran"
# Using post-0.2.2 scipy_distutils to display fortran compilers
from numpy.distutils.fcompiler import new_fcompiler
compiler = new_fcompiler() # or new_fcompiler(compiler='intel')
compiler.dump_properties()
#Generate add.f wrapper
from numpy import f2py
with open("add.f90") as sourcefile:
sourcecode = sourcefile.read()
print 'Fortran code'
print sourcecode
f2py.compile(sourcecode, modulename='add')
# f2py.compile(sourcecode, modulename='add', extra_args = '--fcompiler=/usr/bin/gfortran')
# f2py.compile(sourcecode, modulename='add')
# f2py -c --help-fcompiler
import add
print 'eso'
from numpy import f2py
fsource = '''
subroutine sumarray(A, N)
REAL, DIMENSION(N) :: A
INTEGER :: N
RES = 0.1 * SUM(A, MASK = A .GT. 0)
RES2 = -0.025 * SUM(A, MASK = A .LT. 0)
print*, RES + RES2
end
'''
f2py.compile(fsource,modulename='fort_sum',verbose=0)
from numpy import f2py
import os
files = os.listdir('.')
for file in files:
name, ext = os.path.splitext(file)
if ext == '.f':
print "Compiling file %s." %file
f2py.compile(open(file, 'r').read(), '_' + name)
def setup_execs(self):
from micki.fortran import f90_template, pyf_template
from numpy import f2py
# y_vec is an array symbol that will represent the species
# concentrations provided by the differential equation solver inside
# the Fortran code (that is, y_vec is an INPUT to the functions that
# calculate the residual, Jacobian, and rate)
y_vec = sym.IndexedBase('yin', shape=(self.nvariables,))
# Map y_vec elements (1-indexed, of course) onto 'modelparam' symbols
trans = {self.symbols[i]: y_vec[i + 1] for i in range(self.nvariables)}
# Map string represntation of 'modelparam' symbols onto string
# representation of y-vec elements
str_trans = {}
for i in range(self.nvariables):
str_trans[sym.fcode(self.symbols[i], source_format='free')] = \
sym.fcode(y_vec[i + 1], source_format='free')
str_list = [key for key in str_trans]
str_list.sort(key=len, reverse=True)
# these will contain lists of strings, with each element being one
# Fortran assignment for the master equation, Jacobian, and
# rate expressions
rescode = []
jaccode = []
ratecode = []
# Convert symbolic master equation into a valid Fortran string
for i in range(self.nvariables):
fcode = sym.fcode(self.f_sym[i], source_format='free')
# Replace modelparam symbols with their y_vec counterpart
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
# Create actual line of code for calculating residual
rescode.append(' res({}) = '.format(i + 1) + fcode)
# Effectively the same as above, except on the two-dimensional Jacobian
# matrix.
for i in range(self.nvariables):
for j in range(self.nvariables):
expr = self.jac_sym[j, i]
# Unlike the residual, some elements of the Jacobian can be 0.
# We don't need to bother writing 'jac(x,y) = 0' a hundred
# times in Fortran, so we omit those.
if expr != 0:
fcode = sym.fcode(expr, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
jaccode.append(' jac({}, {}) = '.format(j + 1, i + 1) +
fcode)
# See residual above
for i, rate in enumerate(self.rates):
fcode = sym.fcode(rate, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
ratecode.append(' rates({}) = '.format(i + 1) + fcode)
# We insert all of the parameters of this differential equation into
# the prewritten Fortran template, including the residual, Jacobian,
# and rate expressions we just calculated.
program = f90_template.format(neq=self.nvariables, nx=1,
nrates=len(self.rates),
rescalc='\n'.join(rescode),
jaccalc='\n'.join(jaccode),
ratecalc='\n'.join(ratecode))
# Generate a randomly-named temp directory for compiling the module.
# We will name the actual module file after the directory.
dname = tempfile.mkdtemp()
modname = os.path.split(dname)[1]
fname = modname + '.f90'
pyfname = modname + '.pyf'
# For debugging purposes, write out the generated module
with open('solve_ida.f90', 'w') as f:
f.write(program)
# Write the pertinent data into the temp directory
with open(os.path.join(dname, pyfname), 'w') as f:
f.write(pyf_template.format(modname=modname, neq=self.nvariables,
nrates=len(self.rates)))
# Compile the module with f2py
f2py.compile(program, modulename=modname,
extra_args='--quiet '
'--f90flags="-Wno-unused-dummy-argument '
'-Wno-unused-variable -w -fopenmp" '
'-lsundials_fcvode '
'-lsundials_cvode -lsundials_fnvecopenmp '
'-lsundials_nvecopenmp -lopenblas_openmp -lgomp ' +
os.path.join(dname, pyfname),
source_fn=os.path.join(dname, fname), verbose=0)
# Delete the temporary directory
shutil.rmtree(dname)
# Import the module on-the-fly with __import__. This is kind of a hack.
solve_ida = __import__(modname)
# The Fortran module's initialize, solve, and finalize routines
# are mapped onto finitialize, fsolve, and ffinalize inside the Model
# object. We don't want users touching these manually
self.finitialize = solve_ida.initialize
self.ffind_steady_state = solve_ida.find_steady_state
self.fsolve = solve_ida.solve
self.ffinalize = solve_ida.finalize
# Delete the module file. We've already imported it, so it's in memory.
os.remove(modname + '.so')
def eval(self, x, globals=None, locals=None):
"""
EXAMPLES::
sage: from sage.misc.inline_fortran import InlineFortran, _example
sage: fortran = InlineFortran(globals())
sage: fortran(_example)
sage: import numpy
sage: n = numpy.array(range(10),dtype=float)
sage: fib(n,int(10))
sage: n
array([ 0., 1., 1., 2., 3., 5., 8., 13., 21., 34.])
TESTS::
sage: os.chdir(SAGE_ROOT)
sage: fortran.eval("SYNTAX ERROR !@#$")
Traceback (most recent call last):
...
RuntimeError: failed to compile Fortran code:...
sage: os.getcwd() == SAGE_ROOT
True
"""
if len(x.splitlines()) == 1 and os.path.exists(x):
filename = x
x = open(x).read()
if filename.lower().endswith('.f90'):
x = '!f90\n' + x
from numpy import f2py
# Create everything in a temporary directory
mytmpdir = tmp_dir()
try:
old_cwd = os.getcwd()
os.chdir(mytmpdir)
old_import_path = os.sys.path
os.sys.path.append(mytmpdir)
name = "fortran_module" # Python module name
# if the first line has !f90 as a comment, gfortran will
# treat it as Fortran 90 code
if x.startswith('!f90'):
fortran_file = name + '.f90'
else:
fortran_file = name + '.f'
s_lib_path = ""
s_lib = ""
for s in self.library_paths:
s_lib_path = s_lib_path + "-L%s "
for s in self.libraries:
s_lib = s_lib + "-l%s "%s
log = name + ".log"
extra_args = '--quiet --f77exec=sage-inline-fortran --f90exec=sage-inline-fortran %s %s >"%s" 2>&1'%(
s_lib_path, s_lib, log)
f2py.compile(x, name, extra_args = extra_args, source_fn=fortran_file)
log_string = open(log).read()
# f2py.compile() doesn't raise any exception if it fails.
# So we manually check whether the compiled file exists.
# NOTE: the .so extension is used, even on OS X where .dylib
# might be expected.
soname = name + '.so'
if not os.path.isfile(soname):
raise RuntimeError("failed to compile Fortran code:\n" + log_string)
if self.verbose:
print log_string
m = __builtin__.__import__(name)
finally:
os.sys.path = old_import_path
os.chdir(old_cwd)
try:
import shutil
shutil.rmtree(mytmpdir)
except OSError:
# This can fail for example over NFS
pass
for k, x in m.__dict__.iteritems():
if k[0] != '_':
self.globals[k] = x
def compile_fortran_module(filename, module, source=None):
if source is None:
source = open(filename, 'r').read()
if f2py.compile(source=source, modulename=module,
source_fn=filename):
raise RuntimeError('compile failed, see console')
"""
import sys
try:
n_points = int(sys.argv[1]) # Read from input
except:
n_points = 10 # default number of time-steps
t0, tn, u0 = 0., 10., [2.,0.]
time_points = np.linspace(t0, tn, n_points)
atol, rtol = 1e-4, 1e-4
# Compile these Fortran subroutines
string_to_compile = '\n'.join([f_str, jac_full_str])
from numpy import f2py
f2py.compile(string_to_compile, modulename='callback', verbose=False)
import callback
f_f77, jac_f77 = callback.f_f77, callback.jac_f77
st.figure()
method = Lsode
# Test case 1: Lsode, with f & jac
m = method(None, f_f77=f_f77, rtol=rtol, atol=atol, jac_f77=jac_f77)
m.set_initial_condition(u0)
u,t = m.solve(time_points)
st.plot(t, u[:,0], '-', title="Lsode with Fortran subroutines",
legend="with f & jac_full", hold="on")
# Test case 2: Lsode, with f
integer i
do 10 i = 1,9
mas(1,i) = 1./6.
mas(2,i) = 4./6.
10 mas(3,i) = 1./6.
mas(1,1) = 0.
mas(3,9) = 0.
return
end
"""
# compile these Fortran subroutines
string_to_compile = '\n'.join([f_str, jac_str, mas_str])
from numpy import f2py
f2py.compile(string_to_compile, modulename = "tmp_callback", verbose=False)
import tmp_callback
f_f77, mas_f77, jac_f77_radau5 = \
tmp_callback.f_f77, tmp_callback.mas_f77, tmp_callback.jac_f77_radau5
u0 = np.zeros(9, float)
u0[1], u0[2:5], u0[5] = .5, 1., .5
t0, tn, n_points, ml, mu, mlmas, mumas = 0., .4, 50, 1, 1, 1, 1
time_points = np.linspace(t0, tn, n_points)
atol, rtol = 1e-3, 1e-3
exact_final = [1.07001457e-1, 2.77432492e-1, 5.02444616e-1, 7.21037157e-1,
9.01670441e-1, 8.88832048e-1, 4.96572850e-1, 9.46924362e-2,
-6.90855199e-3]
st.figure()
spcrad_f77 = 4d0*((nx+1)**2 + (ny+1)**2 + (nz+1)**2)
return
end
"""
import sys
try:
n_points = int(sys.argv[1]) # Read from input
except:
n_points = 20 # default number of time-steps
# Compile these Fortran subroutines
string_to_compile = '\n'.join([f_str, spcrad_str])
from numpy import f2py
f2py.compile(string_to_compile, modulename='callback', verbose=False)
import callback
f_f77, spcrad_f77 = callback.f_f77, callback.spcrad_f77
t0, tn = 0., .7
u0 = np.zeros(6859, float)
for i in range(19):
for j in range(19):
for k in range(19):
index = i + j * 19 + k * 19 * 19
u0[index] = np.tanh(5.0*((i+1)*.05 + (j+1)*.1 + \
(k+1)*.075 - .5))
time_points = np.linspace(t0, tn, n_points)
atol, rtol = 1e-4, 1e-4
jac_constant = 1
def generate_auto_def(self, directory):
"""
Parameters
----------
directory
Returns
-------
"""
if not self.pyauto_compat:
raise ValueError('This method can only be called in pyauto compatible mode. Please set `pyauto_compat` to '
'True upon calling the `CircuitIR.compile` method.')
# read file
###########
try:
# read file from excisting system compilation
if not directory:
directory = self._build_dir
fn = f"{directory}/rhs_func.f" if "rhs_func.f" not in directory else directory
with open(fn, 'rt') as f:
func_str = f.read()
except FileNotFoundError:
# compile system and then read the build files
self.compile(build_dir=directory, generate_auto_def=False)
fn = f"{self._build_dir}/rhs_func.f"
with open(fn, 'r') as f:
func_str = f.read()
end_str = "end subroutine func\n"
idx = func_str.index(end_str)
func_str = func_str[:idx+len(end_str)]
# generate additional subroutines
#################################
func_gen = FortranGen()
# generate subroutine header
func_gen.add_linebreak()
func_gen.add_indent()
func_gen.add_code_line("subroutine stpnt(ndim, y, args, t)")
func_gen.add_linebreak()
func_gen.add_code_line("implicit None")
func_gen.add_linebreak()
func_gen.add_code_line("integer, intent(in) :: ndim")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(inout) :: y(ndim), args(*)")
func_gen.add_linebreak()
func_gen.add_code_line("double precision, intent(in) :: T")
func_gen.add_linebreak()
# declare variable types
func_gen.add_code_line("double precision ")
for key in self.vars:
var = self.get_var(key)
name = var.short_name
if "float" in str(var.dtype) and name != 'y_delta' and name != 'y' and name != 't':
func_gen.add_code_line(f"{var.short_name},")
if "," in func_gen.code[-1]:
func_gen.code[-1] = func_gen.code[-1][:-1]
else:
func_gen.code.pop(-1)
func_gen.add_linebreak()
func_gen.add_code_line("integer ")
for key in self.vars:
var = self.get_var(key)
if "int" in str(var.dtype):
func_gen.add_code_line(f"{var.short_name},")
if "," in func_gen.code[-1]:
func_gen.code[-1] = func_gen.code[-1][:-1]
else:
func_gen.code.pop(-1)
func_gen.add_linebreak()
_, params, var_map = self._process_vars()
# define parameter values
func_gen.add_linebreak()
for key, (vtype, idx) in var_map.items():
if vtype == 'constant':
var = params[idx-self.idx_start][1]
if var.short_name != 'y_delta' and var.short_name != 'y':
func_gen.add_code_line(f"{var.short_name} = {var}")
func_gen.add_linebreak()
func_gen.add_linebreak()
# define initial state
func_gen.add_linebreak()
npar = 0
for key, (vtype, idx) in var_map.items():
if vtype == 'constant':
var = params[idx-self.idx_start][1]
if var.short_name != 'y_delta' and var.short_name != 'y':
func_gen.add_code_line(f"args({idx}) = {var.short_name}")
func_gen.add_linebreak()
if idx > npar:
npar = idx
func_gen.add_linebreak()
func_gen.add_linebreak()
for key, (vtype, idx) in var_map.items():
var = self.get_var(key)
if vtype == 'state_var':
func_gen.add_code_line(f"{var.value} = {var.numpy()}")
func_gen.add_linebreak()
func_gen.add_linebreak()
# end subroutine
func_gen.add_linebreak()
func_gen.add_code_line("end subroutine stpnt")
func_gen.add_linebreak()
# add dummy subroutines
for routine in ['bcnd', 'icnd', 'fopt', 'pvls']:
func_gen.add_linebreak()
func_gen.add_code_line(f"subroutine {routine}")
func_gen.add_linebreak()
func_gen.add_code_line(f"end subroutine {routine}")
func_gen.add_linebreak()
func_gen.add_linebreak()
func_gen.remove_indent()
func_combined = f"{func_str} \n {func_gen.generate()}"
f2py.compile(func_combined, source_fn=fn, modulename='rhs_func', extension='.f', verbose=False)
self.npar = npar
self.ndim = self.get_var('y').shape[0]
# generate constants file
#########################
# declare auto constants and their values
auto_constants = {'NDIM': self.ndim, 'NPAR': self.npar, 'IPS': -2, 'ILP': 0, 'ICP': [14], 'NTST': 1, 'NCOL': 4,
'IAD': 3, 'ISP': 0, 'ISW': 1, 'IPLT': 0, 'NBC': 0, 'NINT': 0, 'NMX': 10000, 'NPR': 100,
'MXBF': 10, 'IID': 2, 'ITMX': 8, 'ITNW': 5, 'NWTN': 3, 'JAC': 0, 'EPSL': 1e-7, 'EPSU': 1e-7,
'EPSS': 1e-5, 'IRS': 0, 'DS': 1e-4, 'DSMIN': 1e-8, 'DSMAX': 1e-2, 'IADS': 1, 'THL': {},
'THU': {}, 'UZR': {}, 'STOP': {}}
# write auto constants to string
cgen = FortranGen()
for key, val in auto_constants.items():
cgen.add_code_line(f"{key} = {val}")
cgen.add_linebreak()
# write auto constants to file
try:
with open(f'{directory}/c.ivp', 'wt') as cfile:
cfile.write(cgen.generate())
except FileNotFoundError:
with open(f'{directory}/c.ivp', 'xt') as cfile:
cfile.write(cgen.generate())
self._auto_files_generated = True
return fn
import sys
from os import path
sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
from util import IO_util, util_tp
import matplotlib.pyplot as plt
import numpy as np
from numpy import f2py
with open("/usr/local/home/yl8bc/Nic/PH/post/grid_generation/gridgen.f90") as sourcefile:
sourcecode = sourcefile.read()
f2py.compile(sourcecode, modulename='gridgen', extension='.f90', extra_args='--f90flags=''-fopenmp'' -lgomp')
import gridgen
def normalized_flipped(u, nx):
uscale = u[-1] - u[0]
u -= u[0]
u /= uscale
u = np.flip(u, axis=0)
u = 1. - u
nx0 = u.shape[0]
u = np.interp( np.linspace(0.,nx0-1.,nx), np.linspace(0.,nx0-1.,nx0), u)
return u
def Billig_wedge_shock(M, R, beta, y):
delta = R*0.386*np.exp(4.67/M**2)
Rc = R*1.386*np.exp(1.8/np.power(M-1.,0.75))
tan_beta = np.tan(beta)
x = R + delta - Rc/tan_beta**2*(np.sqrt(1+y**2*tan_beta**2/Rc**2) - 1.)
return x
def Billig_wedge_shock_inverse(M, R, beta, x):
def setup_execs(self):
from micki.fortran import f90_template, pyf_template
from numpy import f2py
# y_vec is an array symbol that will represent the species
# concentrations provided by the differential equation solver inside
# the Fortran code (that is, y_vec is an INPUT to the functions that
# calculate the residual, Jacobian, and rate)
y_vec = sym.IndexedBase('yin', shape=(self.nvariables, ))
# Map y_vec elements (1-indexed, of course) onto 'modelparam' symbols
trans = {self.symbols[i]: y_vec[i + 1] for i in range(self.nvariables)}
# Map string represntation of 'modelparam' symbols onto string
# representation of y-vec elements
str_trans = {}
for i in range(self.nvariables):
str_trans[sym.fcode(self.symbols[i], source_format='free')] = \
sym.fcode(y_vec[i + 1], source_format='free')
str_list = [key for key in str_trans]
str_list.sort(key=len, reverse=True)
# these will contain lists of strings, with each element being one
# Fortran assignment for the master equation, Jacobian, and
# rate expressions
rescode = []
jaccode = []
ratecode = []
# Convert symbolic master equation into a valid Fortran string
for i in range(self.nvariables):
fcode = sym.fcode(self.f_sym[i], source_format='free')
# Replace modelparam symbols with their y_vec counterpart
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
# Create actual line of code for calculating residual
rescode.append(' res({}) = '.format(i + 1) + fcode)
# Effectively the same as above, except on the two-dimensional Jacobian
# matrix.
for i in range(self.nvariables):
for j in range(self.nvariables):
expr = self.jac_sym[j, i]
# Unlike the residual, some elements of the Jacobian can be 0.
# We don't need to bother writing 'jac(x,y) = 0' a hundred
# times in Fortran, so we omit those.
if expr != 0:
fcode = sym.fcode(expr, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
jaccode.append(' jac({}, {}) = '.format(j + 1, i + 1) +
fcode)
# See residual above
for i, rate in enumerate(self.rates):
fcode = sym.fcode(rate, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
ratecode.append(' rates({}) = '.format(i + 1) + fcode)
# We insert all of the parameters of this differential equation into
# the prewritten Fortran template, including the residual, Jacobian,
# and rate expressions we just calculated.
program = f90_template.format(neq=self.nvariables,
nx=1,
nrates=len(self.rates),
rescalc='\n'.join(rescode),
jaccalc='\n'.join(jaccode),
ratecalc='\n'.join(ratecode))
# Generate a randomly-named temp directory for compiling the module.
# We will name the actual module file after the directory.
dname = tempfile.mkdtemp()
modname = os.path.split(dname)[1]
fname = modname + '.f90'
pyfname = modname + '.pyf'
# For debugging purposes, write out the generated module
with open('solve_ida.f90', 'w') as f:
f.write(program)
# Write the pertinent data into the temp directory
with open(os.path.join(dname, pyfname), 'w') as f:
f.write(
pyf_template.format(modname=modname,
neq=self.nvariables,
nrates=len(self.rates)))
# Compile the module with f2py
f2py.compile(program,
modulename=modname,
extra_args='--quiet '
'--f90flags="-Wno-unused-dummy-argument '
'-Wno-unused-variable -w -fopenmp" '
'-lsundials_fcvode '
'-lsundials_cvode -lsundials_fnvecopenmp '
'-lsundials_nvecopenmp -lopenblas_openmp -lgomp ' +
os.path.join(dname, pyfname),
source_fn=os.path.join(dname, fname),
verbose=0)
# Delete the temporary directory
shutil.rmtree(dname)
# Import the module on-the-fly with __import__. This is kind of a hack.
solve_ida = __import__(modname)
# The Fortran module's initialize, solve, and finalize routines
# are mapped onto finitialize, fsolve, and ffinalize inside the Model
# object. We don't want users touching these manually
self.finitialize = solve_ida.initialize
self.ffind_steady_state = solve_ida.find_steady_state
self.fsolve = solve_ida.solve
self.ffinalize = solve_ida.finalize
# Delete the module file. We've already imported it, so it's in memory.
os.remove(modname + '.so')
import os
from numpy import f2py
FLAGS_DEBUG = []
FLAGS_DEBUG += [
'-O', '-Wall', '-Wline-truncation', '-Wsurprising', '-Waliasing'
]
FLAGS_DEBUG += ['-Wunused-parameter', '-fwhole-file', '-fcheck=all']
FLAGS_DEBUG += ['-fbacktrace', '-g', '-fmax-errors=1', '-ffree-line-length-0']
FLAGS_DEBUG += ['-cpp', '-Wcharacter-truncation', '-Wimplicit-interface']
FLAGS_PRODUCTION = ['-O3', '-ffree-line-length-0']
args = ' '.join(FLAGS_PRODUCTION)
os.chdir('src')
cmd = ''
cmd += 'gfortran -c ' + args + ' -fpic shared_constants.f90 slsqp_interface.f90 slsqp.f '
cmd += ' replacements.f90 blackbox.f90'
os.system(cmd)
cmd = 'ar cr libblackbox.a *.o'
os.system(cmd)
os.chdir('../')
args = '--f90flags="' + args + '" -Isrc -Lsrc -lblackbox '
src = open('replacements_f2py.f90', 'rb').read()
f2py.compile(src, 'replacements_f2py', args, extension='.f90')
def setup_execs(self):
from micki.fortran2 import f90_template, pyf_template
from numpy import f2py
# y_vec is an array symbol that will represent the species
# concentrations provided by the differential equation solver inside
# the Fortran code (that is, y_vec is an INPUT to the functions that
# calculate the residual, Jacobian, and rate)
y_vec = sym.IndexedBase('y', shape=(self.nvariables, ))
vac_vec = sym.IndexedBase('vac', shape=(len(self.vacancy), ))
# Map y_vec elements (1-indexed, of course) onto 'modelparam' symbols
trans = {self.symbols[i]: y_vec[i + 1] for i in range(self.nvariables)}
trans.update(
{vac.symbol: y_vec[i + 1]
for i, vac in enumerate(self.vacancy)})
# Map string represntation of 'modelparam' symbols onto string
# representation of y-vec elements
str_trans = {}
for i, symbol in enumerate(self.symbols):
str_trans[sym.fcode(symbol, source_format='free')] = \
sym.fcode(y_vec[i + 1], source_format='free')
for i, vac in enumerate(self.vacancy):
str_trans[sym.fcode(vac.symbol, source_format='free')] = \
sym.fcode(vac_vec[i + 1], source_format='free')
str_list = [key for key in str_trans]
str_list.sort(key=len, reverse=True)
# these will contain lists of strings, with each element being one
# Fortran assignment for the master equation, Jacobian, and
# rate expressions
dypdrcode = []
drdycode = []
vaccode = []
drdvaccode = []
dvacdycode = []
for i, expr in enumerate(self.vac_sym):
fcode = sym.fcode(expr, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
vaccode.append(' vac({}) = '.format(i + 1) + fcode)
for i, row in enumerate(self.drdvac):
for j, elem in enumerate(row):
if elem != 0:
fcode = sym.fcode(elem, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
drdvaccode.append(
' drdvac({}, {}) = '.format(i + 1, j + 1) + fcode)
for i, row in enumerate(self.dvacdy):
for j, elem in enumerate(row):
if elem != 0:
dvacdycode.append(
' dvacdy({}, {}) = '.format(i + 1, j + 1) +
sym.fcode(elem, source_format='free'))
for i, row in enumerate(self.dypdr):
for j, elem in enumerate(row):
if elem != 0:
dypdrcode.append(
' dypdr({}, {}) = '.format(i + 1, j + 1) +
sym.fcode(elem, source_format='free'))
# Effectively the same as above, except on the two-dimensional Jacobian
# matrix.
for i, row in enumerate(self.drdy):
for j, elem in enumerate(row):
if elem != 0:
fcode = sym.fcode(elem, source_format='free')
for key in str_list:
fcode = fcode.replace(key, str_trans[key])
drdycode.append(' drdy({}, {}) = '.format(i + 1, j + 1) +
fcode)
ratecode = self._get_rate_code(str_list, str_trans)
#flowratecode = self._get_flowrate_code(str_list, str_trans)
is_gas = [' isgas = 0']
for idx, species in enumerate(self._variable_species):
if isinstance(species, _Fluid):
is_gas.append(f' isgas({idx+1}) = 1')
else:
is_gas.append(f' isgas({idx+1}) = 0')
# We insert all of the parameters of this differential equation into
# the prewritten Fortran template, including the residual, Jacobian,
# and rate expressions we just calculated.
program = f90_template.format(
neq=self.nvariables,
nx=1,
nrates=len(self.rates),
nvac=len(self.vacancy),
dypdrcalc='\n'.join(dypdrcode),
drdycalc='\n'.join(drdycode),
ratecalc='\n'.join(ratecode),
vaccalc='\n'.join(vaccode),
drdvaccalc='\n'.join(drdvaccode),
dvacdycalc='\n'.join(dvacdycode),
isgas='\n'.join(is_gas),
)
# Generate a randomly-named temp directory for compiling the module.
# We will name the actual module file after the directory.
dname = tempfile.mkdtemp()
modname = os.path.split(dname)[1]
fname = modname + '.f90'
pyfname = modname + '.pyf'
# For debugging purposes, write out the generated module
with open('solve_ida.f90', 'w') as f:
f.write(program)
# Write the pertinent data into the temp directory
with open(os.path.join(dname, pyfname), 'w') as f:
f.write(
pyf_template.format(modname=modname,
neq=self.nvariables,
nrates=len(self.rates),
nvac=len(self.vacancy)))
# Compile the module with f2py
lapack = "-lmkl_rt"
if "MICKI_LAPACK" in os.environ:
lapack = os.environ["MICKI_LAPACK"]
os.environ["CFLAGS"] = "-w"
f2py.compile(program,
modulename=modname,
extra_args='--quiet '
'--f90flags="-Wno-unused-dummy-argument '
'-Wno-unused-variable -Wno-unused-func -w" '
'-lsundials_fida '
'-lsundials_fnvecserial '
'-lsundials_ida '
'-lsundials_fsunlinsollapackdense '
'-lsundials_sunlinsollapackdense '
'-lsundials_nvecserial ' + lapack + ' ' +
os.path.join(dname, pyfname),
source_fn=os.path.join(dname, fname),
verbose=0)
# Delete the temporary directory
shutil.rmtree(dname)
# Import the module on-the-fly with __import__. This is kind of a hack.
solve_ida = __import__(modname)
self._solve_ida = solve_ida
# The Fortran module's initialize, solve, and finalize routines
# are mapped onto finitialize, fsolve, and ffinalize inside the Model
# object. We don't want users touching these manually
self.finitialize = solve_ida.initialize
self.ffind_steady_state = solve_ida.find_steady_state
self.fsolve = solve_ida.solve
self.ffinalize = solve_ida.finalize
# Delete the module file. We've already imported it, so it's in memory.
modulefile = glob.glob(f'{modname}*.so')[0]
os.remove(modulefile)
from numpy import f2py
fsource = b'''
subroutine sumarray(A, N)
REAL, DIMENSION(N) :: A
INTEGER :: N
RES = 0.1 * SUM(A, MASK = A .GT. 0)
RES2 = -0.025 * SUM(A, MASK = A .LT. 0)
print*, RES + RES2
end
'''
f2py.compile(fsource, modulename='fort_sum', verbose=0)
from numpy import f2py
from numpy.distutils.fcompiler import new_fcompiler
compiler = new_fcompiler(compiler='intel')
compiler.dump_properties()
with open(
"C:/Users/ahmed.kotb/PycharmProjects/AGPS/resources/Formating_SH_files.f"
) as sourcefile:
sourcecode = sourcefile.read()
print 'Fortran code'
print sourcecode
f2py.compile(sourcecode, modulename='add', extra_args='--fcompiler=gfortran')
a2 = (-x + 0.5d0) * 0.25d0 / eps
a3 = (-x + 0.375d0) * 0.5 / eps
expa1 = 0.d0
expa2 = 0.d0
expa3 = 0.d0
temp = max(a1, a2, a3)
if ((a1-temp) .ge. -35.d0) expa1 = exp(a1-temp)
if ((a2-temp) .ge. -35.d0) expa2 = exp(a2-temp)
if ((a3-temp) .ge. -35.d0) expa3 = exp(a3-temp)
u(1) = (0.1d0*expa1+0.5d0*expa2+expa3) / (expa1+expa2+expa3)
return
end
"""
f2py.compile(prob_def_f.encode('ascii'), modulename='problemdef', verbose=0)
"""
Part 2
Using the compiled callback routines to solve the problem.
"""
import bacoli_py
import numpy
import time
from problemdef import f, bndxa, bndxb, uinit
# Initialize the Solver object.
solver = bacoli_py.Solver()
# Specify the number of PDE's in this system.
# python -m numpy.f2py -c mPitzer_w_NaCl.f90 -m Pitzer
f = open('mPitzer_w_NaCl.f90', mode='r')
from numpy import f2py
source = "".join(f.readlines())
f2py.compile(source=source, modulename='Pitzer', extension='.f90')
import Pitzer
a = Pitzer.mpitzer_w_nacl(mnacl=1, t_k=300)
print("a = ", a)
def eval(self,x,globals=None, locals=None):
"""
EXAMPLES::
sage: from sage.misc.inline_fortran import InlineFortran, _example
sage: test_fortran = InlineFortran(globals()) # optional -- fortran
sage: test_fortran(_example) # optional -- fortran
sage: import numpy
sage: n = numpy.array(range(10),dtype=float)
sage: fib(n,int(10)) # optional -- fortran
sage: n # optional -- fortran
array([ 0., 1., 1., 2., 3., 5., 8., 13., 21., 34.])
"""
if len(x.splitlines()) == 1 and os.path.exists(x):
filename = x
x = open(x).read()
if filename.lower().endswith('.f90'):
x = '!f90\n' + x
global count
# On linux g77_shared should be a script that runs sage_fortran -shared
# On OS X it should be a script that runs gfortran -bundle -undefined dynamic_lookup
path = os.environ['SAGE_LOCAL']+'/bin/sage-g77_shared'
from numpy import f2py
old_import_path=os.sys.path
cwd=os.getcwd()
os.sys.path.append(cwd)
#name = tmp_dir() + '/fortran_module_%d'%count
name = 'fortran_module_%d'%count
if os.path.exists(name):
os.unlink(name)
s_lib_path=""
s_lib=""
for s in self.library_paths:
s_lib_path=s_lib_path+"-L"+s+" "
for s in self.libraries:
s_lib=s_lib +"-l"+s + " "
# if the first line has !f90 as a comment gfortran will treat it as
# fortran 90 code
if x.startswith('!f90'):
fname = os.path.join(tmp_filename() +'.f90')
else:
fname = os.path.join(tmp_filename() +'.f')
log = tmp_filename()
extra_args = '--quiet --f77exec=%s --f90exec=%s %s %s 1>&2 >"%s"'%(
path, path, s_lib_path, s_lib, log)
f2py.compile(x, name, extra_args = extra_args, source_fn=fname)
log_string = open(log).read()
os.unlink(log)
os.unlink(fname)
if self.verbose:
print log_string
count += 1
try:
m=__builtin__.__import__(name)
except ImportError:
if not self.verbose:
print log_string
return
finally:
os.sys.path=old_import_path
os.unlink(name + '.so')
for k, x in m.__dict__.iteritems():
if k[0] != '_':
self.globals[k] = x
#import add
#print add.zadd([1,2,3],[4,5,6])
from numpy import f2py
with open("addd.f") as sourcefile:
sourcecode=sourcefile.read()
f2py.compile(sourcecode,modulename='hello')
import hello
print hello.zadd([1,2,3],[4,5,6])
#changessss
double precision t,u,dfu,rpar
dimension u(neq),dfu(ldfu,neq),rpar(*),ipar(*)
integer i,j
do 10 j = 1,neq
dfu(1,j) = -2.0d0
dfu(2,j) = 1.0d0
10 dfu(6,j) = 1.0d0
do 20 j = 5,neq,5
20 dfu(2,j) = 0.0d0
return
end
"""
# Compile these Fortran subroutines
from numpy import f2py
f2py.compile(f_str+'\n'+jac_banded_str, modulename='tmp_callback', verbose=False)
import tmp_callback
f_f77, jac_banded_f77 = tmp_callback.f_f77, tmp_callback.jac_f77_radau5
import sys
try:
n_points = int(sys.argv[1]) # Read from input
except:
n_points = 10 # default number of time-steps
t0, tn, u0 = 0., 4., [1]+24*[0]
ml, mu = 5, 0
time_points = np.linspace(t0, tn, n_points)
atol, rtol = 1e-2, 1e-2
