From 542348d0fb64e60eca9aadb1b489464efabfa628 Mon Sep 17 00:00:00 2001 From: shac170 Date: Mon, 18 Mar 2024 09:30:35 -0400 Subject: [PATCH] naming changes for consistency --- examples/fixed_source/slab_reed_dd/input.py | 2 +- mcdc/__init__.py | 2 +- mcdc/card.py | 12 +- mcdc/input_.py | 34 ++-- mcdc/kernel.py | 166 ++++++++++---------- mcdc/loop.py | 10 +- mcdc/main.py | 86 +++++----- mcdc/type_.py | 32 ++-- test/regression/dd_slab_reed/input.py | 2 +- 9 files changed, 170 insertions(+), 176 deletions(-) diff --git a/examples/fixed_source/slab_reed_dd/input.py b/examples/fixed_source/slab_reed_dd/input.py index acb585ac..167e102b 100644 --- a/examples/fixed_source/slab_reed_dd/input.py +++ b/examples/fixed_source/slab_reed_dd/input.py @@ -46,6 +46,6 @@ # Setting mcdc.setting(N_particle=5000) -mcdc.domain_decomp(z=np.linspace(0.0, 8.0, 5)) +mcdc.domain_decomposition(z=np.linspace(0.0, 8.0, 5)) # Run mcdc.run() diff --git a/mcdc/__init__.py b/mcdc/__init__.py index db114870..632d644a 100644 --- a/mcdc/__init__.py +++ b/mcdc/__init__.py @@ -23,7 +23,7 @@ uq, print_card, reset_cards, - domain_decomp, + domain_decomposition, ) from mcdc.main import run, prepare from mcdc.visualizer import visualize diff --git a/mcdc/card.py b/mcdc/card.py index 5c9f6d6c..bec92980 100644 --- a/mcdc/card.py +++ b/mcdc/card.py @@ -80,12 +80,12 @@ def reset(self): "ww": np.ones([1, 1, 1, 1]), "ww_width": 2.5, "ww_mesh": make_card_mesh(), - "domain_decomp": False, - "d_idx": 0, - "domain_mesh": make_card_mesh(), - "exchange_rate": 0, - "repro": False, - "work_ratio": np.array([1]), + "domain_decomposition": False, + "dd_idx": 0, + "dd_mesh": make_card_mesh(), + "dd_exchange_rate": 0, + "dd_repro": False, + "dd_work_ratio": np.array([1]), "weight_roulette": False, "wr_threshold": 0.0, "wr_survive": 1.0, diff --git a/mcdc/input_.py b/mcdc/input_.py index 658d44b4..2bc1fd5d 100644 --- a/mcdc/input_.py +++ b/mcdc/input_.py @@ -1173,7 +1173,7 @@ def weight_window(x=None, y=None, z=None, t=None, window=None, width=None): return card -def domain_decomp( +def domain_decomposition( x=None, y=None, z=None, @@ -1184,36 +1184,36 @@ def domain_decomp( repro=True, ): card = mcdc.input_deck.technique - card["domain_decomp"] = True + card["domain_decomposition"] = True card["domain_bank_size"] = int(1e5) - card["exchange_rate"] = int(exchange_rate) - card["repro"] = repro + card["dd_exchange_rate"] = int(exchange_rate) + card["dd_repro"] = repro dom_num = 1 # Set mesh if x is not None: - card["domain_mesh"]["x"] = x + card["dd_mesh"]["x"] = x dom_num *= len(x) if y is not None: - card["domain_mesh"]["y"] = y + card["dd_mesh"]["y"] = y dom_num *= len(y) if z is not None: - card["domain_mesh"]["z"] = z + card["dd_mesh"]["z"] = z dom_num += len(z) if t is not None: - card["domain_mesh"]["t"] = t + card["dd_mesh"]["t"] = t dom_num += len(t) # Set work ratio if work_ratio is None: - card["work_ratio"] = None + card["dd_work_ratio"] = None elif work_ratio is not None: - card["work_ratio"] = work_ratio - card["d_idx"] = 0 - card["xp_neigh"] = [] - card["xn_neigh"] = [] - card["yp_neigh"] = [] - card["yn_neigh"] = [] - card["zp_neigh"] = [] - card["zn_neigh"] = [] + card["dd_work_ratio"] = work_ratio + card["dd_idx"] = 0 + card["dd_xp_neigh"] = [] + card["dd_xn_neigh"] = [] + card["dd_yp_neigh"] = [] + card["dd_yn_neigh"] = [] + card["dd_zp_neigh"] = [] + card["dd_zn_neigh"] = [] return card diff --git a/mcdc/kernel.py b/mcdc/kernel.py index 8d15db0e..e6a7a9f0 100644 --- a/mcdc/kernel.py +++ b/mcdc/kernel.py @@ -24,9 +24,9 @@ @njit def domain_crossing(P, mcdc): # Domain mesh crossing - max_size = mcdc["technique"]["exchange_rate"] - if mcdc["technique"]["domain_decomp"]: - mesh = mcdc["technique"]["domain_mesh"] + max_size = mcdc["technique"]["dd_exchange_rate"] + if mcdc["technique"]["domain_decomposition"]: + mesh = mcdc["technique"]["dd_mesh"] # Determine which dimension is crossed x, y, z, t, directions = mesh_crossing_evaluate(P, mesh) if len(directions) == 0: @@ -78,84 +78,84 @@ def dd_particle_send(mcdc): with objmode(): for i in range( max( - len(mcdc["technique"]["xp_neigh"]), - len(mcdc["technique"]["xn_neigh"]), - len(mcdc["technique"]["yp_neigh"]), - len(mcdc["technique"]["yn_neigh"]), - len(mcdc["technique"]["zp_neigh"]), - len(mcdc["technique"]["zn_neigh"]), + len(mcdc["technique"]["dd_xp_neigh"]), + len(mcdc["technique"]["dd_xn_neigh"]), + len(mcdc["technique"]["dd_yp_neigh"]), + len(mcdc["technique"]["dd_yn_neigh"]), + len(mcdc["technique"]["dd_zp_neigh"]), + len(mcdc["technique"]["dd_zn_neigh"]), ) ): - if mcdc["technique"]["xp_neigh"].size > i: + if mcdc["technique"]["dd_xp_neigh"].size > i: size = mcdc["bank_domain_xp"]["size"] - ratio = int(size / len(mcdc["technique"]["xp_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_xp_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["xp_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_xp_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_xp"]["particles"][start:end]) request1 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["xp_neigh"][i], tag=1 + bank, dest=mcdc["technique"]["dd_xp_neigh"][i], tag=1 ) - if mcdc["technique"]["xn_neigh"].size > i: + if mcdc["technique"]["dd_xn_neigh"].size > i: size = mcdc["bank_domain_xn"]["size"] - ratio = int(size / len(mcdc["technique"]["xn_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_xn_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["xn_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_xn_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_xn"]["particles"][start:end]) request2 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["xn_neigh"][i], tag=2 + bank, dest=mcdc["technique"]["dd_xn_neigh"][i], tag=2 ) - if mcdc["technique"]["yp_neigh"].size > i: + if mcdc["technique"]["dd_yp_neigh"].size > i: size = mcdc["bank_domain_yp"]["size"] - ratio = int(size / len(mcdc["technique"]["yp_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_yp_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["yp_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_yp_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_yp"]["particles"][start:end]) request3 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["yp_neigh"][i], tag=3 + bank, dest=mcdc["technique"]["dd_yp_neigh"][i], tag=3 ) - if mcdc["technique"]["yn_neigh"].size > i: + if mcdc["technique"]["dd_yn_neigh"].size > i: size = mcdc["bank_domain_yn"]["size"] - ratio = int(size / len(mcdc["technique"]["yn_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_yn_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["yn_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_yn_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_yn"]["particles"][start:end]) request4 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["yn_neigh"][i], tag=4 + bank, dest=mcdc["technique"]["dd_yn_neigh"][i], tag=4 ) - if mcdc["technique"]["zp_neigh"].size > i: + if mcdc["technique"]["dd_zp_neigh"].size > i: size = mcdc["bank_domain_zp"]["size"] - ratio = int(size / len(mcdc["technique"]["zp_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_zp_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["zp_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_zp_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_zp"]["particles"][start:end]) request5 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["zp_neigh"][i], tag=5 + bank, dest=mcdc["technique"]["dd_zp_neigh"][i], tag=5 ) - if mcdc["technique"]["zn_neigh"].size > i: + if mcdc["technique"]["dd_zn_neigh"].size > i: size = mcdc["bank_domain_zn"]["size"] - ratio = int(size / len(mcdc["technique"]["zn_neigh"])) + ratio = int(size / len(mcdc["technique"]["dd_zn_neigh"])) start = ratio * i end = start + ratio - if i == len(mcdc["technique"]["zn_neigh"]) - 1: + if i == len(mcdc["technique"]["dd_zn_neigh"]) - 1: end = size bank = np.array(mcdc["bank_domain_zn"]["particles"][start:end]) request6 = MPI.COMM_WORLD.send( - bank, dest=mcdc["technique"]["zn_neigh"][i], tag=6 + bank, dest=mcdc["technique"]["dd_zn_neigh"][i], tag=6 ) sent_particles = ( @@ -166,7 +166,7 @@ def dd_particle_send(mcdc): + mcdc["bank_domain_zp"]["size"] + mcdc["bank_domain_zn"]["size"] ) - mcdc["technique"]["sent"] += sent_particles + mcdc["technique"]["dd_sent"] += sent_particles mcdc["bank_domain_xp"]["size"] = 0 mcdc["bank_domain_xn"]["size"] = 0 @@ -192,62 +192,62 @@ def dd_particle_receive(mcdc): size_old = bankr.shape[0] for i in range( max( - len(mcdc["technique"]["xp_neigh"]), - len(mcdc["technique"]["xn_neigh"]), - len(mcdc["technique"]["yp_neigh"]), - len(mcdc["technique"]["yn_neigh"]), - len(mcdc["technique"]["zp_neigh"]), - len(mcdc["technique"]["zn_neigh"]), + len(mcdc["technique"]["dd_xp_neigh"]), + len(mcdc["technique"]["dd_xn_neigh"]), + len(mcdc["technique"]["dd_yp_neigh"]), + len(mcdc["technique"]["dd_yn_neigh"]), + len(mcdc["technique"]["dd_zp_neigh"]), + len(mcdc["technique"]["dd_zn_neigh"]), ) ): - if mcdc["technique"]["xp_neigh"].size > i: + if mcdc["technique"]["dd_xp_neigh"].size > i: received1 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["xp_neigh"][i], tag=2 + source=mcdc["technique"]["dd_xp_neigh"][i], tag=2 ) if received1.Get_status(): bankr = np.append(bankr, received1.wait()) else: MPI.Request.cancel(received1) - if mcdc["technique"]["xn_neigh"].size > i: + if mcdc["technique"]["dd_xn_neigh"].size > i: received2 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["xn_neigh"][i], tag=1 + source=mcdc["technique"]["dd_xn_neigh"][i], tag=1 ) if received2.Get_status(): bankr = np.append(bankr, received2.wait()) else: MPI.Request.cancel(received2) - if mcdc["technique"]["yp_neigh"].size > i: + if mcdc["technique"]["dd_yp_neigh"].size > i: received3 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["yp_neigh"][i], tag=4 + source=mcdc["technique"]["dd_yp_neigh"][i], tag=4 ) if received3.Get_status(): bankr = np.append(bankr, received3.wait()) else: MPI.Request.cancel(received3) - if mcdc["technique"]["yn_neigh"].size > i: + if mcdc["technique"]["dd_yn_neigh"].size > i: received4 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["yn_neigh"][i], tag=3 + source=mcdc["technique"]["dd_yn_neigh"][i], tag=3 ) if received4.Get_status(): bankr = np.append(bankr, received4.wait()) else: MPI.Request.cancel(received4) - if mcdc["technique"]["zp_neigh"].size > i: + if mcdc["technique"]["dd_zp_neigh"].size > i: received5 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["zp_neigh"][i], tag=6 + source=mcdc["technique"]["dd_zp_neigh"][i], tag=6 ) if received5.Get_status(): bankr = np.append(bankr, received5.wait()) else: MPI.Request.cancel(received5) - if mcdc["technique"]["zn_neigh"].size > i: + if mcdc["technique"]["dd_zn_neigh"].size > i: received6 = MPI.COMM_WORLD.irecv( - source=mcdc["technique"]["zn_neigh"][i], tag=5 + source=mcdc["technique"]["dd_zn_neigh"][i], tag=5 ) if received6.Get_status(): bankr = np.append(bankr, received6.wait()) @@ -258,12 +258,11 @@ def dd_particle_receive(mcdc): # Set output buffer for i in range(size): buff[i] = bankr[i] - # if (size-size_old)>0: - # print("recieved",size-size_old,"particles, in domain",mcdc["d_idx"]) + # Set source bank from buffer for i in range(size): add_particle(buff[i], mcdc["bank_active"]) - mcdc["technique"]["sent"] -= size + mcdc["technique"]["dd_sent"] -= size # ============================================================================= @@ -274,24 +273,23 @@ def dd_particle_receive(mcdc): # Check if particle is in domain @njit def particle_in_domain(P, mcdc): - d_idx = mcdc["d_idx"] - d_Nx = mcdc["technique"]["domain_mesh"]["x"].size - 1 - d_Ny = mcdc["technique"]["domain_mesh"]["y"].size - 1 - d_Nz = mcdc["technique"]["domain_mesh"]["z"].size - 1 + d_idx = mcdc["dd_idx"] + d_Nx = mcdc["technique"]["dd_mesh"]["x"].size - 1 + d_Ny = mcdc["technique"]["dd_mesh"]["y"].size - 1 + d_Nz = mcdc["technique"]["dd_mesh"]["z"].size - 1 d_iz = int(d_idx / (d_Nx * d_Ny)) d_iy = int((d_idx - d_Nx * d_Ny * d_iz) / d_Nx) d_ix = int(d_idx - d_Nx * d_Ny * d_iz - d_Nx * d_iy) - x_cell = binary_search(P["x"], mcdc["technique"]["domain_mesh"]["x"]) - y_cell = binary_search(P["y"], mcdc["technique"]["domain_mesh"]["y"]) - z_cell = binary_search(P["z"], mcdc["technique"]["domain_mesh"]["z"]) - # print("xc",x_cell,"yc",y_cell,"zc",z_cell,"x",P["x"],"y",P["y"],"z",P["z"],"d_x",d_ix,"d_y",d_iy,"d_z",d_iz,"d_idx",d_idx) + x_cell = binary_search(P["x"], mcdc["technique"]["dd_mesh"]["x"]) + y_cell = binary_search(P["y"], mcdc["technique"]["dd_mesh"]["y"]) + z_cell = binary_search(P["z"], mcdc["technique"]["dd_mesh"]["z"]) + if d_ix == x_cell: if d_iy == y_cell: if d_iz == z_cell: return True - # print("xc",x_cell,"yc",y_cell,"zc",z_cell,"x",P["x"],"y",P["y"],"z",P["z"],"d_x",d_ix,"d_y",d_iy,"d_z",d_iz,"d_idx",d_idx) return False @@ -315,8 +313,6 @@ def source_in_domain(source, domain_mesh, d_idx): d_y = [domain_mesh["y"][d_iy], domain_mesh["y"][d_iy + 1]] d_z = [domain_mesh["z"][d_iz], domain_mesh["z"][d_iz + 1]] - # print("domain:",d_idx,"d_x:",d_x,"d_y:",d_y,"d_z:",d_z,domain_mesh["z"],source["box_x"],source["box_y"],source["box_z"]) - if ( d_x[0] <= source["box_x"][0] <= d_x[1] or d_x[0] <= source["box_x"][1] <= d_x[1] @@ -348,7 +344,7 @@ def source_in_domain(source, domain_mesh, d_idx): @njit def domain_work(mcdc, domain, N): - domain_mesh = mcdc["technique"]["domain_mesh"] + domain_mesh = mcdc["technique"]["dd_mesh"] d_Nx = domain_mesh["x"].size - 1 d_Ny = domain_mesh["y"].size - 1 @@ -405,9 +401,9 @@ def domain_work(mcdc, domain, N): Nm += Ni[source] * Vim[source] / Vi[source] work_start += Nm d_idx = domain - d_iz = int(mcdc["d_idx"] / (d_Nx * d_Ny)) - d_iy = int((mcdc["d_idx"] - d_Nx * d_Ny * d_iz) / d_Nx) - d_ix = int(mcdc["d_idx"] - d_Nx * d_Ny * d_iz - d_Nx * d_iy) + d_iz = int(mcdc["dd_idx"] / (d_Nx * d_Ny)) + d_iy = int((mcdc["dd_idx"] - d_Nx * d_Ny * d_iz) / d_Nx) + d_ix = int(mcdc["dd_idx"] - d_Nx * d_Ny * d_iz - d_Nx * d_iy) d_x = [domain_mesh["x"][d_ix], domain_mesh["x"][d_ix + 1]] d_y = [domain_mesh["y"][d_iy], domain_mesh["y"][d_iy + 1]] @@ -450,10 +446,10 @@ def domain_work(mcdc, domain, N): i += 1 for source in range(num_source): Nm += Ni[source] * Vim[source] / Vi[source] - Nm /= mcdc["technique"]["work_ratio"][domain] + Nm /= mcdc["technique"]["dd_work_ratio"][domain] rank = mcdc["mpi_rank"] - if mcdc["technique"]["work_ratio"][domain] > 1: - work_start += Nm * (rank - np.sum(mcdc["technique"]["work_ratio"][0:d_idx])) + if mcdc["technique"]["dd_work_ratio"][domain] > 1: + work_start += Nm * (rank - np.sum(mcdc["technique"]["dd_work_ratio"][0:d_idx])) total_v = 0 for source in range(len(mcdc["sources"])): total_v += Vim[source] @@ -472,16 +468,16 @@ def domain_work(mcdc, domain, N): @njit() def source_particle_dd(seed, mcdc): - domain_mesh = mcdc["technique"]["domain_mesh"] - d_idx = mcdc["d_idx"] + domain_mesh = mcdc["technique"]["dd_mesh"] + d_idx = mcdc["dd_idx"] d_Nx = domain_mesh["x"].size - 1 d_Ny = domain_mesh["y"].size - 1 d_Nz = domain_mesh["z"].size - 1 - d_iz = int(mcdc["d_idx"] / (d_Nx * d_Ny)) - d_iy = int((mcdc["d_idx"] - d_Nx * d_Ny * d_iz) / d_Nx) - d_ix = int(mcdc["d_idx"] - d_Nx * d_Ny * d_iz - d_Nx * d_iy) + d_iz = int(mcdc["dd_idx"] / (d_Nx * d_Ny)) + d_iy = int((mcdc["dd_idx"] - d_Nx * d_Ny * d_iz) / d_Nx) + d_ix = int(mcdc["dd_idx"] - d_Nx * d_Ny * d_iz - d_Nx * d_iy) d_x = [domain_mesh["x"][d_ix], domain_mesh["x"][d_ix + 1]] d_y = [domain_mesh["y"][d_iy], domain_mesh["y"][d_iy + 1]] @@ -541,9 +537,7 @@ def source_particle_dd(seed, mcdc): P["uy"] = uy P["uz"] = uz P["g"] = g - P["w"] = 1 # /(mcdc["technique"]["work_ratio"][mcdc["d_idx"]]) - # P["w"] =np.sum(mcdc["technique"]["work_ratio"])/(mcdc["technique"]["work_ratio"][d_idx])#len(mcdc["sources"])*(1+(np.sum(mcdc["technique"]["work_ratio"])-len(mcdc["technique"]["work_ratio"]))/len(mcdc["technique"]["work_ratio"]))/(mcdc["technique"]["work_ratio"][d_idx]) - + P["w"] = 1 P["sensitivity_ID"] = 0 return P @@ -553,8 +547,8 @@ def distribute_work_dd(N, mcdc, precursor=False): # Total # of work work_size_total = N - if not mcdc["technique"]["repro"]: - work_size, work_start = domain_work(mcdc, mcdc["d_idx"], N) + if not mcdc["technique"]["dd_repro"]: + work_size, work_start = domain_work(mcdc, mcdc["dd_idx"], N) else: work_start = 0 work_size = work_size_total @@ -886,7 +880,7 @@ def manage_particle_banks(seed, mcdc): ] # MPI rebalance - if not mcdc["technique"]["domain_decomp"]: + if not mcdc["technique"]["domain_decomposition"]: bank_rebalance(mcdc) # Zero out census bank @@ -2268,8 +2262,8 @@ def move_to_event(P, mcdc): d_mesh = distance_to_mesh(P, mcdc["tally"]["mesh"], mcdc) d_domain = INF - if mcdc["cycle_active"] and mcdc["technique"]["domain_decomp"]: - d_domain = distance_to_mesh(P, mcdc["technique"]["domain_mesh"], mcdc) + if mcdc["cycle_active"] and mcdc["technique"]["domain_decomposition"]: + d_domain = distance_to_mesh(P, mcdc["technique"]["dd_mesh"], mcdc) if mcdc["technique"]["iQMC"]: d_iqmc_mesh = distance_to_mesh(P, mcdc["technique"]["iqmc"]["mesh"], mcdc) diff --git a/mcdc/loop.py b/mcdc/loop.py index ab998d65..5ec7b4eb 100644 --- a/mcdc/loop.py +++ b/mcdc/loop.py @@ -52,7 +52,7 @@ def loop_fixed_source(mcdc): # Loop over source particles seed_source = kernel.split_seed(seed_census, SEED_SPLIT_SOURCE) - if mcdc["technique"]["domain_decomp"]: + if mcdc["technique"]["domain_decomposition"]: loop_source_dd(seed_source, mcdc) else: loop_source(seed_source, mcdc) @@ -238,13 +238,13 @@ def loop_source_dd(seed, mcdc): # Get from fixed-source? if mcdc["bank_source"]["size"] == 0: # Sample source - if mcdc["technique"]["repro"]: + if mcdc["technique"]["dd_repro"]: P = kernel.source_particle(seed_work, mcdc) else: P = kernel.source_particle(seed_work, mcdc) - if mcdc["technique"]["work_ratio"][mcdc["d_idx"]] > 0: - P["w"] /= mcdc["technique"]["work_ratio"][mcdc["d_idx"]] + if mcdc["technique"]["dd_work_ratio"][mcdc["dd_idx"]] > 0: + P["w"] /= mcdc["technique"]["dd_work_ratio"][mcdc["dd_idx"]] # Get from source bank else: P = mcdc["bank_source"]["particles"][work_idx] @@ -335,7 +335,7 @@ def loop_source_dd(seed, mcdc): kernel.dd_particle_receive(mcdc) work_remaining = int(kernel.allreduce(mcdc["bank_active"]["size"])) - total_sent = int(kernel.allreduce(mcdc["technique"]["sent"])) + total_sent = int(kernel.allreduce(mcdc["technique"]["dd_sent"])) if work_remaining > max_work: max_work = work_remaining diff --git a/mcdc/main.py b/mcdc/main.py index ba8e583f..1533efc1 100644 --- a/mcdc/main.py +++ b/mcdc/main.py @@ -182,22 +182,22 @@ def get_neighbors(N, w, nx, ny, nz): def dd_prepare(): - work_ratio = input_deck.technique["work_ratio"] + work_ratio = input_deck.technique["dd_work_ratio"] - d_Nx = input_deck.technique["domain_mesh"]["x"].size - 1 - d_Ny = input_deck.technique["domain_mesh"]["y"].size - 1 - d_Nz = input_deck.technique["domain_mesh"]["z"].size - 1 + d_Nx = input_deck.technique["dd_mesh"]["x"].size - 1 + d_Ny = input_deck.technique["dd_mesh"]["y"].size - 1 + d_Nz = input_deck.technique["dd_mesh"]["z"].size - 1 input_deck.setting["bank_active_buff"] = 1000 - if input_deck.technique["exchange_rate"] == None: - input_deck.technique["exchange_rate"] = 100 + if input_deck.technique["dd_exchange_rate"] == None: + input_deck.technique["dd_exchange_rate"] = 100 if work_ratio is None: work_ratio = np.ones(d_Nx * d_Ny * d_Nz) - input_deck.technique["work_ratio"] = work_ratio + input_deck.technique["dd_work_ratio"] = work_ratio if ( - input_deck.technique["domain_decomp"] + input_deck.technique["domain_decomposition"] and np.sum(work_ratio) != MPI.COMM_WORLD.Get_size() ): print_msg( @@ -206,7 +206,7 @@ def dd_prepare(): ) exit() - if input_deck.technique["domain_decomp"]: + if input_deck.technique["domain_decomposition"]: # Assigning domain index i = 0 rank_info = [] @@ -218,44 +218,44 @@ def dd_prepare(): d_idx = n i += 1 rank_info.append(ranks) - input_deck.technique["d_idx"] = d_idx + input_deck.technique["dd_idx"] = d_idx xn, xp, yn, yp, zn, zp = get_neighbors(d_idx, 0, d_Nx, d_Ny, d_Nz) else: - input_deck.technique["d_idx"] = 0 - input_deck.technique["xp_neigh"] = [] - input_deck.technique["xn_neigh"] = [] - input_deck.technique["yp_neigh"] = [] - input_deck.technique["yn_neigh"] = [] - input_deck.technique["zp_neigh"] = [] - input_deck.technique["zn_neigh"] = [] + input_deck.technique["dd_idx"] = 0 + input_deck.technique["dd_xp_neigh"] = [] + input_deck.technique["dd_xn_neigh"] = [] + input_deck.technique["dd_yp_neigh"] = [] + input_deck.technique["dd_yn_neigh"] = [] + input_deck.technique["dd_zp_neigh"] = [] + input_deck.technique["dd_zn_neigh"] = [] return if xp is not None: - input_deck.technique["xp_neigh"] = rank_info[xp] + input_deck.technique["dd_xp_neigh"] = rank_info[xp] else: - input_deck.technique["xp_neigh"] = [] + input_deck.technique["dd_xp_neigh"] = [] if xn is not None: - input_deck.technique["xn_neigh"] = rank_info[xn] + input_deck.technique["dd_xn_neigh"] = rank_info[xn] else: - input_deck.technique["xn_neigh"] = [] + input_deck.technique["dd_xn_neigh"] = [] if yp is not None: - input_deck.technique["yp_neigh"] = rank_info[yp] + input_deck.technique["dd_yp_neigh"] = rank_info[yp] else: - input_deck.technique["yp_neigh"] = [] + input_deck.technique["dd_yp_neigh"] = [] if yn is not None: - input_deck.technique["yn_neigh"] = rank_info[yn] + input_deck.technique["dd_yn_neigh"] = rank_info[yn] else: - input_deck.technique["yn_neigh"] = [] + input_deck.technique["dd_yn_neigh"] = [] if zp is not None: - input_deck.technique["zp_neigh"] = rank_info[zp] + input_deck.technique["dd_zp_neigh"] = rank_info[zp] else: - input_deck.technique["zp_neigh"] = [] + input_deck.technique["dd_zp_neigh"] = [] if zn is not None: - input_deck.technique["zn_neigh"] = rank_info[zn] + input_deck.technique["dd_zn_neigh"] = rank_info[zn] else: - input_deck.technique["zn_neigh"] = [] + input_deck.technique["dd_zn_neigh"] = [] def prepare(): @@ -519,7 +519,7 @@ def prepare(): "implicit_capture", "population_control", "weight_window", - "domain_decomp", + "domain_decomposition", "weight_roulette", "iQMC", "IC_generator", @@ -576,8 +576,8 @@ def prepare(): # ========================================================================= # Set domain mesh - if input_deck.technique["domain_decomp"]: - name = "domain_mesh" + if input_deck.technique["domain_decomposition"]: + name = "dd_mesh" mcdc["technique"][name]["x"] = input_deck.technique[name]["x"] mcdc["technique"][name]["y"] = input_deck.technique[name]["y"] mcdc["technique"][name]["z"] = input_deck.technique[name]["z"] @@ -585,17 +585,17 @@ def prepare(): mcdc["technique"][name]["mu"] = input_deck.technique[name]["mu"] mcdc["technique"][name]["azi"] = input_deck.technique[name]["azi"] # Set exchange rate - mcdc["technique"]["exchange_rate"] = input_deck.technique["exchange_rate"] - mcdc["technique"]["repro"] = input_deck.technique["repro"] + mcdc["technique"]["dd_exchange_rate"] = input_deck.technique["dd_exchange_rate"] + mcdc["technique"]["dd_repro"] = input_deck.technique["dd_repro"] # Set domain index - mcdc["d_idx"] = input_deck.technique["d_idx"] - mcdc["technique"]["xp_neigh"] = input_deck.technique["xp_neigh"] - mcdc["technique"]["xn_neigh"] = input_deck.technique["xn_neigh"] - mcdc["technique"]["yp_neigh"] = input_deck.technique["yp_neigh"] - mcdc["technique"]["yn_neigh"] = input_deck.technique["yn_neigh"] - mcdc["technique"]["zp_neigh"] = input_deck.technique["zp_neigh"] - mcdc["technique"]["zn_neigh"] = input_deck.technique["zn_neigh"] - mcdc["technique"]["work_ratio"] = input_deck.technique["work_ratio"] + mcdc["dd_idx"] = input_deck.technique["dd_idx"] + mcdc["technique"]["dd_xp_neigh"] = input_deck.technique["dd_xp_neigh"] + mcdc["technique"]["dd_xn_neigh"] = input_deck.technique["dd_xn_neigh"] + mcdc["technique"]["dd_yp_neigh"] = input_deck.technique["dd_yp_neigh"] + mcdc["technique"]["dd_yn_neigh"] = input_deck.technique["dd_yn_neigh"] + mcdc["technique"]["dd_zp_neigh"] = input_deck.technique["dd_zp_neigh"] + mcdc["technique"]["dd_zn_neigh"] = input_deck.technique["dd_zn_neigh"] + mcdc["technique"]["dd_work_ratio"] = input_deck.technique["dd_work_ratio"] # ========================================================================= # Quasi Monte Carlo @@ -736,7 +736,7 @@ def prepare(): mcdc["mpi_master"] = mcdc["mpi_rank"] == 0 # Distribute work to MPI ranks - if mcdc["technique"]["domain_decomp"]: + if mcdc["technique"]["domain_decomposition"]: kernel.distribute_work_dd(mcdc["setting"]["N_particle"], mcdc) else: kernel.distribute_work(mcdc["setting"]["N_particle"], mcdc) diff --git a/mcdc/type_.py b/mcdc/type_.py index 9fc611b9..7aa92bcf 100644 --- a/mcdc/type_.py +++ b/mcdc/type_.py @@ -694,7 +694,7 @@ def make_type_technique(input_deck): ("iQMC", bool_), ("IC_generator", bool_), ("branchless_collision", bool_), - ("domain_decomp", bool_), + ("domain_decomposition", bool_), ("uq", bool_), ] @@ -708,19 +708,19 @@ def make_type_technique(input_deck): # domain decomp # ========================================================================= # Mesh - mesh, Nx, Ny, Nz, Nt, Nmu, N_azi, Ng = make_type_mesh(card["domain_mesh"]) - struct += [("domain_mesh", mesh)] - struct += [("d_idx", int64)] - struct += [("sent", int64)] - struct += [("work_ratio", int64, (len(card["work_ratio"]),))] - struct += [("exchange_rate", int64)] - struct += [("repro", bool_)] - struct += [("xp_neigh", int64, (len(card["xp_neigh"]),))] - struct += [("xn_neigh", int64, (len(card["xn_neigh"]),))] - struct += [("yp_neigh", int64, (len(card["yp_neigh"]),))] - struct += [("yn_neigh", int64, (len(card["yn_neigh"]),))] - struct += [("zp_neigh", int64, (len(card["zp_neigh"]),))] - struct += [("zn_neigh", int64, (len(card["zn_neigh"]),))] + mesh, Nx, Ny, Nz, Nt, Nmu, N_azi, Ng = make_type_mesh(card["dd_mesh"]) + struct += [("dd_mesh", mesh)] + struct += [("dd_idx", int64)] + struct += [("dd_sent", int64)] + struct += [("dd_work_ratio", int64, (len(card["dd_work_ratio"]),))] + struct += [("dd_exchange_rate", int64)] + struct += [("dd_repro", bool_)] + struct += [("dd_xp_neigh", int64, (len(card["dd_xp_neigh"]),))] + struct += [("dd_xn_neigh", int64, (len(card["dd_xn_neigh"]),))] + struct += [("dd_yp_neigh", int64, (len(card["dd_yp_neigh"]),))] + struct += [("dd_yn_neigh", int64, (len(card["dd_yn_neigh"]),))] + struct += [("dd_zp_neigh", int64, (len(card["dd_zp_neigh"]),))] + struct += [("dd_zn_neigh", int64, (len(card["dd_zn_neigh"]),))] # ========================================================================= # Weight window @@ -1076,7 +1076,7 @@ def make_type_global(input_deck): bank_precursor = precursor_bank(0) # Domain banks if needed - if input_deck.technique["domain_decomp"]: + if input_deck.technique["domain_decomposition"]: bank_domain_xp = particle_bank(input_deck.technique["domain_bank_size"]) bank_domain_xn = particle_bank(input_deck.technique["domain_bank_size"]) bank_domain_yp = particle_bank(input_deck.technique["domain_bank_size"]) @@ -1138,7 +1138,7 @@ def make_type_global(input_deck): ("bank_domain_zp", bank_domain_zp), ("bank_domain_zn", bank_domain_zn), ("bank_precursor", bank_precursor), - ("d_idx", int64), + ("dd_idx", int64), ("k_eff", float64), ("k_cycle", float64, (N_cycle,)), ("k_avg", float64), diff --git a/test/regression/dd_slab_reed/input.py b/test/regression/dd_slab_reed/input.py index acb585ac..167e102b 100644 --- a/test/regression/dd_slab_reed/input.py +++ b/test/regression/dd_slab_reed/input.py @@ -46,6 +46,6 @@ # Setting mcdc.setting(N_particle=5000) -mcdc.domain_decomp(z=np.linspace(0.0, 8.0, 5)) +mcdc.domain_decomposition(z=np.linspace(0.0, 8.0, 5)) # Run mcdc.run()