def execute(self, p, desc_ext=None, hpc=None, make_call=True):
"""
Check that instance of problem has not been run (if database specified),
create input file, call executable, and add instance to database (if
applicable)
"""
# Create input file and check if instance contained in database
self.create_input_file(p, desc_ext, self.db)
exist = self.check_database(desc_ext)
if not exist:
# If instance does not exist, write input file, call executable,
# and add to database
self.writeInputFile()
# for coupled simulations, self.infile and self.log will be arrays
if hasattr(self.infile, "__iter__"):
infileArray = [x.fname for x in self.infile]
logFile = self.infile[0].log + "-" + self.infile[1].log
else:
infileArray = self.infile.fname
logFile = self.infile.log
exec_str = hpc.execute_str(self.bin, infileArray)
current_dir = os.getcwd()
os.chdir(self.exec_dir)
execute_code(exec_str, logFile, make_call)
os.chdir(current_dir)
if self.db is not None:
self.db.add_entry(p, self.desc, self.infile)
def run_cd2tet_fromtop(top, out, log=None, make_call=True, cd2tet=None):
# Default cd2tet executable
if cd2tet is None: cd2tet = os.path.expandvars('$CD2TET')
# Build execution string, execute
exec_str = "{0:s} -mesh {1:s} -output {2:s}".format(cd2tet, top, out)
execute_code(exec_str, log, make_call)
def cat_split_gen(fname_root, fname_gen, n, cleanup=False):
s = ''
for k in range(n):
s += ' {0:s}'.format(fname_gen(k))
cat_str = 'cat {0:s} > {1:s}'.format(s, fname_root)
execute_code(cat_str, None, True)
if cleanup:
rm_str = 'rm {0:s}'.format(s)
execute_code(rm_str, None, True)
def cat_split(fname_root, npartition, cleanup=False):
s = ''
for k in range(npartition):
s += ' {0:s}.{1:d}parts.part{2:s}'.format(fname_root, npartition,
str(k).zfill(len(str(npartition))))
cat_str = 'cat {0:s} > {1:s}'.format(s, fname_root)
execute_code(cat_str, None, True)
if cleanup:
rm_str = 'rm {0:s}'.format(s)
execute_code(rm_str, None, True)
def run_matcher(top, feminput, geom_prefix, log=None, make_call=True, matcher=None):
# Default matcher executable
if matcher is None: matcher = os.path.expandvars('$MATCHER')
# Build execution string, execute
exec_str = "{0:s} {1:s} {2:s} -output {3:s}".format(matcher, top, feminput,
geom_prefix)
execute_code(exec_str, log, make_call)
return "{0:s}.match.fluid".format(geom_prefix)
def run_xp2exo(top, exo_out, xpost_in=[], log=None, make_call=True,
xp2exo=None):
# Default xp2exo executable
if xp2exo is None: xp2exo = os.path.expandvars('$XP2EXO')
# Build execution string, execute
exec_str = "{0:s} {1:s} {2:s}".format(xp2exo, top, exo_out)
for res in xpost_in:
exec_str = "{0:s} {1:s}".format(exec_str, res)
execute_code(exec_str, log, make_call)
def sower_fluid_mesh_motion(mm_file, msh, con, out, bccode=-3, log=None,
make_call=True, sower=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = ("{0:s} -fluid -split -con {1:s} -mesh {2:s} "+
"-result {3:s} -ascii -bc {4:d} -out {5:s}").format(
sower, con, msh, mm_file, bccode, out)
execute_code(exec_str, log, make_call)
def sower_fluid_merge(res_file, msh, con, out, name, from_bin=False, log=None,
make_call=True, sower=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = "{0:s} -fluid -merge -con {1:s}".format(sower, con)
exec_str = "{0:s} -mesh {1:s} -result {2:s}".format(exec_str, msh, res_file)
exec_str = "{0:s} -name {1:s} -out {2:s}".format(exec_str, name, out)
if from_bin: exec_str = "{0:s} -binary".format(exec_str)
execute_code(exec_str, log, make_call)
def sower_fluid_split(file2split, msh, con, out, from_ascii=True, log=None,
make_call=True, sower=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = ("{0:s} -fluid -split -con {1:s} -mesh {2:s} "+
"-result {3:s}").format(sower, con, msh, file2split)
if from_ascii: exec_str = "{0:s} -ascii".format(exec_str)
exec_str = "{0:s} -out {1:s}".format(exec_str, out)
execute_code(exec_str, log, make_call)
def sower_fluid_extract_surf(msh, con, surf_top, bccode=-3, log=None,
make_call=True, sower=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = ("{0:s} -fluid -merge -con {1:s} -mesh {2:s} "+
"-skin {3:s} -bc {4:d}").format(sower, con, msh, surf_top,
bccode)
execute_code(exec_str, log, make_call)
subprocess.call('mv {0:s}.xpost {0:s}'.format(surf_top), shell=True)
def sower_fluid_top(top, dec, cpus, nclust, geom_prefix, log=None,
make_call=True, sower=None, match=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = "{0:s} -fluid -mesh {1:s} -dec {2:s}".format(sower, top, dec)
for cpu in cpus:
exec_str += " -cpu {0:d}".format(cpu)
if match is not None:
exec_str += " -match {0:s}".format(match)
exec_str += " -cluster {0:d} -output {1:s}".format(nclust, geom_prefix)
execute_code(exec_str, log, make_call)
def execute(self, p, desc_ext=None, hpc=None, make_call=True):
# Create input file and check if instance contained in database
self.create_input_file(p, desc_ext, self.db)
exist = self.check_database(self.infile, desc_ext)
# If instance does not exist, write input file, call executable,
# and add to database
if not exist:
self.infile.write()
prepare_directory(self.infile.fname, self.femesh)
exec_str = execute_str(self.bin, tmp_fname)
execute_code(exec_str, self.infile.log, make_call)
clean_directory(self.femesh, self.infile.vmo, self.infile.der)
if self.db is not None: self.db.add_entry(p, self.desc, self.infile)
def sower_fluid_merge_geom(msh,
con,
dec,
from_bin=False,
log=None,
make_call=True,
sower=None):
# Default sower executable
if sower is None: sower = os.path.expandvars('$SOWER')
# Build execution string, execute
exec_str = "{0:s} -fluid -merge -con {1:s}".format(sower, con)
exec_str = "{0:s} -mesh {1:s} -dec {2:s}".format(exec_str, msh, dec)
if from_bin: exec_str = "{0:s} -binary".format(exec_str)
execute_code(exec_str, log, make_call)
def part_mesh(top, ndec, log=None, make_call=True, partmesh=None):
# Default partnmesh executable
if partmesh is None: partmesh = os.path.expandvars('$PARTMESH')
# Build execution string, execute
if make_call:
top_old = copy.copy(top)
top = top.split('/')[-1]+'.copy'
subprocess.call('cp {0:s} {1:s}'.format(top_old, top), shell=True)
exec_str = "{0:s} {1:s} {2:d}".format(partmesh, top, ndec)
execute_code(exec_str, log, make_call)
if make_call:
subprocess.call('rm {0:s}'.format(top), shell=True)
subprocess.call('mv {0:s}.dec.{2:d} {1:s}.dec.{2:d}'.format(top,
top_old, ndec), shell=True)
top = copy.copy(top_old)
return "{0:s}.dec.{1:d}".format(top, ndec)
def run_code(x,
deform_obj,
ptcloud,
vmo,
der=None,
eps=1.0e-8,
xpost=None,
log='blender.tmp.log',
make_call=True,
blender_exec=None,
bg=True,
mpiexec=None,
nproc=1):
"""
Pickle input arguments and run Blender.
"""
# Pickle *args for unpickling inside blender call (don't change fnamePickle
# unless you change it in blender_deform.py as well)
import pickle
pkf = open(pickle_filename(), 'wb')
pickle.dump([x, deform_obj, ptcloud, vmo, der, eps, xpost], pkf)
pkf.close()
# Default blender executable
if blender_exec is None: blender_exec = os.path.expandvars('$BLENDER')
# Build execution string
exec_str = blender_exec
if mpiexec is not None and nproc > 1:
exec_str = "{0:s} -n {1:d} {2:s}".format(mpiexec, nproc, exec_str)
if bg: exec_str += ' -b'
# exec_str+=(' -P '+os.path.expandvars('$PYAEROOPT')+
# 'pyaeroopt/util/blender/deform.py')
exec_str += (' -b -P ' + os.path.expandvars('$PYAEROOPT') +
'pyaeroopt/util/blender/deform2.py')
# Call Blender and clean directory
import sys
start_time = time.time()
execute_code(exec_str, log, make_call)
print('blender time def: ', time.time() - start_time)
sys.stdout.flush()
clean_directory()
def execute(self, p, desc_ext=None, hpc=None, make_call=True):
"""
Check that instance of problem has not been run (if database specified),
create input file, call executable, and add instance to database (if
applicible)
"""
# Create input file and check if instance contained in database
self.create_input_file(p, desc_ext, self.db)
exist = self.check_database(self.infile, desc_ext)
if not exist:
# If instance does not exist, write input file, call executable,
# and add to database
self.infile.write()
exec_str = hpc.execute_str(self.bin, self.infile.fname)
execute_code(exec_str, self.infile.log, make_call)
if self.db is not None:
self.db.add_entry(p, self.desc, self.infile)
