def __init__(self,start,goal,g): self.running = False # initial with running state self.done = False #for tell whether search is done if start == None: self.start = Node([0,0]) else: self.start = Node(start) self.goal_list = goal.copy() #print(self.goal_list) #self.g_temp = goal self.current_node = self.start # Create lists for open nodes and closed nodes self.open = [] self.closed = [] self.open.append(self.start) #for statistics stt = pygame.time.get_ticks() tracemalloc.start() self.astar_search(start,goal,g) CurrentMem, self.Peak_mem = tracemalloc.get_traced_memory() tracemalloc.stop() self.time_consumption = pygame.time.get_ticks() - stt print(self.Peak_mem,self.time_consumption) self.g_temp = self.goal_list.copy() self.goal = self.g_temp.pop(0)
def astar_search(self,start, end,g): # Create lists for open nodes and closed nodes open = [] closed = [] # Create a start node and an goal node start_node = Node(start, None) goal_node = Node(end.pop(0), None) # Add the start node open.append(start_node) # Loop until the open list is empty while len(open) > 0: # Sort the open list to get the node with the lowest cost first open.sort() # Get the node with the lowest cost current_node = open.pop(0) # Add the current node to the closed list closed.append(current_node) # Check goal #print(closed) if current_node == goal_node: if len(end) > 0: goal_node = Node(end.pop(0), None) else: return 0 open = [] closed = [] # Get neighbors neighbors = g.find_neighbors(current_node.position) # Loop neighbors for next in neighbors: neighbor = Node(next,current_node) # Check if the neighbor is in the closed list if(neighbor in closed): continue # Generate heuristics (Manhattan distance) neighbor.g = abs(neighbor.position[0] - start_node.position[0]) + abs(neighbor.position[1] - start_node.position[1]) neighbor.h = abs(neighbor.position[0] - goal_node.position[0]) + abs(neighbor.position[1] - goal_node.position[1]) neighbor.f = neighbor.g + neighbor.h # Check if neighbor is in open list and if it has a lower f value if self.chc(neighbor,open): open.append(neighbor)
def assign_new_to_values(grid, q_new, q, tmp): i_gm, i_env, i_uds, i_sd = q.domain_idx() slice_all_c = grid.slice_all(Center()) slice_all_n = grid.slice_all(Node()) for i in i_uds: q_new['w', i][slice_all_n] = [ q['w', i][k] for k in grid.over_elems(Node()) ] q_new['q_tot', i][slice_all_c] = [ q['q_tot', i][k] for k in grid.over_elems(Center()) ] q_new['q_rai', i][slice_all_c] = [ q['q_rai', i][k] for k in grid.over_elems(Center()) ] q_new['θ_liq', i][slice_all_c] = [ q['θ_liq', i][k] for k in grid.over_elems(Center()) ] return
def update_sol_gm(grid, q_new, q, q_tendencies, TS, tmp, tri_diag): i_gm, i_env, i_uds, i_sd = q.domain_idx() ρ_0_half = tmp['ρ_0'] ae = q['a', i_env] slice_real_n = grid.slice_real(Node()) slice_all_c = grid.slice_all(Center()) tri_diag.ρaK[slice_real_n] = [ ae.Mid(k) * tmp['K_h'].Mid(k) * ρ_0_half.Mid(k) for k in grid.over_elems_real(Node()) ] construct_tridiag_diffusion_O1(grid, TS.Δt, tri_diag, ρ_0_half, ae) tri_diag.f[slice_all_c] = [ q['q_tot', i_gm][k] + TS.Δt * q_tendencies['q_tot', i_gm][k] for k in grid.over_elems(Center()) ] solve_tridiag_wrapper(grid, q_new['q_tot', i_gm], tri_diag) tri_diag.f[slice_all_c] = [ q['θ_liq', i_gm][k] + TS.Δt * q_tendencies['θ_liq', i_gm][k] for k in grid.over_elems(Center()) ] solve_tridiag_wrapper(grid, q_new['θ_liq', i_gm], tri_diag) tri_diag.ρaK[slice_real_n] = [ ae.Mid(k) * tmp['K_m'].Mid(k) * ρ_0_half.Mid(k) for k in grid.over_elems_real(Node()) ] construct_tridiag_diffusion_O1(grid, TS.Δt, tri_diag, ρ_0_half, ae) tri_diag.f[slice_all_c] = [ q['U', i_gm][k] + TS.Δt * q_tendencies['U', i_gm][k] for k in grid.over_elems(Center()) ] solve_tridiag_wrapper(grid, q_new['U', i_gm], tri_diag) tri_diag.f[slice_all_c] = [ q['V', i_gm][k] + TS.Δt * q_tendencies['V', i_gm][k] for k in grid.over_elems(Center()) ] solve_tridiag_wrapper(grid, q_new['V', i_gm], tri_diag) return
def compute_prognostic_updrafts(self, grid, q_new, q, q_tendencies, tmp, UpdVar, Case, TS): time_elapsed = 0.0 i_gm, i_env, i_uds, i_sd = q.domain_idx() u_max = np.max( [q['w', i][k] for i in i_uds for k in grid.over_elems(Node())]) TS.Δt_up = np.minimum(TS.Δt, 0.5 * grid.dz / np.fmax(u_max, 1e-10)) while time_elapsed < TS.Δt: compute_entrainment_detrainment(grid, UpdVar, Case, tmp, q, self.entr_detr_fp, self.wstar, self.tke_ed_coeff, self.entrainment_factor, self.detrainment_factor) eos_update_SA_mean(grid, q, False, tmp, self.max_supersaturation) buoyancy(grid, q, tmp) compute_sources(grid, q, tmp, self.max_supersaturation) update_updraftvars(grid, q, tmp) solve_updraft_velocity_area(grid, q_new, q, q_tendencies, tmp, UpdVar, TS, self.params) solve_updraft_scalars(grid, q_new, q, q_tendencies, tmp, UpdVar, TS, self.params) assign_values_to_new(grid, q, q_new, tmp) for i in i_sd: q['θ_liq', i].apply_bc(grid, 0.0) q['q_tot', i].apply_bc(grid, 0.0) q['q_rai', i].apply_bc(grid, 0.0) q['w', i_env].apply_bc(grid, 0.0) time_elapsed += TS.Δt_up u_max = np.max( [q['w', i][k] for i in i_uds for k in grid.over_elems(Node())]) TS.Δt_up = np.minimum(TS.Δt - time_elapsed, 0.5 * grid.dz / np.fmax(u_max, 1e-10)) diagnose_environment(grid, q) eos_update_SA_mean(grid, q, True, tmp, self.max_supersaturation) buoyancy(grid, q, tmp) return
def search(self,g): # Loop until the open list is empty if len(self.open) > 0: # Sort the open list to get the node with the lowest cost first self.open.sort() # Get the node with the lowest cost self.current_node = self.open.pop(0) # Add the current node to the closed list self.closed.append(self.current_node) # Check if we have reached the goal, return the path #print(self.current_node.position,self.goal) if self.current_node.position == self.goal: #print('A_star done',self.goal) path = [] backtraverse = deepcopy(self.current_node) while backtraverse.position != self.start.position: path.append(backtraverse.position) backtraverse = backtraverse.parent if len(self.g_temp) > 0: self.goal = self.g_temp.pop(0) else: self.done = True return 0 self.open = [] self.closed = [] # Get neighbors neighbors = g.find_neighbors(self.current_node.position) # Loop neighbors for next in neighbors: # Create a neighbor node neighbor = Node(next, self.current_node) # Check if the neighbor is in the closed list if(neighbor in self.closed): continue # Generate heuristics (Manhattan distance) neighbor.g = abs(neighbor.position[0] - self.start.position[0]) + abs(neighbor.position[1] - self.start.position[1]) neighbor.h = abs(neighbor.position[0] - self.goal[0]) + abs(neighbor.position[1] - self.goal[1]) neighbor.f = neighbor.g + neighbor.h # Check if neighbor is in open list and if it has a lower f value if self.check(neighbor): # Everything is green, add neighbor to open list self.open.append(neighbor)
def __init__(self, namelist, paramlist, root_dir): z_min = 0 n_elems_real = namelist['grid']['nz'] z_max = namelist['grid']['dz'] * namelist['grid']['nz'] n_ghost = namelist['grid']['gw'] N_subdomains = namelist['turbulence']['EDMF_PrognosticTKE'][ 'updraft_number'] + 2 N_sd = N_subdomains unkowns = ( ('a', Center(), Neumann(), N_sd), ('w', Node(), Dirichlet(), N_sd), ('q_tot', Center(), Neumann(), N_sd), ('q_rai', Center(), Neumann(), N_sd), ('θ_liq', Center(), Neumann(), N_sd), ('tke', Center(), Neumann(), N_sd), ('cv_q_tot', Center(), Neumann(), N_sd), ('cv_θ_liq', Center(), Neumann(), N_sd), ('cv_θ_liq_q_tot', Center(), Neumann(), N_sd), ('U', Center(), Neumann(), N_sd), ('V', Center(), Neumann(), N_sd), ) temp_vars = ( ('mean_entr_sc', Center(), Neumann(), 1), ('mean_detr_sc', Center(), Neumann(), 1), ('massflux_half', Center(), Neumann(), 1), ('mf_q_tot_half', Center(), Neumann(), 1), ('mf_θ_liq_half', Center(), Neumann(), 1), ('temp_C', Center(), Neumann(), 1), ('ρ_0', Center(), Neumann(), 1), ('α_0', Center(), Neumann(), 1), ('p_0', Center(), Neumann(), 1), ('K_m', Center(), Neumann(), 1), ('K_h', Center(), Neumann(), 1), ('l_mix', Center(), Neumann(), 1), ('q_tot_dry', Center(), Neumann(), 1), ('θ_dry', Center(), Neumann(), 1), ('t_cloudy', Center(), Neumann(), 1), ('q_vap_cloudy', Center(), Neumann(), 1), ('q_tot_cloudy', Center(), Neumann(), 1), ('θ_cloudy', Center(), Neumann(), 1), ('cv_θ_liq_rain_dt', Center(), Neumann(), 1), ('cv_q_tot_rain_dt', Center(), Neumann(), 1), ('cv_θ_liq_q_tot_rain_dt', Center(), Neumann(), 1), ('CF', Center(), Neumann(), 1), ('entr_sc', Center(), Neumann(), N_sd), # Entrainment/Detrainment rates ('detr_sc', Center(), Neumann(), N_sd), # Entrainment/Detrainment rates ('δ_src_a', Center(), Neumann(), N_sd), ('δ_src_w', Center(), Neumann(), N_sd), ('δ_src_q_tot', Center(), Neumann(), N_sd), ('δ_src_θ_liq', Center(), Neumann(), N_sd), ('δ_src_a_model', Center(), Neumann(), N_sd), ('δ_src_w_model', Center(), Neumann(), N_sd), ('δ_src_q_tot_model', Center(), Neumann(), N_sd), ('δ_src_θ_liq_model', Center(), Neumann(), N_sd), ('q_liq', Center(), Neumann(), N_sd), ('prec_src_θ_liq', Center(), Neumann(), N_sd), ('prec_src_q_tot', Center(), Neumann(), N_sd), ('T', Center(), Neumann(), N_sd), ('B', Center(), Neumann(), N_sd), ('mf_θ_liq', Center(), Neumann(), N_sd), ('mf_q_tot', Center(), Neumann(), N_sd), ('mf_tend_θ_liq', Center(), Neumann(), N_sd), ('mf_tend_q_tot', Center(), Neumann(), N_sd), ('mf_tmp', Center(), Neumann(), N_sd), ) q_2MO = ( ('values', Center(), Neumann(), 1), ('dissipation', Center(), Neumann(), 1), ('entr_gain', Center(), Neumann(), 1), ('detr_loss', Center(), Neumann(), 1), ('buoy', Center(), Neumann(), 1), ('press', Center(), Neumann(), 1), ('shear', Center(), Neumann(), 1), ('interdomain', Center(), Neumann(), 1), ('rain_src', Center(), Neumann(), 1), ) self.grid = Grid(z_min, z_max, n_elems_real, n_ghost) self.q = StateVec(unkowns, self.grid) self.q_new = copy.deepcopy(self.q) self.q_old = copy.deepcopy(self.q) self.q_tendencies = copy.deepcopy(self.q) self.tmp = StateVec(temp_vars, self.grid) self.tmp_O2 = {} self.tmp_O2['tke'] = StateVec(q_2MO, self.grid) self.tmp_O2['cv_q_tot'] = copy.deepcopy(self.tmp_O2['tke']) self.tmp_O2['cv_θ_liq'] = copy.deepcopy(self.tmp_O2['tke']) self.tmp_O2['cv_θ_liq_q_tot'] = copy.deepcopy(self.tmp_O2['tke']) self.tmp_O2['tke'] = copy.deepcopy(self.tmp_O2['tke']) self.n_updrafts = namelist['turbulence']['EDMF_PrognosticTKE'][ 'updraft_number'] self.Ref = ReferenceState(self.grid) self.Case = CasesFactory(namelist, paramlist) self.Turb = EDMF_PrognosticTKE(namelist, paramlist, self.grid) self.UpdVar = [ UpdraftVariables(i, self.Turb.surface_area, self.n_updrafts) for i in range(self.n_updrafts) ] self.TS = TimeStepping(namelist) self.Stats = NetCDFIO_Stats(namelist, paramlist, self.grid, root_dir) self.tri_diag = type('', (), {})() self.tri_diag.a = Half(self.grid) self.tri_diag.b = Half(self.grid) self.tri_diag.c = Half(self.grid) self.tri_diag.f = Half(self.grid) self.tri_diag.β = Half(self.grid) self.tri_diag.γ = Half(self.grid) self.tri_diag.xtemp = Half(self.grid) self.tri_diag.ρaK = Full(self.grid) return
def __init__(self, grid, bc=None): super(Full, self).__init__(grid.nzg, Node(), bc) return
def extrap(self, grid): for k in reversed(grid.over_elems_ghost(Node(), Zmin())): self.values[k] = 2.0 * self.values[k + 1] - self.values[k + 2] for k in grid.over_elems_ghost(Node(), Zmax()): self.values[k] = 2.0 * self.values[k - 1] - self.values[k - 2]
def initialize_ref_state(grid, Stats, p_0, ρ_0, α_0, loc, sg, Pg, Tg, qtg): sg = t_to_entropy_c(Pg, Tg, qtg, 0.0, 0.0) # Form a right hand side for integrating the hydrostatic equation to # determine the reference pressure def rhs(p, z): T, q_l = eos_entropy(np.exp(p), qtg, sg) q_i = 0.0 R_m = Rd * (1.0 - qtg + eps_vi * (qtg - q_l - q_i)) return -g / (R_m * T) # Construct arrays for integration points z_full = [grid.z[k] for k in grid.over_elems_real(Node())] z_half = [grid.z_half[k] for k in grid.over_elems_real(Center())] z = z_full if isinstance(loc, Node) else z_half # We are integrating the log pressure so need to take the log of the # surface pressure q_liq = Field.field(grid, loc) q_ice = Field.field(grid, loc) q_vap = Field.field(grid, loc) temperature = Field.field(grid, loc) p0 = np.log(Pg) p_0[grid.slice_real(loc)] = odeint(rhs, p0, z, hmax=1.0)[:, 0] p_0.apply_Neumann(grid, 0.0) p_0[:] = np.exp(p_0[:]) # Compute reference state thermodynamic profiles for k in grid.over_elems_real(loc): temperature[k], q_liq[k] = eos_entropy(p_0[k], qtg, sg) q_vap[k] = qtg - (q_liq[k] + q_ice[k]) α_0[k] = alpha_c(p_0[k], temperature[k], qtg, q_vap[k]) ρ_0[k] = 1.0 / α_0[k] # Sanity check: make sure Reference State entropy is uniform for k in grid.over_elems(loc): s = t_to_entropy_c(p_0[k], temperature[k], qtg, q_liq[k], q_ice[k]) if np.abs(s - sg) / sg > 0.01: print('Error in reference profiles entropy not constant !') print('Likely error in saturation adjustment') α_0.extrap(grid) p_0.extrap(grid) ρ_0.extrap(grid) p_0_name = nice_name('p_0') + str(loc.__class__.__name__) ρ_0_name = nice_name('ρ_0') + str(loc.__class__.__name__) α_0_name = nice_name('α_0') + str(loc.__class__.__name__) plt.plot(p_0.values, grid.z) plt.title(p_0_name + ' vs z') plt.xlabel(p_0_name) plt.ylabel('z') plt.savefig(Stats.figpath + p_0_name + '.png') plt.close() plt.plot(ρ_0.values, grid.z) plt.title(ρ_0_name + ' vs z') plt.xlabel(ρ_0_name) plt.ylabel('z') plt.savefig(Stats.figpath + ρ_0_name + '.png') plt.close() plt.plot(α_0.values, grid.z) plt.title(α_0_name + ' vs z') plt.xlabel(α_0_name) plt.ylabel('z') plt.savefig(Stats.figpath + α_0_name + '.png') plt.close() p_0.export_data(grid, Stats.outpath + p_0_name + '.dat') ρ_0.export_data(grid, Stats.outpath + ρ_0_name + '.dat') α_0.export_data(grid, Stats.outpath + α_0_name + '.dat') k_1 = grid.boundary(Zmin()) k_2 = grid.boundary(Zmax()) Stats.add_reference_profile(p_0_name) Stats.write_reference_profile(p_0_name, α_0[k_1:k_2]) Stats.add_reference_profile(ρ_0_name) Stats.write_reference_profile(ρ_0_name, p_0[k_1:k_2]) Stats.add_reference_profile(α_0_name) Stats.write_reference_profile(α_0_name, ρ_0[k_1:k_2]) return