def test_all(self): cls = self.__class__ rank = cls.comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(file_dir+'/'+filename, cls.parallelEnv) parameter_map = problem.getParameterMap(0) parameter = Tpetra.MultiVector(parameter_map, 1, dtype="d") num_elems = parameter_map.getNodeNumElements() parameter[0, :] = 2.0*np.ones(num_elems) problem.performSolve() state_map = problem.getStateMap() state = Tpetra.MultiVector(state_map, 1, dtype="d") state[0, :] = problem.getState() state_ref = Utils.loadMVector('state_ref', 1, state_map, distributedFile=False, useBinary=False, readOnRankZero=True) stackedTimer = problem.getStackedTimer() setup_time = stackedTimer.accumulatedTime("PyAlbany: Setup Time") print("setup_time = " + str(setup_time)) tol = 1.e-8 self.assertTrue(np.linalg.norm(state_ref[0, :] - state[0,:]) < tol)
def test_all(self): cls = self.__class__ rank = cls.comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(file_dir+'/'+filename, cls.parallelEnv) n_vecs = 4 parameter_map = problem.getParameterMap(0) num_elems = parameter_map.getNodeNumElements() # generate vectors with random entries omega = Tpetra.MultiVector(parameter_map, n_vecs, dtype="d") for i in range(n_vecs): omega[i,:] = np.random.randn(num_elems) # call the orthonormalization method wpa.orthogTpMVecs(omega, 2) # check that the vectors are now orthonormal tol = 1.e-12 for i in range(n_vecs): for j in range(i+1): omegaiTomegaj = Utils.inner(omega[i,:], omega[j,:], cls.comm) if rank == 0: if i == j: self.assertTrue(abs(omegaiTomegaj - 1.0) < tol) else: self.assertTrue(abs(omegaiTomegaj-0.0) < tol)
def test_write_non_distributed_npy(self): cls = self.__class__ rank = cls.comm.getRank() nproc = cls.comm.getSize() if nproc > 1: mvector_filename = 'out_mvector_write_test_' + str(nproc) else: mvector_filename = 'out_mvector_write_test' file_dir = os.path.dirname(__file__) filename = 'input.yaml' problem = Utils.createAlbanyProblem(file_dir + '/' + filename, cls.parallelEnv) n_cols = 4 parameter_map = problem.getParameterMap(0) mvector = Tpetra.MultiVector(parameter_map, n_cols, dtype="d") mvector[0, :] = 1. * (rank + 1) mvector[1, :] = -1. * (rank + 1) mvector[2, :] = 3.26 * (rank + 1) mvector[3, :] = -3.1 * (rank + 1) Utils.writeMVector(file_dir + '/' + mvector_filename, mvector, distributedFile=False, useBinary=True)
def main(parallelEnv): comm = Teuchos.DefaultComm.getComm() filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(filename, parallelEnv) # We can get from the Albany problem the map of a distributed parameter: parameter_map = problem.getParameterMap(0) # This map can then be used to construct an RCP to a Tpetra::Multivector: m_directions = 4 directions = Tpetra.MultiVector(parameter_map, m_directions, dtype="d") # Numpy operations, such as assignments, can then be performed on the local entries: directions[0, :] = 1. # Set all entries of v_0 to 1 directions[1, :] = -1. # Set all entries of v_1 to -1 directions[2, :] = 3. # Set all entries of v_2 to 3 directions[3, :] = -3. # Set all entries of v_3 to -3 # Now that we have an RCP to the directions, we provide it to the Albany problem: problem.setDirections(0, directions) # Finally, we can solve the problem (which includes applying the Hessian to the directions) # and get the Hessian-vector products: problem.performSolve() hessian = problem.getReducedHessian(0, 0)
def _matvec(self, x): parameter_map = self.problem.getParameterMap(self.parameter_id) direction = Tpetra.MultiVector(parameter_map, 1, dtype="d") direction[0, :] = x self.problem.setDirections(self.parameter_id, direction) self.problem.performSolve() hessian = self.problem.getReducedHessian(self.response_id, self.parameter_id) return hessian[0, :]
def test_all(self): cls = self.__class__ rank = cls.comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(file_dir+'/'+filename, cls.parallelEnv) n_directions = 4 parameter_map = problem.getParameterMap(0) directions = Tpetra.MultiVector(parameter_map, n_directions, dtype="d") directions[0,:] = 1. directions[1,:] = -1. directions[2,:] = 3. directions[3,:] = -3. problem.setDirections(0, directions) problem.performSolve() response = problem.getResponse(0) sensitivity = problem.getSensitivity(0, 0) hessian = problem.getReducedHessian(0, 0) g_target = 3.23754626955999991e-01 norm_target = 8.94463776843999921e-03 h_target = np.array([0.009195356672103817, 0.009195356672103817, 0.027586070971800013, 0.027586070971800013]) g_data = response.getData() norm = Utils.norm(sensitivity.getData(0), cls.comm) print("g_target = " + str(g_target)) print("g_data[0] = " + str(g_data[0])) print("norm = " + str(norm)) print("norm_target = " + str(norm_target)) hessian_norms = np.zeros((n_directions,)) for i in range(0,n_directions): hessian_norms[i] = Utils.norm(hessian.getData(i), cls.comm) tol = 1e-8 if rank == 0: self.assertTrue(np.abs(g_data[0]-g_target) < tol) self.assertTrue(np.abs(norm-norm_target) < tol) for i in range(0,n_directions): self.assertTrue(np.abs(hessian_norms[i]-h_target[i]) < tol)
def test_all(self): comm = Teuchos.DefaultComm.getComm() rank = comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(file_dir + '/' + filename) n_directions = 4 parameter_map = problem.getParameterMap(0) directions = Tpetra.MultiVector(parameter_map, n_directions, dtype="d") directions[0, :] = 1. directions[1, :] = -1. directions[2, :] = 3. directions[3, :] = -3. problem.setDirections(0, directions) problem.performSolve() response = problem.getResponse(0) sensitivity = problem.getSensitivity(0, 0) hessian = problem.getReducedHessian(0, 0) g_target = 3.23754626955999991e-01 norm_target = 8.94463776843999921e-03 h_target = np.array([ 4.2121719763904516e-05, -4.21216874727712e-05, 0.00012636506241831498, -0.00012636506241831496 ]) g_data = response.getData() norm = Utils.norm(sensitivity.getData(0), comm) print("g_target = " + str(g_target)) print("g_data[0] = " + str(g_data[0])) print("norm = " + str(norm)) print("norm_target = " + str(norm_target)) tol = 1e-8 if rank == 0: self.assertTrue(np.abs(g_data[0] - g_target) < tol) self.assertTrue(np.abs(norm - norm_target) < tol) for i in range(0, n_directions): self.assertTrue(np.abs(hessian[i, 0] - h_target[i]) < tol)
def _matvec(self, x): tmp1 = self.C_sqr.dot(self.R.dot(self.P.transpose().dot(x))) parameter_map = self.problem.getParameterMap(self.parameter_id) direction = Tpetra.MultiVector(parameter_map, 1, dtype="d") direction[0, :] = tmp1 self.problem.setDirections(self.parameter_id, direction) self.problem.performSolve() hessian = self.problem.getReducedHessian(self.response_id, self.parameter_id) tmp2 = hessian[0, :] tmp3 = self.P.dot(self.R.transpose().dot( self.C_sqr.transpose().dot(tmp2))) return tmp3
def main(parallelEnv): comm = MPI.COMM_WORLD nMaxProcs = comm.Get_size() myGlobalRank = comm.rank timerNames = [ "PyAlbany: Create Albany Problem", "PyAlbany: Set directions", "PyAlbany: Perform Solve", "PyAlbany: Total" ] nTimers = len(timerNames) # number of times that the test is repeated for a fixed # number of MPI processes N = 10 timers_sec = np.zeros((nMaxProcs, nTimers, N)) mean_timers_sec = np.zeros((nMaxProcs, nTimers)) speedUp = np.zeros((nMaxProcs, nTimers)) for nProcs in range(1, nMaxProcs + 1): newGroup = comm.group.Incl(np.arange(0, nProcs)) newComm = comm.Create_group(newGroup) if myGlobalRank < nProcs: parallelEnv.comm = Teuchos.MpiComm(newComm) for i_test in range(0, N): timers = Utils.createTimers(timerNames) timers[3].start() timers[0].start() filename = 'input_conductivity_dist_paramT.yaml' problem = Utils.createAlbanyProblem(filename, parallelEnv) timers[0].stop() timers[1].start() n_directions = 4 parameter_map = problem.getParameterMap(0) directions = Tpetra.MultiVector(parameter_map, n_directions, dtype="d") directions[0, :] = 1. directions[1, :] = -1. directions[2, :] = 3. directions[3, :] = -3. problem.setDirections(0, directions) timers[1].stop() timers[2].start() problem.performSolve() timers[2].stop() timers[3].stop() if myGlobalRank == 0: for j in range(0, nTimers): timers_sec[nProcs - 1, j, i_test] = timers[j].totalElapsedTime() if myGlobalRank == 0: for i in range(0, nMaxProcs): for j in range(0, nTimers): mean_timers_sec[i, j] = np.mean(timers_sec[i, j, :]) speedUp[i, :] = mean_timers_sec[0, :] / (mean_timers_sec[i, :]) print('timers') print(mean_timers_sec) print('speed up') print(speedUp) if printPlot: fig = plt.figure(figsize=(10, 6)) plt.plot(np.arange(1, nMaxProcs + 1), np.arange(1, nMaxProcs + 1), '--') for j in range(0, nTimers): plt.plot(np.arange(1, nMaxProcs + 1), speedUp[:, j], 'o-', label=timerNames[j]) plt.ylabel('speed up') plt.xlabel('number of MPI processes') plt.grid(True) plt.legend() plt.savefig('speedup.jpeg', dpi=800) plt.close()
def loadMVector(filename, n_cols, map, distributedFile=True, useBinary=True, readOnRankZero=True, dtype="d"): """@brief Loads distributed a multivector stored using numpy format. \param filename [in] Base name of the file(s) to load. \param n_cols [in] Number of columns of the multivector. \param map [in] Tpetra map of the multivector which has to be loaded. \param distributedFile (default: True) [in] Bool which specifies whether each MPI process reads a different file (if distributedFile==True, MPI process i reads filename+"_"+str(i)) or if all the entries are stored inside a unique file. \param useBinary (default: True) [in] Bool which specifies if the function reads a binary or a text file. \param readOnRankZero (default: True) [in] Bool which specifies if the file is read by the rank 0 and scattered or if it is read by all the MPI processes. \param dtype (default: "d") [in] Data type of the entries of the multivector. """ rank = map.getComm().getRank() nproc = map.getComm().getSize() mvector = Tpetra.MultiVector(map, n_cols, dtype=dtype) if nproc == 1: if useBinary: mVectorNP = np.load(filename + '.npy') else: mVectorNP = np.loadtxt(filename + '.txt') if (mVectorNP.ndim == 1 and n_cols == 1): mvector[0, :] = mVectorNP else: for i in range(0, n_cols): mvector[i, :] = mVectorNP[i, :] elif distributedFile: if useBinary: mVectorNP = np.load(filename + '_' + str(rank) + '.npy') else: mVectorNP = np.loadtxt(filename + '_' + str(rank) + '.txt') for i in range(0, n_cols): mvector[i, :] = mVectorNP[i, :] else: if readOnRankZero: map0 = wpa.getRankZeroMap(map) mvector0 = Tpetra.MultiVector(map0, n_cols, dtype=dtype) if rank == 0: if useBinary: mVectorNP = np.load(filename + '.npy') else: mVectorNP = np.loadtxt(filename + '.txt') if (mVectorNP.ndim == 1 and n_cols == 1): mvector0[0, :] = mVectorNP else: for i in range(0, n_cols): mvector0[i, :] = mVectorNP[i, :] mvector = wpa.scatterMVector(mvector0, map) else: if useBinary: mVectorNP = np.load(filename + '.npy') else: mVectorNP = np.loadtxt(filename + '.txt') for lid in range(0, map.getNodeNumElements()): gid = map.getGlobalElement(lid) mvector[:, lid] = mVectorNP[:, gid] return mvector