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