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 writeIntDoubleArraysToFile(self, pathToSaveTo, cubeNumber):
writeBlitzArrayToDisk(
self.cubeIntArrays,
os.path.join(pathToSaveTo,
str(cubeNumber) + "_IntArrays.txt"))
writeBlitzArrayToDisk(
self.cubeDoubleArrays,
os.path.join(pathToSaveTo,
str(cubeNumber) + "_DoubleArrays.txt"))
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 Z_nearPerCube(path, cube, CFIE, cubeNumber, w, eps_r, mu_r, ELEM_TYPE,
Z_TMP_ELEM_TYPE, TDS_APPROX, Z_s, MOM_FULL_PRECISION):
"""this function computes the part of the MoM Z matrix corresponding to
the cube 'cubeNumber' as the observer cube and all its neighbors cubes,
including itself, as the source cubes."""
# call of the C++ routine for computing the interaction matrix
Z_CFIE_near_local = Z_MoM_triangles_arraysFromCube(cube, CFIE, w, eps_r,
mu_r, TDS_APPROX, Z_s,
MOM_FULL_PRECISION)
# we create a 1-D array out of Z_CFIE_near_local
Z_CFIE_nearPerCube = array(Z_CFIE_near_local.astype(ELEM_TYPE).flat)
writeBlitzArrayToDisk(Z_CFIE_near_local.astype(Z_TMP_ELEM_TYPE),
os.path.join(path, str(cubeNumber)))
return Z_CFIE_nearPerCube
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 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"))