def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Base output directory and file name
basedir = self.cfg.getpath(self.cfgsect, 'basedir', '.', abs=True)
basename = self.cfg.get(self.cfgsect, 'basename')
# Construct the solution writer
self._writer = NativeWriter(intg, basedir, basename, 'soln')
# Output time step and last output time
self.dt_out = self.cfg.getfloat(cfgsect, 'dt-out')
self.tout_last = intg.tcurr
# Output field names
self.fields = intg.system.elementscls.convarmap[self.ndims]
# Output data type
self.fpdtype = intg.backend.fpdtype
# Register our output times with the integrator
intg.call_plugin_dt(self.dt_out)
# If we're not restarting then make sure we write out the initial
# solution when we are called for the first time
if not intg.isrestart:
self.tout_last -= self.dt_out
def _init_writer_for_region(self, intg, nout, prefix, *, fpdtype=None):
# Base output directory and file name
basedir = self.cfg.getpath(self.cfgsect, 'basedir', '.', abs=True)
basename = self.cfg.get(self.cfgsect, 'basename')
# Data type
if fpdtype is None:
fpdtype = intg.backend.fpdtype
elif fpdtype == 'single':
fpdtype = np.float32
elif fpdtype == 'double':
fpdtype = np.float64
else:
raise ValueError('Invalid floating point data type')
# Region of interest
region = self.cfg.get(self.cfgsect, 'region', '*')
# All elements
if region == '*':
mdata = self._prepare_mdata_all(intg, fpdtype, nout, prefix)
self._add_region_data = self._add_region_data_all
# All elements inside a box
elif '(' in region or '[' in region:
box = self.cfg.getliteral(self.cfgsect, 'region')
mdata = self._prepare_mdata_box(intg, fpdtype, nout, prefix, *box)
self._add_region_data = self._add_region_data_subset
# All elements on a boundary
else:
mdata = self._prepare_mdata_bcs(intg, fpdtype, nout, prefix,
region)
self._add_region_data = self._add_region_data_subset
# Construct the file writer
return NativeWriter(intg, mdata, basedir, basename)
def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Construct the solution writer
basedir = self.cfg.getpath(cfgsect, 'basedir', '.')
basename = self.cfg.get(cfgsect, 'basename')
self._writer = NativeWriter(intg,
self.nvars,
basedir,
basename,
prefix='soln')
# Output time step and next output time
self.dt_out = self.cfg.getfloat(cfgsect, 'dt-out')
self.tout_next = intg.tcurr
# Output field names
self.fields = intg.system.elementscls.convarmap[self.ndims]
# Register our output times with the integrator
intg.call_plugin_dt(self.dt_out)
# If we're not restarting then write out the initial solution
if not intg.isrestart:
self(intg)
else:
self.tout_next += self.dt_out
def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Underlying elements class
self.elementscls = intg.system.elementscls
# Expressions to time average
c = self.cfg.items_as('constants', float)
self.exprs = [(k, self.cfg.getexpr(cfgsect, k, subs=c))
for k in self.cfg.items(cfgsect)
if k.startswith('avg-')]
# Save a reference to the physical solution point locations
self.plocs = intg.system.ele_ploc_upts
# Output file directory, base name, and writer
basedir = self.cfg.getpath(cfgsect, 'basedir', '.')
basename = self.cfg.get(cfgsect, 'basename')
self._writer = NativeWriter(intg, len(self.exprs), basedir, basename,
prefix='tavg')
# Time averaging parameters
self.dtout = self.cfg.getfloat(cfgsect, 'dt-out')
self.nsteps = self.cfg.getint(cfgsect, 'nsteps')
self.tout = intg.tcurr + self.dtout
# Register our output times with the integrator
intg.call_plugin_dt(self.dtout)
# Time averaging state
self.prevt = intg.tcurr
self.prevex = self._eval_exprs(intg)
self.accmex = [np.zeros_like(p) for p in self.prevex]
def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Underlying elements class
self.elementscls = intg.system.elementscls
# Expressions to time average
c = self.cfg.items_as('constants', float)
self.exprs = [(k, self.cfg.getexpr(cfgsect, k, subs=c))
for k in self.cfg.items(cfgsect)
if k.startswith('avg-')]
# Gradient pre-processing
self._init_gradients(intg)
# Save a reference to the physical solution point locations
self.plocs = intg.system.ele_ploc_upts
# Element info and backend data type
einfo = zip(intg.system.ele_types, intg.system.ele_shapes)
fpdtype = intg.backend.fpdtype
# Output metadata
mdata = [(f'tavg_{etype}', (nupts, len(self.exprs), neles), fpdtype)
for etype, (nupts, _, neles) in einfo]
# Output base directory and name
basedir = self.cfg.getpath(cfgsect, 'basedir', '.', abs=True)
basename = self.cfg.get(cfgsect, 'basename')
self._writer = NativeWriter(intg, mdata, basedir, basename)
# Time averaging parameters
self.dtout = self.cfg.getfloat(cfgsect, 'dt-out')
self.nsteps = self.cfg.getint(cfgsect, 'nsteps')
self.tout_last = intg.tcurr
# Register our output times with the integrator
intg.call_plugin_dt(self.dtout)
# Time averaging state
self.prevt = intg.tcurr
self.prevex = self._eval_exprs(intg)
self.accmex = [np.zeros_like(p) for p in self.prevex]
def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Underlying elements class
self.elementscls = intg.system.elementscls
# Averaging mode
self.mode = self.cfg.get(cfgsect, 'mode', 'windowed')
if self.mode not in {'continuous', 'windowed'}:
raise ValueError('Invalid averaging mode')
# Expressions pre-processing
self._prepare_exprs()
# Output data type
fpdtype = self.cfg.get(cfgsect, 'precision', 'single')
if fpdtype == 'single':
self.fpdtype = np.float32
elif fpdtype == 'double':
self.fpdtype = np.float64
else:
raise ValueError('Invalid floating point data type')
# Base output directory and file name
basedir = self.cfg.getpath(self.cfgsect, 'basedir', '.', abs=True)
basename = self.cfg.get(self.cfgsect, 'basename')
# Construct the file writer
self._writer = NativeWriter(intg, basedir, basename, 'tavg')
# Gradient pre-processing
self._init_gradients(intg)
# Time averaging parameters
self.tstart = self.cfg.getfloat(cfgsect, 'tstart', 0.0)
self.dtout = self.cfg.getfloat(cfgsect, 'dt-out')
self.nsteps = self.cfg.getint(cfgsect, 'nsteps')
# Register our output times with the integrator
intg.call_plugin_dt(self.dtout)
# Mark ourselves as not currently averaging
self._started = False
def save_solution(self, savedir, basename, t=0):
ndims = self.solver.system.ndims
nvars = self.solver.system.nvars
writer = NativeWriter(self.solver,
nvars,
savedir,
basename,
prefix='soln')
fields = self.solver.system.elementscls.convarmap[ndims]
stats = Inifile()
stats.set('data', 'fields', ','.join(fields))
stats.set('data', 'prefix', 'soln')
self.solver.collect_stats(stats)
stats.set('solver-time-integrator', 'tcurr', str(t))
metadata = dict(self.solver.cfgmeta,
stats=stats.tostr(),
mesh_uuid=self.solver.mesh_uuid)
writer.write(self.solver.soln, metadata, t)
def __init__(self, intg, cfgsect, suffix=None):
super().__init__(intg, cfgsect, suffix)
# Output region
region = self.cfg.get(cfgsect, 'region', '*')
# All elements
if region == '*':
mdata = self._prepare_mdata_all(intg)
self._prepare_data = self._prepare_data_all
# All elements inside a box
elif ',' in region:
box = self.cfg.getliteral(cfgsect, 'region')
mdata = self._prepare_mdata_box(intg, *box)
self._prepare_data = self._prepare_data_subset
# All elements on a boundary
else:
mdata = self._prepare_mdata_bcs(intg, region)
self._prepare_data = self._prepare_data_subset
# Construct the solution writer
basedir = self.cfg.getpath(cfgsect, 'basedir', '.', abs=True)
basename = self.cfg.get(cfgsect, 'basename')
self._writer = NativeWriter(intg, mdata, basedir, basename)
# Output time step and last output time
self.dt_out = self.cfg.getfloat(cfgsect, 'dt-out')
self.tout_last = intg.tcurr
# Output field names
self.fields = intg.system.elementscls.convarmap[self.ndims]
# Register our output times with the integrator
intg.call_plugin_dt(self.dt_out)
# If we're not restarting then write out the initial solution
if not intg.isrestart:
self.tout_last -= self.dt_out
self(intg)