def __init__(self, backend, rallocs, mesh, initsoln, cfg):
self.backend = backend
self.rallocs = rallocs
self.isrestart = initsoln is not None
self.cfg = cfg
self.prevcfgs = {
f: initsoln[f]
for f in initsoln or [] if f.startswith('config-')
}
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 'tstart', 0.0)
self.tend = cfg.getfloat('solver-time-integrator', 'tend')
# Current time; defaults to tstart unless restarting
if self.isrestart:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
else:
self.tcurr = self.tstart
# List of target times to advance to
self.tlist = deque([self.tend])
# Accepted and rejected step counters
self.nacptsteps = 0
self.nrjctsteps = 0
self.nacptchain = 0
# Current and minimum time steps
self._dt = cfg.getfloat('solver-time-integrator', 'dt')
self.dtmin = cfg.getfloat('solver-time-integrator', 'dt-min', 1e-12)
# Extract the UUID of the mesh (to be saved with solutions)
self.mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Solution cache
self._curr_soln = None
# Solution gradients cache
self._curr_grad_soln = None
# Record the starting wall clock time
self._wstart = time.time()
# Abort computation
self.abort = False
def __init__(self, backend, systemcls, rallocs, mesh, initsoln, cfg):
from mpi4py import MPI
self.backend = backend
self.rallocs = rallocs
self.cfg = cfg
# Sanity checks
if self._controller_needs_errest and not self._stepper_has_errest:
raise TypeError('Incompatible stepper/controller combination')
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 't0', 0.0)
# Output times
self.tout = sorted(range_eval(cfg.get('soln-output', 'times')))
self.tend = self.tout[-1]
# Current time; defaults to tstart unless resuming a simulation
if initsoln is None or 'stats' not in initsoln:
self.tcurr = self.tstart
else:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
# Cull already written output times
self.tout = [t for t in self.tout if t > self.tcurr]
# Ensure no time steps are in the past
if self.tout[0] < self.tcurr:
raise ValueError('Output times must be in the future')
# Determine the amount of temp storage required by thus method
nreg = self._stepper_nregs
# Construct the relevant mesh partition
self._system = systemcls(backend, rallocs, mesh, initsoln, nreg, cfg)
# Extract the UUID of the mesh (to be saved with solutions)
self._mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Get the number of degrees of freedom in this partition
ndofs = sum(self._system.ele_ndofs)
# Sum to get the global number over all partitions
self._gndofs = MPI.COMM_WORLD.allreduce(ndofs, op=MPI.SUM)
def __init__(self, backend, rallocs, mesh, initsoln, cfg):
self.backend = backend
self.rallocs = rallocs
self.isrestart = initsoln is not None
self.cfg = cfg
self.prevcfgs = {f: initsoln[f] for f in initsoln or []
if f.startswith('config-')}
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 'tstart', 0.0)
self.tend = cfg.getfloat('solver-time-integrator', 'tend')
# Current time; defaults to tstart unless restarting
if self.isrestart:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
else:
self.tcurr = self.tstart
# List of target times to advance to
self.tlist = deque([self.tend])
# Accepted and rejected step counters
self.nacptsteps = 0
self.nrjctsteps = 0
self.nacptchain = 0
# Current and minimum time steps
self._dt = cfg.getfloat('solver-time-integrator', 'dt')
self.dtmin = cfg.getfloat('solver-time-integrator', 'dt-min', 1e-12)
# Extract the UUID of the mesh (to be saved with solutions)
self.mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Solution cache
self._curr_soln = None
# Add kernel cache
self._axnpby_kerns = {}
# Record the starting wall clock time
self._wstart = time.time()
def __init__(self, backend, systemcls, rallocs, mesh, initsoln, cfg):
self.backend = backend
self.rallocs = rallocs
self.cfg = cfg
self.isrestart = initsoln is not None
# Sanity checks
if self._controller_needs_errest and not self._stepper_has_errest:
raise TypeError('Incompatible stepper/controller combination')
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 'tstart', 0.0)
self.tend = cfg.getfloat('solver-time-integrator', 'tend')
# Current time; defaults to tstart unless restarting
if self.isrestart:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
else:
self.tcurr = self.tstart
self.tlist = deque([self.tend])
# Determine the amount of temp storage required by thus method
nreg = self._stepper_nregs
# Construct the relevant mesh partition
self.system = systemcls(backend, rallocs, mesh, initsoln, nreg, cfg)
# Extract the UUID of the mesh (to be saved with solutions)
self.mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Get the number of degrees of freedom in this partition
ndofs = sum(self.system.ele_ndofs)
comm, rank, root = get_comm_rank_root()
# Sum to get the global number over all partitions
self._gndofs = comm.allreduce(ndofs, op=get_mpi('sum'))
def __init__(self, backend, systemcls, rallocs, mesh, initsoln, cfg):
self.backend = backend
self.rallocs = rallocs
self.isrestart = initsoln is not None
self.cfg = cfg
self.prevcfgs = {f: initsoln[f] for f in initsoln or []
if f.startswith('config-')}
# Ensure the system is compatible with our formulation
if self.formulation not in systemcls.elementscls.formulations:
raise RuntimeError(
'System {0} does not support time stepping formulation {1}'
.format(systemcls.name, self.formulation)
)
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 'tstart', 0.0)
self.tend = cfg.getfloat('solver-time-integrator', 'tend')
# Current time; defaults to tstart unless restarting
if self.isrestart:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
else:
self.tcurr = self.tstart
# List of target times to advance to
self.tlist = deque([self.tend])
# Accepted and rejected step counters
self.nacptsteps = 0
self.nrjctsteps = 0
self.nacptchain = 0
# Current and minimum time steps
self._dt = cfg.getfloat('solver-time-integrator', 'dt')
self.dtmin = cfg.getfloat('solver-time-integrator', 'dt-min', 1e-12)
# Determine the amount of temp storage required by this method
self.nreg = self._stepper_nregs
# Construct the relevant mesh partition
self._init_system(systemcls, backend, rallocs, mesh, initsoln)
# Storage for register banks and current index
self._init_reg_banks()
# Extract the UUID of the mesh (to be saved with solutions)
self.mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Global degree of freedom count
self._gndofs = self._get_gndofs()
# Solution cache
self._curr_soln = None
# Add kernel cache
self._axnpby_kerns = {}
# Record the starting wall clock time
self._wstart = time.time()
# Event handlers for advance_to
self.completed_step_handlers = proxylist(self._get_plugins())
# Delete the memory-intensive elements map from the system
del self.system.ele_map
def __init__(self, backend, systemcls, rallocs, mesh, initsoln, cfg):
self.backend = backend
self.rallocs = rallocs
self.isrestart = initsoln is not None
self.cfg = cfg
self.prevcfgs = {f: initsoln[f] for f in initsoln or []
if f.startswith('config-')}
# Ensure the system is compatible with our formulation
if self.formulation not in systemcls.elementscls.formulations:
raise RuntimeError(
'System {0} does not support time stepping formulation {1}'
.format(systemcls.name, self.formulation)
)
# Start time
self.tstart = cfg.getfloat('solver-time-integrator', 'tstart', 0.0)
self.tend = cfg.getfloat('solver-time-integrator', 'tend')
# Current time; defaults to tstart unless restarting
if self.isrestart:
stats = Inifile(initsoln['stats'])
self.tcurr = stats.getfloat('solver-time-integrator', 'tcurr')
else:
self.tcurr = self.tstart
# List of target times to advance to
self.tlist = deque([self.tend])
# Accepted and rejected step counters
self.nacptsteps = 0
self.nrjctsteps = 0
self.nacptchain = 0
# Current and minimum time steps
self._dt = self.cfg.getfloat('solver-time-integrator', 'dt')
self.dtmin = 1.0e-12
# Determine the amount of temp storage required by this method
nreg = self._stepper_nregs
# Construct the relevant mesh partition
self.system = systemcls(backend, rallocs, mesh, initsoln, nreg, cfg)
# Storage register banks
self._regs, self._regidx = self._get_reg_banks(nreg)
# Extract the UUID of the mesh (to be saved with solutions)
self.mesh_uuid = mesh['mesh_uuid']
# Get a queue for subclasses to use
self._queue = backend.queue()
# Global degree of freedom count
self._gndofs = self._get_gndofs()
# Bank index of solution
self._idxcurr = 0
# Solution cache
self._curr_soln = None
# Add kernel cache
self._axnpby_kerns = {}
# Record the starting wall clock time
self._wstart = time.time()
# Event handlers for advance_to
self.completed_step_handlers = proxylist(self._get_plugins())
# Delete the memory-intensive elements map from the system
del self.system.ele_map
def process_tavg(args):
infs = {}
# Interrogate files passed by the shell
for fname in args.infs:
# Load solution files and obtain solution times
inf = read_pyfr_data(fname)
cfg = Inifile(inf["stats"])
tinf = cfg.getfloat("solver-time-integrator", "tcurr")
# Retain if solution time is within limits
if args.limits is None or args.limits[0] <= tinf <= args.limits[1]:
infs[tinf] = inf
# Verify that solutions were computed on the same mesh3
if inf["mesh_uuid"] != next(iter(infs.values()))["mesh_uuid"]:
raise RuntimeError("Solution files in scope were not" " computed on the same mesh")
# Sort the solution times, check for sufficient files in scope
stimes = sorted(infs)
if len(infs) <= 1:
raise RuntimeError("More than one solution file is required to " "compute an average")
# Initialise progress bar
pb = ProgressBar(0, 0, len(stimes), 0)
# Copy over the solutions from the first time dump
solnfs = infs[stimes[0]].soln_files
avgs = {s: infs[stimes[0]][s].copy() for s in solnfs}
# Weight the initialised trapezoidal mean
dtnext = stimes[1] - stimes[0]
for name in solnfs:
avgs[name] *= 0.5 * dtnext
pb.advance_to(1)
# Compute the trapezoidal mean up to the last solution file
for i in range(len(stimes[2:])):
dtlast = dtnext
dtnext = stimes[i + 2] - stimes[i + 1]
# Weight the current solution, then add to the mean
for name in solnfs:
avgs[name] += 0.5 * (dtlast + dtnext) * infs[stimes[i + 1]][name]
pb.advance_to(i + 2)
# Weight final solution, update mean and normalise for elapsed time
for name in solnfs:
avgs[name] += 0.5 * dtnext * infs[stimes[-1]][name]
avgs[name] *= 1.0 / (stimes[-1] - stimes[0])
pb.advance_to(i + 3)
# Compute and assign stats for a time-averaged solution
stats = Inifile()
stats.set("time-average", "tmin", stimes[0])
stats.set("time-average", "tmax", stimes[-1])
stats.set("time-average", "ntlevels", len(stimes))
avgs["stats"] = stats.tostr()
# Copy over the ini file and mesh uuid
avgs["config"] = infs[stimes[0]]["config"]
avgs["mesh_uuid"] = infs[stimes[0]]["mesh_uuid"]
# Save to disk
with h5py.File(args.outf, "w") as f:
for k, v in avgs.items():
f[k] = v
