def compute_list_cubes(cubesNumbers, pathToReadCubesFrom, Z_TMP_ELEM_TYPE):
"""returns a list of cubes"""
list_cubes = {}
list_Z_tmp = {}
for i in range(len(cubesNumbers)):
cubeNumber = cubesNumbers[i]
cube = CubeClass()
# we only need the int arrays of the cubes
cube.setIntArraysFromFile(pathToReadCubesFrom, cubeNumber)
list_cubes[cubeNumber] = copy.copy(cube)
list_Z_tmp[cubeNumber] = read_Z_perCube_fromFile(pathToReadCubesFrom, cubeNumber, cube, Z_TMP_ELEM_TYPE)
return list_cubes, list_Z_tmp
def MgPreconditionerComputationPerCube(cube, list_cubes_with_neighbors, list_Z_tmp, pathToReadFrom, cubeNumber_to_chunkNumber, ELEM_TYPE, Z_TMP_ELEM_TYPE, LIB_G2C):
Z_local = eye(cube.N_RWG_src, cube.N_RWG_src).astype(Z_TMP_ELEM_TYPE)
src_edges_numbers_local_src_edges_numbers = {}
index = 0
for RWGnumber in cube.testSrc_RWGsNumbers:
src_edges_numbers_local_src_edges_numbers[RWGnumber] = index
index += 1
## construction of the local matrix to be inverted
for i in range(cube.N_neighbors):
neighborCubeNumber = cube.cubeNeighborsIndexes[int(i)]
if neighborCubeNumber not in list_cubes_with_neighbors:
chunkNumber = cubeNumber_to_chunkNumber[neighborCubeNumber]
pathToReadFromChunk = os.path.join( pathToReadFrom, "chunk" + str(chunkNumber) )
neighborCube = CubeClass()
neighborCube.setIntArraysFromFile(pathToReadFromChunk, neighborCubeNumber)
list_cubes_with_neighbors[neighborCubeNumber] = copy.copy(neighborCube)
list_Z_tmp[neighborCubeNumber] = read_Z_perCube_fromFile(pathToReadFromChunk, neighborCubeNumber, neighborCube, Z_TMP_ELEM_TYPE)
set_cubeNeighborsIndexes = set(cube.cubeNeighborsIndexes)
for i in range(cube.N_neighbors):
neighborCubeNumber = cube.cubeNeighborsIndexes[int(i)]
neighborCube = list_cubes_with_neighbors[neighborCubeNumber]
Z_neighbor = list_Z_tmp[neighborCubeNumber]
if i==0:
## we first fill in the first lines of Z_local
indexes_lines = arange(Z_neighbor.shape[0]).astype('i')
indexes_columns = arange(Z_neighbor.shape[1]).astype('i')
assignValuesToMatrix(Z_local, Z_neighbor, indexes_lines, indexes_columns)
else:
## we then fill in the remaining lines
Z_local_lines_indexes = zeros(neighborCube.N_RWG_test, 'i')
index = 0
for RWGnumber in neighborCube.testSrc_RWGsNumbers[:neighborCube.N_RWG_test]:
Z_local_lines_indexes[index] = src_edges_numbers_local_src_edges_numbers[RWGnumber]
index += 1
common_neighborsNumbers = [val for val in neighborCube.cubeNeighborsIndexes if val in set_cubeNeighborsIndexes]
srcEdgesNumbersOfNeighborCubeToBeConsidered_tmp = []
for common_neighbor in common_neighborsNumbers:
common_neighborCube = list_cubes_with_neighbors[common_neighbor]
testRWGs = common_neighborCube.testSrc_RWGsNumbers[:common_neighborCube.N_RWG_test]
for RWG in testRWGs:
srcEdgesNumbersOfNeighborCubeToBeConsidered_tmp.append(RWG)
set_srcEdgesNumbersOfNeighborCubeToBeConsidered = set(srcEdgesNumbersOfNeighborCubeToBeConsidered_tmp)
columnsOfNeighborCubeToBeConsidered = array([val for val in range(neighborCube.N_RWG_src) if neighborCube.testSrc_RWGsNumbers[val] in set_srcEdgesNumbersOfNeighborCubeToBeConsidered], 'i')
Z_local_columns_indexes = zeros(len(srcEdgesNumbersOfNeighborCubeToBeConsidered_tmp), 'i')
index = 0
for RWGnumber in srcEdgesNumbersOfNeighborCubeToBeConsidered_tmp:
Z_local_columns_indexes[index] = src_edges_numbers_local_src_edges_numbers[RWGnumber]
index += 1
Z_tmp2 = take(Z_neighbor, columnsOfNeighborCubeToBeConsidered, axis=1)
assignValuesToMatrix(Z_local, Z_tmp2, Z_local_lines_indexes, Z_local_columns_indexes)
Z_local_2 = compress(cube.isEdgeInCartesianRadius, Z_local, axis=0).astype('D')
src_edges_numbers_2 = compress(cube.isEdgeInCartesianRadius, cube.testSrc_RWGsNumbers, axis=0)
#Y_CFIE_near_local = linalg.pinv(Z_local_2)
#Y_CFIE_near_local = computeMyPinv(Z_local_2)
Y_CFIE_near_local = computeMyPinvCC(Z_local_2, LIB_G2C)
# we take the first N_RWG_test lines
Mg_tmp = take(Y_CFIE_near_local, arange(cube.N_RWG_test), axis=0)
# we now "flatten" the preconditioner, in order to make a sparse matrix
return (Mg_tmp.flat[:]).astype(ELEM_TYPE), src_edges_numbers_2