def distribute_Chunks(params_simu, simuDirName): Wall_t0 = time.time() CPU_t0 = time.clock() num_procs = MPI.COMM_WORLD.Get_size() my_id = MPI.COMM_WORLD.Get_rank() tmpDirName = os.path.join(simuDirName, 'tmp' + str(my_id)) geoDirName = os.path.join(simuDirName, 'geo') if my_id==0: file = open(os.path.join(tmpDirName, "mesh", 'cubes_lists_RWGsNumbers.txt'), 'rb') cubes_lists_RWGsNumbers = cPickle.load(file) file.close() file = open(os.path.join(tmpDirName, "mesh", 'cubes_lists_NeighborsIndexes.txt'), 'rb') cubes_lists_NeighborsIndexes = cPickle.load(file) file.close() N_nearPerCube = Z_near_size_computation(cubes_lists_RWGsNumbers, cubes_lists_NeighborsIndexes) else: N_nearPerCube = ['blabla'] N_nearPerCube = MPI.COMM_WORLD.bcast(N_nearPerCube) file = open(os.path.join(tmpDirName, 'pickle', 'variables.txt'), 'rb') variables = cPickle.load(file) file.close() chunkNumber_to_cubesNumbers, cubeNumber_to_chunkNumber, chunkNumber_to_processNumber, processNumber_to_ChunksNumbers = Z_nearChunksDistribution(params_simu.MAX_BLOCK_SIZE, N_nearPerCube, variables['C'], tmpDirName) chunkNumber_to_cubesNumbers = MPI.COMM_WORLD.bcast(chunkNumber_to_cubesNumbers) cubeNumber_to_chunkNumber = MPI.COMM_WORLD.bcast(cubeNumber_to_chunkNumber) chunkNumber_to_processNumber = MPI.COMM_WORLD.bcast(chunkNumber_to_processNumber) processNumber_to_ChunksNumbers = MPI.COMM_WORLD.bcast(processNumber_to_ChunksNumbers) # distributing chunks of the mesh local_ChunksNumbers = processNumber_to_ChunksNumbers[my_id] local_chunkNumber_to_cubesNumbers = [] local_chunkNumber_N_cubesNumbers = [] startIndex = 0 for chunkNumber in local_ChunksNumbers: list_cubes_tmp = chunkNumber_to_cubesNumbers[chunkNumber] local_chunkNumber_to_cubesNumbers += list_cubes_tmp length = len(list_cubes_tmp) local_chunkNumber_N_cubesNumbers += [length] writeBlitzArrayToDisk(array(local_ChunksNumbers, 'i'), os.path.join(tmpDirName, 'Z_tmp', 'local_ChunksNumbers.txt')) writeBlitzArrayToDisk(array(local_chunkNumber_to_cubesNumbers, 'i'), os.path.join(tmpDirName, 'Z_tmp', 'local_chunkNumber_to_cubesNumbers.txt')) writeBlitzArrayToDisk(array(local_chunkNumber_N_cubesNumbers, 'i'), os.path.join(tmpDirName, 'Z_tmp', 'local_chunkNumber_N_cubesNumbers.txt')) writeScalarToDisk(len(local_ChunksNumbers), os.path.join(tmpDirName, 'Z_tmp', "N_local_Chunks.txt")) writeScalarToDisk(len(local_chunkNumber_to_cubesNumbers), os.path.join(tmpDirName, 'Z_tmp', "N_local_cubes.txt")) createChunkDirs(processNumber_to_ChunksNumbers, tmpDirName, my_id) variables['chunkNumber_to_cubesNumbers'] = chunkNumber_to_cubesNumbers variables['cubeNumber_to_chunkNumber'] = cubeNumber_to_chunkNumber variables['chunkNumber_to_processNumber'] = chunkNumber_to_processNumber variables['processNumber_to_ChunksNumbers'] = processNumber_to_ChunksNumbers CPU_time_distribute_ZChunks_and_cubes = time.clock() - CPU_t0 Wall_time_distribute_ZChunks_and_cubes = time.time() - Wall_t0 variables['Wall_time_distribute_ZChunks_and_cubes'] = Wall_time_distribute_ZChunks_and_cubes variables['CPU_time_distribute_ZChunks_and_cubes'] = CPU_time_distribute_ZChunks_and_cubes file = open(os.path.join(tmpDirName, 'pickle', 'variables.txt'), 'wb') cPickle.dump(variables, file) file.close()
def writeToDisk_chunk_of_Z_sparse(path, name, Z, src_RWG_numbers, rowIndexToColumnIndexes, test_RWG_numbers, chunkNumber): """this function writes to disk the chunks of Z sparse and the corresponding indexes arrays, each with a number""" chunkNumberString = str(chunkNumber) writeBlitzArrayToDisk(Z, os.path.join(path, name) + str(chunkNumber) + '.txt') writeBlitzArrayToDisk( src_RWG_numbers, os.path.join(path, 'src_RWG_numbers') + str(chunkNumber) + '.txt') writeBlitzArrayToDisk( rowIndexToColumnIndexes, os.path.join(path, 'rowIndexToColumnIndexes') + str(chunkNumber) + '.txt') writeBlitzArrayToDisk( test_RWG_numbers, os.path.join(path, 'test_RWG_numbers') + str(chunkNumber) + '.txt') # now we write the scalar values N_test_RWG_File = os.path.join(path, 'N_test_RWG') + str(chunkNumber) + '.txt' writeScalarToDisk(test_RWG_numbers.shape[0], N_test_RWG_File) N_near_File = os.path.join(path, 'N_near') + str(chunkNumber) + '.txt' writeScalarToDisk(Z.shape[0], N_near_File) N_src_RWG_File = os.path.join(path, 'N_src_RWG') + str(chunkNumber) + '.txt' writeScalarToDisk(src_RWG_numbers.shape[0], N_src_RWG_File)
def setup_mesh(params_simu, simuDirName): """Sets up the mesh. params_simu is a class instance that contains the parameters for the simulation. """ my_id = 0 tmpDirName = os.path.join(simuDirName, 'tmp' + str(my_id)) geoDirName = os.path.join(simuDirName, 'geo') # size of cube at finest level a = c / params_simu.f * params_simu.a_factor # reading the mesh path, name = geoDirName, params_simu.targetName + params_simu.meshFileTermination meshPath = os.path.join(tmpDirName, "mesh") print("read_MLFMA_mesh_part1.py: reading" + os.path.join(path, name) + "...") t0 = time.clock() vertexes_coord, triangle_vertexes, triangles_physicalSurface = readMesh( path, name, params_simu) time_reading = time.clock() - t0 print("reading mesh time = " + str(time_reading) + " seconds") T = triangle_vertexes.shape[0] V = vertexes_coord.shape[0] print("number of triangles = " + str(T) + "\n") sys.stdout.flush() writeScalarToDisk(T, os.path.join(meshPath, "T.txt")) writeScalarToDisk(V, os.path.join(meshPath, "V.txt")) writeScalarToDisk(a, os.path.join(meshPath, "a.txt")) writeBlitzArrayToDisk(vertexes_coord, os.path.join(meshPath, 'vertexes_coord.txt')) writeBlitzArrayToDisk(triangle_vertexes, os.path.join(meshPath, 'triangle_vertexes.txt'))
def computeTreeParameters(my_id, tmpDirName, a, k, N_levels, params_simu): # L computation NB_DIGITS = params_simu.NB_DIGITS L = zeros(N_levels-1, 'i') # array of poles numbers: 1 number per level for i in range(L.shape[0]): L[i] = L_computation(k, a*(2**i), NB_DIGITS) if (my_id==0) and (params_simu.VERBOSE == 1): print("L = " + str(L)) # integration and interpolation data octtreeXcosThetas, octtreeWthetas, octtreeNthetas = octtreeXWN_computation(-1.0, 1.0, L, N_levels, params_simu.int_method_theta, params_simu.INCLUDE_BOUNDARIES) octtreeXthetas = zeros(octtreeXcosThetas.shape, 'd') for i in range(octtreeNthetas.shape[0]): Npoints = octtreeNthetas[i] octtreeXthetas[i,:Npoints] = arccos(octtreeXcosThetas[i, Npoints-1::-1]) octtreeXphis, octtreeWphis, octtreeNphis = octtreeXWN_computation(0.0, 2.0*pi, L, N_levels, params_simu.int_method_phi, params_simu.INCLUDE_BOUNDARIES) #if (my_id==0): # print("Nthetas =", octtreeNthetas) # print("Nphis =", octtreeNphis) # order of interpolation NOrderInterpTheta = L[0] NOrderInterpPhi = L[0] # number of zones per theta #num_proc = MPI.COMM_WORLD.Get_size() #Ntheta_zones, Nphi_zones = directions_zones_calculation(num_proc) # now we write the info to disk writeScalarToDisk(NOrderInterpTheta, os.path.join(tmpDirName, 'octtree_data/NOrderInterpTheta.txt') ) writeScalarToDisk(NOrderInterpPhi, os.path.join(tmpDirName, 'octtree_data/NOrderInterpPhi.txt') ) #writeScalarToDisk(Ntheta_zones, os.path.join(tmpDirName, 'octtree_data/Ntheta_zones.txt') ) #writeScalarToDisk(Nphi_zones, os.path.join(tmpDirName, 'octtree_data/Nphi_zones.txt') ) writeASCIIBlitzArrayToDisk(L, os.path.join(tmpDirName, 'octtree_data/LExpansion.txt') ) writeScalarToDisk(params_simu.alphaTranslation_smoothing_factor, os.path.join(tmpDirName, 'octtree_data/alphaTranslation_smoothing_factor.txt') ) writeScalarToDisk(params_simu.alphaTranslation_thresholdRelValueMax, os.path.join(tmpDirName, 'octtree_data/alphaTranslation_thresholdRelValueMax.txt') ) writeScalarToDisk(params_simu.alphaTranslation_RelativeCountAboveThreshold, os.path.join(tmpDirName, 'octtree_data/alphaTranslation_RelativeCountAboveThreshold.txt') ) writeASCIIBlitzArrayToDisk(octtreeNthetas, os.path.join(tmpDirName, 'octtree_data/octtreeNthetas.txt') ) writeASCIIBlitzArrayToDisk(octtreeNphis, os.path.join(tmpDirName, 'octtree_data/octtreeNphis.txt') ) writeASCIIBlitzArrayToDisk(octtreeXthetas, os.path.join(tmpDirName, 'octtree_data/octtreeXthetas.txt') ) writeASCIIBlitzArrayToDisk(octtreeXphis, os.path.join(tmpDirName, 'octtree_data/octtreeXphis.txt') ) writeASCIIBlitzArrayToDisk(octtreeWthetas, os.path.join(tmpDirName, 'octtree_data/octtreeWthetas.txt') ) writeASCIIBlitzArrayToDisk(octtreeWphis, os.path.join(tmpDirName, 'octtree_data/octtreeWphis.txt') ) A_theta, B_theta, A_phi, B_phi = 0., pi, 0., 2.*pi N_theta, N_phi = octtreeNthetas[0], octtreeNphis[0] INCLUDED_THETA_BOUNDARIES, INCLUDED_PHI_BOUNDARIES = 0, 0 if (abs(octtreeXthetas[0,0]-A_theta)<=1.e-8) and (abs(octtreeXthetas[0,N_theta-1]-B_theta)<=1.e-8): INCLUDED_THETA_BOUNDARIES = 1 if (abs(octtreeXphis[0,0]-A_phi)<=1.e-8) and (abs(octtreeXphis[0,N_phi-1]-B_phi)<=1.e-8): INCLUDED_PHI_BOUNDARIES = 1 writeScalarToDisk(INCLUDED_THETA_BOUNDARIES, os.path.join(tmpDirName, 'octtree_data/INCLUDED_THETA_BOUNDARIES.txt') ) writeScalarToDisk(INCLUDED_PHI_BOUNDARIES, os.path.join(tmpDirName, 'octtree_data/INCLUDED_PHI_BOUNDARIES.txt') ) # we now have to calculate the theta/phi abscissas for the coarsest level # These are needed for far-field computation L_coarsest = L_computation(k, a*(2**N_levels), NB_DIGITS) # theta abscissas NpointsTheta = L_coarsest + 1 DTheta = 0 if not params_simu.AUTOMATIC_THETAS and (params_simu.USER_DEFINED_NB_THETA > 0): NpointsTheta = params_simu.USER_DEFINED_NB_THETA else: NpointsThetaTmp = NpointsTheta * (params_simu.STOP_THETA - params_simu.START_THETA)/pi NpointsTheta = int(ceil(NpointsThetaTmp))+1 octtreeXthetas_coarsest = zeros(NpointsTheta, 'd') if NpointsTheta>1: DTheta = (params_simu.STOP_THETA - params_simu.START_THETA)/(NpointsTheta - 1) for i in range(NpointsTheta): octtreeXthetas_coarsest[i] = params_simu.START_THETA + i*DTheta # make sure the last element is params_simu.STOP_THETA octtreeXthetas_coarsest[-1] = params_simu.STOP_THETA else: octtreeXthetas_coarsest[0] = params_simu.START_THETA # phis abscissas NpointsPhi = 2 * L_coarsest DPhi = 0 if not params_simu.AUTOMATIC_PHIS and (params_simu.USER_DEFINED_NB_PHI > 0): NpointsPhi = params_simu.USER_DEFINED_NB_PHI else: NpointsPhiTmp = NpointsPhi * (params_simu.STOP_PHI - params_simu.START_PHI)/(2.0*pi) NpointsPhi = int(ceil(NpointsPhiTmp))+1 octtreeXphis_coarsest = zeros(NpointsPhi, 'd') if NpointsPhi>1: DPhi = (params_simu.STOP_PHI - params_simu.START_PHI)/(NpointsPhi-1) for i in range(NpointsPhi): octtreeXphis_coarsest[i] = params_simu.START_PHI + i*DPhi # make sure the last element is params_simu.STOP_PHI octtreeXphis_coarsest[-1] = params_simu.STOP_PHI else: octtreeXphis_coarsest[0] = params_simu.START_PHI if (my_id==0): print("Summary of sampling points at the coarsest level (used for far-field sampling).") print("L_coarsest =", L_coarsest) print("For 0 < theta < 180, NpointsTheta = L_coarsest + 1 =", L_coarsest + 1) print("For", params_simu.START_THETA/pi*180, "< theta <", params_simu.STOP_THETA/pi*180, ", NpointsTheta =", NpointsTheta, ", DTheta =", DTheta/pi*180, "degrees") print("For 0 < phi < 360, NpointsPhi = 2 * L_coarsest =", 2 * L_coarsest) print("For", params_simu.START_PHI/pi*180, "< phi <", params_simu.STOP_PHI/pi*180, ", NpointsPhi =", NpointsPhi, ", DPhi =", DPhi/pi*180, "degrees") writeASCIIBlitzArrayToDisk(octtreeXthetas_coarsest, os.path.join(tmpDirName, 'octtree_data/octtreeXthetas_coarsest.txt') ) writeASCIIBlitzArrayToDisk(octtreeXphis_coarsest, os.path.join(tmpDirName, 'octtree_data/octtreeXphis_coarsest.txt') ) MPI.COMM_WORLD.Barrier()
def setup_excitation(params_simu, inputDirName, simuDirName): num_proc = MPI.COMM_WORLD.Get_size() my_id = MPI.COMM_WORLD.Get_rank() tmpDirName = os.path.join(simuDirName, 'tmp' + str(my_id)) # phase center writeASCIIBlitzArrayToDisk(array(params_simu.r_phase_center), os.path.join(tmpDirName,'V_CFIE/r_phase_center.txt')) # observation points if (params_simu.BISTATIC_R_OBS == 1) and (params_simu.BISTATIC_R_OBS_FILENAME != ""): if (my_id==0): # this file is only on processor 0 r_obs = read_observation_points(os.path.join(inputDirName, params_simu.BISTATIC_R_OBS_FILENAME)) else: r_obs = zeros((1, 3), 'd') r_obs = MPI.COMM_WORLD.bcast(r_obs) writeASCIIBlitzArrayToDisk(r_obs, os.path.join(tmpDirName,'V_CFIE/r_obs.txt')) writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/BISTATIC_R_OBS.txt')) else: writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/BISTATIC_R_OBS.txt')) # bistatic observation angles if (params_simu.BISTATIC == 1) and (params_simu.BISTATIC_ANGLES_OBS == 1) and (params_simu.BISTATIC_ANGLES_OBS_FILENAME != ""): writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/BISTATIC_ANGLES_OBS.txt')) else: writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/BISTATIC_ANGLES_OBS.txt')) # Antenna pattern? if (params_simu.BISTATIC == 1) and (params_simu.ANTENNA_PATTERN == 1): writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/ANTENNA_PATTERN.txt')) else: writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/ANTENNA_PATTERN.txt')) # now the excitations writeScalarToDisk(params_simu.BISTATIC_EXCITATION_DIPOLES, os.path.join(tmpDirName,'V_CFIE/DIPOLES_EXCITATION.txt')) writeScalarToDisk(params_simu.BISTATIC_EXCITATION_PLANE_WAVE, os.path.join(tmpDirName,'V_CFIE/PLANE_WAVE_EXCITATION.txt')) writeScalarToDisk(params_simu.V_FULL_PRECISION*1, os.path.join(tmpDirName, 'V_CFIE/V_FULL_PRECISION.txt') ) # if we have dipoles excitation AND definition of the excitation in a user-supplied file if (params_simu.BISTATIC_EXCITATION_DIPOLES == 1): if params_simu.BISTATIC_EXCITATION_J_DIPOLES_FILENAME != "": if (my_id==0): # this file is only on processor 0 J_src, r_J_src = read_dipole_excitation(os.path.join(inputDirName, params_simu.BISTATIC_EXCITATION_J_DIPOLES_FILENAME)) else: J_src, r_J_src = zeros((1, 3), 'D'), zeros((1, 3), 'd') J_src = MPI.COMM_WORLD.bcast(J_src) r_J_src = MPI.COMM_WORLD.bcast(r_J_src) writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/J_DIPOLES_EXCITATION.txt')) writeASCIIBlitzArrayToDisk(J_src, os.path.join(tmpDirName,'V_CFIE/J_dip.txt')) writeASCIIBlitzArrayToDisk(r_J_src, os.path.join(tmpDirName,'V_CFIE/r_J_dip.txt')) else: writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/J_DIPOLES_EXCITATION.txt')) if params_simu.BISTATIC_EXCITATION_M_DIPOLES_FILENAME != "": if (my_id==0): # this file is only on processor 0 M_src, r_M_src = read_dipole_excitation(os.path.join(inputDirName, params_simu.BISTATIC_EXCITATION_M_DIPOLES_FILENAME)) else: M_src, r_M_src = zeros((1, 3), 'D'), zeros((1, 3), 'd') M_src = MPI.COMM_WORLD.bcast(M_src) r_M_src = MPI.COMM_WORLD.bcast(r_M_src) writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/M_DIPOLES_EXCITATION.txt')) writeASCIIBlitzArrayToDisk(M_src, os.path.join(tmpDirName,'V_CFIE/M_dip.txt')) writeASCIIBlitzArrayToDisk(r_M_src, os.path.join(tmpDirName,'V_CFIE/r_M_dip.txt')) else: writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/M_DIPOLES_EXCITATION.txt')) # now the plane wave excitation if params_simu.BISTATIC_EXCITATION_PLANE_WAVE == 1: writeScalarToDisk(params_simu.theta_inc, os.path.join(tmpDirName,'V_CFIE/theta_inc.txt')) writeScalarToDisk(params_simu.phi_inc, os.path.join(tmpDirName,'V_CFIE/phi_inc.txt')) E_inc = array([params_simu.E_inc_theta, params_simu.E_inc_phi], 'D') writeASCIIBlitzArrayToDisk(E_inc, os.path.join(tmpDirName,'V_CFIE/E_inc.txt')) if (params_simu.BISTATIC_EXCITATION_DIPOLES != 1) and (params_simu.BISTATIC_EXCITATION_PLANE_WAVE != 1): if (my_id==0): print("incorrect excitation choice. You have to choose dipole and/or plane wave excitation.") sys.exit(1) if (params_simu.MONOSTATIC_RCS == 1) and (params_simu.ANGLES_FROM_FILE == 1) and (params_simu.ANGLES_FILENAME != ""): if (my_id==0): # this file is only on processor 0 angles = read_input_angles(os.path.join(inputDirName, params_simu.ANGLES_FILENAME)) else: angles = zeros((1, 2), 'd') angles = MPI.COMM_WORLD.bcast(angles) writeASCIIBlitzArrayToDisk(angles, os.path.join(tmpDirName,'V_CFIE/monostatic_angles.txt')) writeScalarToDisk(1, os.path.join(tmpDirName,'V_CFIE/ANGLES_FROM_FILE.txt')) elif (params_simu.MONOSTATIC_RCS == 1) and ((params_simu.ANGLES_FROM_FILE == 0) or (params_simu.ANGLES_FILENAME == "")): writeScalarToDisk(0, os.path.join(tmpDirName,'V_CFIE/ANGLES_FROM_FILE.txt')) if params_simu.MONOSTATIC_SAR==1: writeASCIIBlitzArrayToDisk(array(params_simu.SAR_local_x_hat, 'd'), os.path.join(tmpDirName,'V_CFIE/SAR_local_x_hat.txt')) writeASCIIBlitzArrayToDisk(array(params_simu.SAR_local_y_hat, 'd'), os.path.join(tmpDirName,'V_CFIE/SAR_local_y_hat.txt')) writeASCIIBlitzArrayToDisk(array(params_simu.SAR_plane_origin, 'd'), os.path.join(tmpDirName,'V_CFIE/SAR_plane_origin.txt')) writeScalarToDisk(params_simu.SAR_x_span, os.path.join(tmpDirName,'V_CFIE/SAR_x_span.txt')) writeScalarToDisk(params_simu.SAR_y_span, os.path.join(tmpDirName,'V_CFIE/SAR_y_span.txt')) writeScalarToDisk(params_simu.SAR_x_span_offset, os.path.join(tmpDirName,'V_CFIE/SAR_x_span_offset.txt')) writeScalarToDisk(params_simu.SAR_y_span_offset, os.path.join(tmpDirName,'V_CFIE/SAR_y_span_offset.txt')) writeScalarToDisk(params_simu.SAR_N_x_points, os.path.join(tmpDirName,'V_CFIE/SAR_N_x_points.txt')) writeScalarToDisk(params_simu.SAR_N_y_points, os.path.join(tmpDirName,'V_CFIE/SAR_N_y_points.txt'))
def setup_mesh(params_simu, simuDirName): """Sets up the mesh. params_simu is a class instance that contains the parameters for the simulation. """ my_id = 0 tmpDirName = os.path.join(simuDirName, 'tmp' + str(my_id)) meshPath = os.path.join(tmpDirName, "mesh") # size of cube at finest level a = c / params_simu.f * params_simu.a_factor is_closed_surface = readASCIIBlitzIntArray1DFromDisk( os.path.join(meshPath, "is_closed_surface.txt")) S = len(is_closed_surface) print("test of the closed surfaces : " + str(is_closed_surface)) N_RWG = readIntFromDisk(os.path.join(meshPath, "N_RWG.txt")) print("Number of RWG = " + str(N_RWG)) sys.stdout.flush() triangles_surfaces = readASCIIBlitzIntArray1DFromDisk( os.path.join(meshPath, "triangles_surfaces.txt")) RWGNumber_signedTriangles = readBlitzArrayFromDisk( os.path.join(meshPath, "RWGNumber_signedTriangles.txt"), N_RWG, 2, 'i') RWGNumber_CFIE_OK, RWGNumber_M_CURRENT_OK = compute_RWG_CFIE_OK( triangles_surfaces, RWGNumber_signedTriangles, is_closed_surface) RWGNumber_edgeVertexes = readBlitzArrayFromDisk( os.path.join(meshPath, "RWGNumber_edgeVertexes.txt"), N_RWG, 2, 'i') average_RWG_length = readFloatFromDisk( os.path.join(meshPath, 'average_RWG_length.txt')) if params_simu.VERBOSE == 1: print("average RWG length = " + str(average_RWG_length) + "m = lambda /" + str((c / params_simu.f) / average_RWG_length)) # cubes computation WEAVE = 0 if WEAVE != 0: print("Using good old weave!") from Cubes import cube_lower_coord_computation, RWGNumber_cubeNumber_computation, cubeIndex_RWGNumbers_computation, findCubeNeighbors from mesh_functions_seb import compute_RWGNumber_edgeCentroidCoord max_N_cubes_1D, N_levels, big_cube_lower_coord, big_cube_center_coord = cube_lower_coord_computation( a, vertexes_coord) N_levels = max(N_levels, 2) RWGNumber_edgeCentroidCoord = compute_RWGNumber_edgeCentroidCoord( vertexes_coord, RWGNumber_edgeVertexes) RWGNumber_cubeNumber, RWGNumber_cubeCentroidCoord = RWGNumber_cubeNumber_computation( a, max_N_cubes_1D, big_cube_lower_coord, RWGNumber_edgeCentroidCoord) cubes_RWGsNumbers, cubes_lists_RWGsNumbers, cube_N_RWGs, cubes_centroids = cubeIndex_RWGNumbers_computation( RWGNumber_cubeNumber, RWGNumber_cubeCentroidCoord) print("Average number of RWGs per cube: " + str(mean(cube_N_RWGs))) C = cubes_centroids.shape[0] cubes_lists_NeighborsIndexes, cubes_neighborsIndexes, cube_N_neighbors = findCubeNeighbors( max_N_cubes_1D, big_cube_lower_coord, cubes_centroids, a) writeScalarToDisk(C, os.path.join(meshPath, "C.txt")) writeBlitzArrayToDisk( cubes_centroids, os.path.join(meshPath, 'cubes_centroids') + '.txt') writeBlitzArrayToDisk( cubes_RWGsNumbers, os.path.join(meshPath, 'cubes_RWGsNumbers') + '.txt') writeBlitzArrayToDisk(cube_N_RWGs, os.path.join(meshPath, 'cube_N_RWGs') + '.txt') writeBlitzArrayToDisk( cubes_neighborsIndexes, os.path.join(meshPath, 'cubes_neighborsIndexes') + '.txt') writeBlitzArrayToDisk( cube_N_neighbors, os.path.join(meshPath, 'cube_N_neighbors') + '.txt') writeScalarToDisk(N_levels, os.path.join(meshPath, "N_levels.txt")) else: print("Using new mesh_cubes.cpp code") print(commands.getoutput("./code/MoM/mesh_cubes " + meshPath + "/")) C = readIntFromDisk(os.path.join(meshPath, 'C.txt')) # making of cubes_lists_RWGsNumbers cubes_RWGsNumbers = read1DBlitzArrayFromDisk( os.path.join(meshPath, "cubes_RWGsNumbers.txt"), 'i') cube_N_RWGs = read1DBlitzArrayFromDisk( os.path.join(meshPath, "cube_N_RWGs.txt"), 'i') print("Average number of RWGs per cube: " + str(mean(cube_N_RWGs))) cubes_lists_RWGsNumbers = {} index = 0 for i in range(C): array_tmp = zeros(cube_N_RWGs[i], 'i') for j in range(cube_N_RWGs[i]): array_tmp[j] = cubes_RWGsNumbers[index] index += 1 cubes_lists_RWGsNumbers[i] = array_tmp # making of cubes_lists_NeighborsIndexes cubesNeighborsIndexesTmp2 = readBlitzArrayFromDisk( os.path.join(meshPath, "cubesNeighborsIndexesTmp2.txt"), C, 28, 'i') cubes_lists_NeighborsIndexes = {} for i in range(C): cubes_lists_NeighborsIndexes[i] = [ elem for elem in cubesNeighborsIndexesTmp2[i] if elem > -1 ] # writing some data file = open(os.path.join(meshPath, 'cubes_lists_RWGsNumbers.txt'), 'wb') cPickle.dump(cubes_lists_RWGsNumbers, file) file.close() file = open(os.path.join(meshPath, 'cubes_lists_NeighborsIndexes.txt'), 'wb') cPickle.dump(cubes_lists_NeighborsIndexes, file) file.close() writeScalarToDisk(S, os.path.join(meshPath, "S.txt")) writeBlitzArrayToDisk(RWGNumber_CFIE_OK, os.path.join(meshPath, 'RWGNumber_CFIE_OK') + '.txt') writeBlitzArrayToDisk( RWGNumber_M_CURRENT_OK, os.path.join(meshPath, 'RWGNumber_M_CURRENT_OK') + '.txt')
def saveToDisk(self, path): """this function writes to disk the arrays necessary for MLFMA to work.""" writeBlitzArrayToDisk(self.cubes_centroids, os.path.join(path, 'cubes_centroids') + '.txt') writeBlitzArrayToDisk(self.cubes_RWGsNumbers, os.path.join(path, 'cubes_RWGsNumbers') + '.txt') writeBlitzArrayToDisk(self.cube_N_RWGs, os.path.join(path, 'cube_N_RWGs') + '.txt') writeBlitzArrayToDisk( self.cubes_neighborsIndexes, os.path.join(path, 'cubes_neighborsIndexes') + '.txt') writeBlitzArrayToDisk(self.cube_N_neighbors, os.path.join(path, 'cube_N_neighbors') + '.txt') file = open(os.path.join(path, 'cubes_lists_RWGsNumbers.txt'), 'wb') cPickle.dump(self.cubes_lists_RWGsNumbers, file) file.close() file = open(os.path.join(path, 'cubes_lists_NeighborsIndexes.txt'), 'wb') cPickle.dump(self.cubes_lists_NeighborsIndexes, file) file.close() writeBlitzArrayToDisk(self.vertexes_coord, os.path.join(path, 'vertexes_coord') + '.txt') writeBlitzArrayToDisk(self.triangle_vertexes, os.path.join(path, 'triangle_vertexes') + '.txt') writeBlitzArrayToDisk( self.triangles_surfaces, os.path.join(path, 'triangles_surfaces') + '.txt') writeBlitzArrayToDisk(self.IS_CLOSED_SURFACE, os.path.join(path, 'isClosedSurface') + '.txt') writeBlitzArrayToDisk(self.RWGNumber_CFIE_OK, os.path.join(path, 'RWGNumber_CFIE_OK') + '.txt') writeBlitzArrayToDisk( self.RWGNumber_M_CURRENT_OK, os.path.join(path, 'RWGNumber_M_CURRENT_OK') + '.txt') writeBlitzArrayToDisk( self.RWGNumber_signedTriangles, os.path.join(path, 'RWGNumber_signedTriangles') + '.txt') writeBlitzArrayToDisk( self.RWGNumber_edgeVertexes, os.path.join(path, 'RWGNumber_edgeVertexes') + '.txt') writeBlitzArrayToDisk( self.RWGNumber_oppVertexes, os.path.join(path, 'RWGNumber_oppVertexes') + '.txt') writeBlitzArrayToDisk( self.big_cube_lower_coord, os.path.join(path, 'big_cube_lower_coord') + '.txt') writeBlitzArrayToDisk( self.big_cube_center_coord, os.path.join(path, 'big_cube_center_coord') + '.txt') # now we write the scalar values writeScalarToDisk(self.C, os.path.join(path, "C.txt")) writeScalarToDisk(self.N_RWG, os.path.join(path, "N_RWG.txt")) writeScalarToDisk(self.T, os.path.join(path, "T.txt")) writeScalarToDisk(self.S, os.path.join(path, "S.txt")) writeScalarToDisk(self.vertexes_coord.shape[0], os.path.join(path, "V.txt")) writeScalarToDisk(self.N_levels, os.path.join(path, "N_levels.txt"))
def setup_mesh(params_simu, simuDirName): """Sets up the mesh. params_simu is a class instance that contains the parameters for the simulation. """ num_procs = MPI.COMM_WORLD.Get_size() my_id = MPI.COMM_WORLD.Get_rank() tmpDirName = os.path.join(simuDirName, 'tmp' + str(my_id)) geoDirName = os.path.join(simuDirName, 'geo') meshPath = os.path.join(tmpDirName, "mesh") # size of cube at finest level a = params_simu.c / params_simu.f * params_simu.a_factor if (my_id == 0): N_RWG = readIntFromDisk(os.path.join(meshPath, "N_RWG.txt")) N_levels = readIntFromDisk(os.path.join(meshPath, 'N_levels.txt')) max_N_cubes_1D = readIntFromDisk( os.path.join(meshPath, 'max_N_cubes_1D.txt')) C = readIntFromDisk(os.path.join(meshPath, 'C.txt')) big_cube_center_coord = read1DBlitzArrayFromDisk( os.path.join(meshPath, "big_cube_center_coord.txt"), 'd') big_cube_lower_coord = read1DBlitzArrayFromDisk( os.path.join(meshPath, "big_cube_lower_coord.txt"), 'd') # writing some data print("N_levels = " + str(N_levels)) print("max_N_cubes_1D = " + str(max_N_cubes_1D)) print("big_cube_center_coord = " + str(big_cube_center_coord)) print("big_cube_lower_coord = " + str(big_cube_lower_coord)) else: big_cube_lower_coord = ['blabla'] big_cube_center_coord = ['blabla'] N_levels = ['blabla'] N_RWG = ['blabla'] C = ['blabla'] big_cube_lower_coord = MPI.COMM_WORLD.bcast(big_cube_lower_coord) big_cube_center_coord = MPI.COMM_WORLD.bcast(big_cube_center_coord) N_levels = MPI.COMM_WORLD.bcast(N_levels) N_RWG = MPI.COMM_WORLD.bcast(N_RWG) C = MPI.COMM_WORLD.bcast(C) w = 2. * pi * params_simu.f k = w * sqrt(params_simu.eps_0 * params_simu.eps_r * params_simu.mu_0 * params_simu.mu_r) + 1.j * 0. CFIE = array(params_simu.CFIE).astype('D') writeScalarToDisk(num_procs, os.path.join(tmpDirName, 'octtree_data/num_procs.txt')) writeScalarToDisk( a, os.path.join(tmpDirName, 'octtree_data/leaf_side_length.txt')) writeScalarToDisk(2.0 * pi * params_simu.f, os.path.join(tmpDirName, 'octtree_data/w.txt')) writeScalarToDisk(params_simu.eps_r, os.path.join(tmpDirName, 'octtree_data/eps_r.txt')) writeScalarToDisk(params_simu.mu_r, os.path.join(tmpDirName, 'octtree_data/mu_r.txt')) writeScalarToDisk(k, os.path.join(tmpDirName, 'octtree_data/k.txt')) writeASCIIBlitzArrayToDisk( CFIE, os.path.join(tmpDirName, 'octtree_data/CFIEcoeffs.txt')) writeScalarToDisk(N_RWG, os.path.join(tmpDirName, 'octtree_data/N_RWG.txt')) writeScalarToDisk( N_levels - 1, os.path.join(tmpDirName, 'octtree_data/N_active_levels.txt')) writeASCIIBlitzArrayToDisk( big_cube_lower_coord, os.path.join(tmpDirName, 'octtree_data/big_cube_lower_coord.txt')) writeASCIIBlitzArrayToDisk( big_cube_center_coord, os.path.join(tmpDirName, 'octtree_data/big_cube_center_coord.txt')) writeScalarToDisk( params_simu.PERIODIC_Theta * 1, os.path.join(tmpDirName, 'octtree_data/PERIODIC_Theta.txt')) writeScalarToDisk( params_simu.CYCLIC_Theta * 1, os.path.join(tmpDirName, 'octtree_data/CYCLIC_Theta.txt')) writeScalarToDisk( params_simu.PERIODIC_Phi * 1, os.path.join(tmpDirName, 'octtree_data/PERIODIC_Phi.txt')) writeScalarToDisk(params_simu.CYCLIC_Phi * 1, os.path.join(tmpDirName, 'octtree_data/CYCLIC_Phi.txt')) writeScalarToDisk( params_simu.ALLOW_CEILING_LEVEL * 1, os.path.join(tmpDirName, 'octtree_data/ALLOW_CEILING_LEVEL.txt')) writeScalarToDisk( params_simu.DIRECTIONS_PARALLELIZATION * 1, os.path.join(tmpDirName, 'octtree_data/DIRECTIONS_PARALLELIZATION.txt')) writeScalarToDisk( params_simu.BE_BH_N_Gauss_points, os.path.join(tmpDirName, 'octtree_data/N_GaussOnTriangle.txt')) writeScalarToDisk( params_simu.MOM_FULL_PRECISION * 1, os.path.join(tmpDirName, 'octtree_data/MOM_FULL_PRECISION.txt')) writeScalarToDisk(params_simu.VERBOSE * 1, os.path.join(tmpDirName, 'octtree_data/VERBOSE.txt')) writeScalarToDisk(params_simu.TDS_APPROX * 1, os.path.join(tmpDirName, 'octtree_data/TDS_APPROX.txt')) writeScalarToDisk(params_simu.Z_s, os.path.join(tmpDirName, 'octtree_data/Z_s.txt')) # what type of simulation are we running? writeScalarToDisk(params_simu.BISTATIC * 1, os.path.join(tmpDirName, 'BISTATIC.txt')) writeScalarToDisk(params_simu.MONOSTATIC_RCS * 1, os.path.join(tmpDirName, 'MONOSTATIC_RCS.txt')) writeScalarToDisk(params_simu.MONOSTATIC_SAR * 1, os.path.join(tmpDirName, 'MONOSTATIC_SAR.txt')) writeScalarToDisk(params_simu.COMPUTE_RCS_HH * 1, os.path.join(tmpDirName, 'COMPUTE_RCS_HH.txt')) writeScalarToDisk(params_simu.COMPUTE_RCS_VV * 1, os.path.join(tmpDirName, 'COMPUTE_RCS_VV.txt')) writeScalarToDisk(params_simu.COMPUTE_RCS_HV * 1, os.path.join(tmpDirName, 'COMPUTE_RCS_HV.txt')) writeScalarToDisk(params_simu.COMPUTE_RCS_VH * 1, os.path.join(tmpDirName, 'COMPUTE_RCS_VH.txt')) writeScalarToDisk(params_simu.USE_PREVIOUS_SOLUTION * 1, os.path.join(tmpDirName, 'USE_PREVIOUS_SOLUTION.txt')) writeScalarToDisk( params_simu.MONOSTATIC_BY_BISTATIC_APPROX * 1, os.path.join(tmpDirName, 'MONOSTATIC_BY_BISTATIC_APPROX.txt')) writeScalarToDisk(params_simu.MAXIMUM_DELTA_PHASE, os.path.join(tmpDirName, 'MAXIMUM_DELTA_PHASE.txt')) # writing the iterative solver setup restrt = min(params_simu.RESTART, N_RWG) writeScalarToDisk(params_simu.MAXITER, os.path.join(tmpDirName, 'iterative_data/MAXITER.txt')) writeScalarToDisk(restrt, os.path.join(tmpDirName, 'iterative_data/RESTART.txt')) writeScalarToDisk(params_simu.SOLVER, os.path.join(tmpDirName, 'iterative_data/SOLVER.txt')) writeScalarToDisk( params_simu.INNER_SOLVER, os.path.join(tmpDirName, 'iterative_data/INNER_SOLVER.txt')) writeScalarToDisk(params_simu.TOL, os.path.join(tmpDirName, 'iterative_data/TOL.txt')) writeScalarToDisk(params_simu.INNER_TOL, os.path.join(tmpDirName, 'iterative_data/INNER_TOL.txt')) writeScalarToDisk( params_simu.INNER_MAXITER, os.path.join(tmpDirName, 'iterative_data/INNER_MAXITER.txt')) writeScalarToDisk( params_simu.INNER_RESTART, os.path.join(tmpDirName, 'iterative_data/INNER_RESTART.txt')) writeScalarToDisk(N_RWG, os.path.join(tmpDirName, 'ZI/ZI_size.txt')) variables = {} variables['a'] = a variables['k'] = k variables['w'] = w variables['C'] = C variables['N_RWG'] = N_RWG variables['N_levels'] = N_levels variables['CFIE'] = CFIE file = open(os.path.join(tmpDirName, 'pickle', 'variables.txt'), 'wb') cPickle.dump(variables, file) file.close()
def Mg_listsOfZnearBlocks_ToTransmitAndReceive( ZnearChunkNumber_to_cubesNumbers, ZnearCubeNumber_to_chunkNumber, ZnearChunkNumber_to_processNumber, ZnearProcessNumber_to_ChunksNumbers, pathToReadFrom, Z_TMP_ELEM_TYPE): """this function creates 2 lists: Mg_listsOfZ_nearToTransmit and Mg_listsOfZ_nearToReceive""" num_proc = MPI.COMM_WORLD.Get_size() my_id = MPI.COMM_WORLD.Get_rank() chunkNumbers = ZnearProcessNumber_to_ChunksNumbers[my_id] localPreconditionedCubesNumbers = [] for i in chunkNumbers: localPreconditionedCubesNumbers.append( ZnearChunkNumber_to_cubesNumbers[i]) listCubesNumbersToReceiveTmp, listCubesNumbersToSendTmp = [], [] # initialization of the lists for i in range(num_proc): listCubesNumbersToReceiveTmp.append([]) listCubesNumbersToSendTmp.append([]) # we now fill the lists for elem in localPreconditionedCubesNumbers: for localCube in elem: # elem is a list of cubes Numbers chunkNumber = ZnearCubeNumber_to_chunkNumber[localCube] pathToReadCubeFrom = os.path.join(pathToReadFrom, "chunk" + str(chunkNumber)) cube = CubeClass() cube.setIntArraysFromFile(pathToReadCubeFrom, localCube) for j in cube.cubeNeighborsIndexes: ZnearChunkNumber = ZnearCubeNumber_to_chunkNumber[j] ZnearProcessNumber = ZnearChunkNumber_to_processNumber[int( ZnearChunkNumber)] if not (my_id == ZnearProcessNumber): listCubesNumbersToReceiveTmp[ZnearProcessNumber].append(j) listCubesNumbersToSendTmp[ZnearProcessNumber].append( localCube) # we now reduce the redundancy of the lists listCubesNumbersToReceive, listCubesNumbersToSend = [], [] for i in range(num_proc): listCubesNumbersToReceive.append( reduceListRedundancy(listCubesNumbersToReceiveTmp[i])) listCubesNumbersToSend.append( reduceListRedundancy(listCubesNumbersToSendTmp[i])) # now we construct the corresponding chunkNumbers and processNumbers lists listChunkNumbersToReceive, listChunkNumbersToSend = [], [] for L in listCubesNumbersToReceive: listChunkNumbersToReceive.append([]) for i in L: listChunkNumbersToReceive[-1].append( ZnearCubeNumber_to_chunkNumber[i]) for L in listCubesNumbersToSend: listChunkNumbersToSend.append([]) for i in L: listChunkNumbersToSend[-1].append( ZnearCubeNumber_to_chunkNumber[i]) ## we create the missing directories for L in listChunkNumbersToReceive: for i in L: if 'chunk' + str(i) not in os.listdir(pathToReadFrom): os.mkdir(os.path.join(pathToReadFrom, 'chunk' + str(i))) ## now we write the data to be exchanged to disk for i in range(num_proc): if not (my_id == i): writeASCIIBlitzArrayToDisk( array(listCubesNumbersToSend[i]).astype('i'), os.path.join(pathToReadFrom, "CubesNumbersToSendToP" + str(i) + ".txt")) writeASCIIBlitzArrayToDisk( array(listChunkNumbersToSend[i]).astype('i'), os.path.join(pathToReadFrom, "ChunkNumbersToSendToP" + str(i) + ".txt")) #MPI.COMM_WORLD.Barrier() ## finally we write the format of the Near Field matrix elements NBytes = 8 if Z_TMP_ELEM_TYPE == 'D': NBytes = 16 print( "16 Bytes not supported yet in data transfer in communicateZnearBlocks. Exiting...." ) sys.exit(1) writeScalarToDisk(NBytes, os.path.join(pathToReadFrom, "itemsize.txt")) MPI.COMM_WORLD.Barrier()