def callback_initialization(q, qbc, aux, subdivision_factor_x0, subdivision_factor_x1, subdivision_factor_x2, unknowns_per_subcell, aux_fields_per_subcell, size_x, size_y, size_z, position_x, position_y, position_z): import clawpack.pyclaw as pyclaw dim = get_number_of_dimensions(q) if dim is 2: self.dim_x = pyclaw.Dimension('x',position_x,position_x + size_x,subdivision_factor_x0) self.dim_y = pyclaw.Dimension('y',position_y,position_y + size_y,subdivision_factor_x1) domain = pyclaw.Domain([self.dim_x,self.dim_y]) elif dim is 3: self.dim_x = pyclaw.Dimension('x',position_x,position_x + size_x,subdivision_factor_x0) self.dim_y = pyclaw.Dimension('y',position_y,position_y + size_y,subdivision_factor_x1) self.dim_z = pyclaw.Dimension('z',position_z,position_z + size_z,subdivision_factor_x2) domain = pyclaw.Domain([self.dim_x,self.dim_y,self.dim_z]) domain = pyclaw.Domain([self.dim_x,self.dim_y]) subgrid_state = pyclaw.State(domain, unknowns_per_subcell, aux_fields_per_subcell) subgrid_state.q = q if(aux_fields_per_subcell > 0): subgrid_state.aux = aux subgrid_state.problem_data = self.solver.solution.state.problem_data self.q_initialization(subgrid_state) if(self.aux_initialization != None and aux_fields_per_subcell > 0): self.aux_initialization(subgrid_state) #Steer refinement if self.refinement_criterion != None: return self.refinement_criterion(subgrid_state) else: return self.initial_minimal_mesh_width
def callback_add_to_solution(q, qbc, ghostlayer_width, size_x, size_y, size_z, position_x, position_y, position_z, currentTime): dim = get_number_of_dimensions( q ) #TODO 3D: Adjust subdivision_factor to 3D # Set up grid information for current patch if dim is 2: subdivision_factor_x = q.shape[1] subdivision_factor_y = q.shape[2] unknowns_per_subcell = q.shape[0] dim_x = pyclaw.Dimension('x', position_x, position_x + size_x, subdivision_factor_x) dim_y = pyclaw.Dimension('y', position_y, position_y + size_y, subdivision_factor_y) patch = pyclaw.geometry.Patch((dim_x, dim_y)) elif dim is 3: subdivision_factor_x = q.shape[1] subdivision_factor_y = q.shape[2] subdivision_factor_z = q.shape[3] unknowns_per_subcell = q.shape[0] dim_x = pyclaw.Dimension('x', position_x, position_x + size_x, subdivision_factor_x) dim_y = pyclaw.Dimension('y', position_y, position_y + size_y, subdivision_factor_y) dim_z = pyclaw.Dimension('z', position_z, position_z + size_z, subdivision_factor_z) patch = pyclaw.geometry.Patch((dim_x, dim_y,dim_z)) state = pyclaw.State(patch, unknowns_per_subcell) state.q[:] = q[:] state.t = currentTime self.gathered_patches.append(patch) self.gathered_states.append(state)
def __init__(self, solver, global_state, q, qbc, aux, position, size, subdivision_factor, unknowns_per_cell, aux_fields_per_cell, current_time): r""" Initializes this subgrid solver. It get's all information to prepare a domain and state for a single subgrid. :Input: - *solver* - (:class:`pyclaw.Solver`) The PyClaw-solver used for advancing this subgrid in time. - *global_state* - (:class:`pyclaw.State`) The global state. This is not the state used for for the actual solving of the timestep on the subgrid. - *q* - The array storing the current solution. - *qbc* - The array storing the solution of the last timestep including the ghostlayer. - *position* - A d-dimensional tuple holding the position of the grid in the computational domain. This measures the continuous real-world position in floats, not the integer position in terms of cells. - *size* - A d-dimensional tuple holding the size of the grid in the computational domain. This measures the continuous real-world size in floats, not the size in terms of cells. - *subdivision_factor* - The number of cells in one dimension of this subgrid. At the moment only square subgrids are allowed, so the total number of cells in the subgrid (excluding the ghostlayer) is subdivision_factor x subdivision_factor. - *unknowns_per_cell* - The number of equations or unknowns that are stored per cell of the subgrid. """ self.solver = solver number_of_dimensions = get_number_of_dimensions(q) self.domain = create_domain(number_of_dimensions, position, size, subdivision_factor) subgrid_state = create_subgrid_state(global_state, self.domain, q, qbc, aux, unknowns_per_cell, aux_fields_per_cell) subgrid_state.problem_data = global_state.problem_data self.solution = pyclaw.Solution(subgrid_state, self.domain) self.solution.t = current_time self.solver.bc_lower[:] = [pyclaw.BC.custom] * len(self.solver.bc_lower) self.solver.bc_upper[:] = [pyclaw.BC.custom] * len(self.solver.bc_upper) self.qbc = qbc self.solver.user_bc_lower = self.user_bc_lower self.solver.user_bc_upper = self.user_bc_upper self.recover_ghostlayers = False
def callback_interpolation( source_q, source_qbc, source_aux, source_subdivision_factor_x0, source_subdivision_factor_x1, source_subdivision_factor_x2, source_size_x0, source_size_x1, source_size_x2, source_position_x0, source_position_x1, source_position_x2, source_current_time, source_timestep_size, destination_q, destination_qbc, destination_aux, destination_subdivision_factor_x0, destination_subdivision_factor_x1, destination_subdivision_factor_x2, destination_size_x0, destination_size_x1, destination_size_x2, destination_position_x0, destination_position_x1, destination_position_x2, destination_current_time, destination_timestep_size, unknowns_per_cell, aux_fields_per_cell): # Fix aux array if(aux_fields_per_cell == 0): source_aux = None destination_aux = None number_of_dimensions = get_number_of_dimensions(source_q) source_domain = create_domain(number_of_dimensions, (source_position_x0, source_position_x1, source_position_x2), (source_size_x0, source_size_x1, source_size_x2), (source_subdivision_factor_x0, source_subdivision_factor_x1, source_subdivision_factor_x2)) source_subgrid_state = create_subgrid_state( self.solver.solution.state, source_domain, source_q, source_qbc, source_aux, unknowns_per_cell, aux_fields_per_cell) destination_domain = create_domain(number_of_dimensions, (destination_position_x0, destination_position_x1, destination_position_x2), (destination_size_x0, destination_size_x1, destination_size_x2), (destination_subdivision_factor_x0, destination_subdivision_factor_x1, destination_subdivision_factor_x2)) destination_subgrid_state = create_subgrid_state( self.solver.solution.state, destination_domain, destination_q, destination_qbc, destination_aux, unknowns_per_cell, aux_fields_per_cell) self.interpolation(source_subgrid_state, source_qbc, destination_subgrid_state, destination_qbc)
def __init__(self, solution, initial_minimal_mesh_width, use_dimensional_splitting_optimization, ghostlayer_width, dt_initial, initialization_callback, solver_callback, boundary_condition_callback, interpolation_callback, restriction_callback, flux_correction_callback): ''' Constructor ''' dim = get_number_of_dimensions( solution.q ) logging.getLogger('peanoclaw').info("Loading Peano-library...") self.libpeano = CDLL(self.get_lib_path(dim),mode=RTLD_GLOBAL) logging.getLogger('peanoclaw').info("Peano loaded successfully.") self.libpeano.pyclaw_peano_new.restype = c_void_p self.libpeano.pyclaw_peano_destroy.argtypes = [c_void_p] self.libpeano.pyclaw_peano_evolveToTime.argtypes = [c_double, c_void_p] self.boundary_condition_callback = boundary_condition_callback self.solver_callback = solver_callback self.interpolation_callback = interpolation_callback self.restriction_callback = restriction_callback self.flux_correction_callback = flux_correction_callback # Get parameters for Peano dimensions = solution.state.grid.dimensions subdivision_factor_x0 = solution.state.grid.dimensions[0].num_cells subdivision_factor_x1 = solution.state.grid.dimensions[1].num_cells if dim is 3: subdivision_factor_x2 = solution.state.grid.dimensions[2].num_cells else: subdivision_factor_x2 = 0 number_of_unknowns = solution.state.num_eqn number_of_auxiliar_fields = solution.state.num_aux import os, sys configuration_file = os.path.join(sys.path[0], 'peanoclaw-config.xml') if dim is 2: domain_position_x2 = 0 domain_size_x2 = 0 else: domain_position_x2 = dimensions[2].lower domain_size_x2 = dimensions[2].upper - dimensions[2].lower self.crank = c_int() self.libpeano.pyclaw_peano_new.argtypes = [ c_double, #Initial mesh width c_double, #Domain position X0 c_double, #Domain position X1 c_double, #Domain position X2 c_double, #Domain size X0 c_double, #Domain size X1 c_double, #Domain size X2 c_int, #Subdivision factor X0 c_int, #Subdivision factor X1 c_int, #Subdivision factor X2 c_int, #Number of unknowns c_int, #Number of auxiliar fields c_int, #Ghostlayer width c_double, #Initial timestep size c_char_p, #Config file c_bool, #Use dimensional splitting c_void_p, #q Initialization callback c_void_p, #Boundary condition callback c_void_p, #Solver callback c_void_p, #Solution callback c_void_p, #Interpolation callback c_void_p, #Restriction callback c_void_p, #Flux correction callback c_void_p #rank ] self.peano = self.libpeano.pyclaw_peano_new(c_double(initial_minimal_mesh_width), c_double(dimensions[0].lower), c_double(dimensions[1].lower), c_double(domain_position_x2), c_double(dimensions[0].upper - dimensions[0].lower), c_double(dimensions[1].upper - dimensions[1].lower), c_double(domain_size_x2), subdivision_factor_x0, subdivision_factor_x1, subdivision_factor_x2, number_of_unknowns, number_of_auxiliar_fields, ghostlayer_width, dt_initial, c_char_p(configuration_file), use_dimensional_splitting_optimization, initialization_callback.get_initialization_callback(), boundary_condition_callback.get_boundary_condition_callback(), solver_callback.get_solver_callback(), solution.get_add_to_solution_callback(), interpolation_callback.get_interpolation_callback(), restriction_callback.get_restriction_callback(), flux_correction_callback.get_flux_correction_callback(), byref(self.crank) ) self.rank = self.crank.value print 'peano instance: got rank: ', self.rank # Set PeanoSolution import clawpack.peanoclaw as peanoclaw if(isinstance(solution, peanoclaw.Solution)): solution.peano = self.peano solution.libpeano = self.libpeano else: logging.getLogger('peanoclaw').warning("Use peanoclaw.Solution instead of pyclaw.Solution together with peanoclaw.Solver to provide plotting functionality.") #Causes Ctrl+C to quit Peano signal.signal(signal.SIGINT, signal.SIG_DFL)