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 setInitialGuess(problem, p, n_params, params_in_vector=True): if params_in_vector: parameter_map = problem.getParameterMap(0) parameter = Tpetra.Vector(parameter_map, dtype="d") for j in range(0, n_params): parameter[j] = p[j] problem.setParameter(0, parameter) else: for j in range(0, n_params): parameter_map = problem.getParameterMap(j) parameter = Tpetra.Vector(parameter_map, dtype="d") parameter[0] = p[j] problem.setParameter(j, parameter)
def set_theta_star(self, theta_star): self.theta_star = theta_star if self.params_in_vector: parameter_map = self.problem.getParameterMap(0) parameter = Tpetra.Vector(parameter_map, dtype="d") for k in range(0, self.n_params): parameter[k] = theta_star[k] self.problem.setParameter(0, parameter) else: for k in range(0, self.n_params): parameter_map = self.problem.getParameterMap(k) parameter = Tpetra.Vector(parameter_map, dtype="d") parameter[0] = theta_star[k] self.problem.setParameter(k, parameter)
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 evaluate_responses(X, Y, problem, recompute=False): if not recompute and os.path.isfile('Z1_2.txt'): Z1 = np.loadtxt('Z1_2.txt') Z2 = np.loadtxt('Z2_2.txt') else: comm = MPI.COMM_WORLD myGlobalRank = comm.rank parameter_map = problem.getParameterMap(0) parameter = Tpetra.Vector(parameter_map, dtype="d") n_x = len(X) n_y = len(Y) Z1 = np.zeros((n_y, n_x)) Z2 = np.zeros((n_y, n_x)) for i in range(n_x): parameter[0] = X[i] for j in range(n_y): parameter[1] = Y[j] problem.setParameter(0, parameter) problem.performSolve() Z1[j, i] = problem.getCumulativeResponseContribution(0, 0) Z2[j, i] = problem.getCumulativeResponseContribution(0, 1) np.savetxt('Z1_2.txt', Z1) np.savetxt('Z2_2.txt', Z2) return Z1, Z2
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 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 test_all(self): cls = self.__class__ rank = cls.comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = "input_dirichlet_mixed_paramsT.yaml" parameter = Utils.createParameterList(file_dir + "/" + filename, cls.parallelEnv) parameter.sublist("Discretization").set("1D Elements", 10) parameter.sublist("Discretization").set("2D Elements", 10) problem = Utils.createAlbanyProblem(parameter, cls.parallelEnv) parameter_map_0 = problem.getParameterMap(0) para_0_new = Tpetra.Vector(parameter_map_0, dtype="d") parameter_map_1 = problem.getParameterMap(1) para_1_new = Tpetra.Vector(parameter_map_1, dtype="d") para_1_new[:] = 0.333333 n_values = 5 para_0_values = np.linspace(-1, 1, n_values) responses = np.zeros((n_values, )) responses_target = np.array( [0.69247527, 0.48990929, 0.35681844, 0.29320271, 0.2990621]) tol = 1e-8 for i in range(0, n_values): para_0_new[:] = para_0_values[i] problem.setParameter(0, para_0_new) problem.performSolve() response = problem.getResponse(0) responses[i] = response.getData()[0] print("p = " + str(para_0_values)) print("QoI = " + str(responses)) if rank == 0: self.assertTrue( np.abs(np.amax(responses - responses_target)) < tol)
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 importanceSamplingEstimator(theta_0, C, theta_star, F_star, P_star, samples_0, problem, F_id=1, params_in_vector=True): invC = np.linalg.inv(C) n_l = len(F_star) P = np.zeros((n_l, )) n_samples = np.shape(samples_0)[0] n_params = np.shape(samples_0)[1] # Loop over the lambdas for i in range(0, n_l): # Loop over the samples for j in range(0, n_samples): sample = samples_0[j, :] + theta_star[i, :] - theta_0 if params_in_vector: parameter_map = problem.getParameterMap(0) parameter = Tpetra.Vector(parameter_map, dtype="d") for j in range(0, n_params): parameter[j] = sample[j] problem.setParameter(0, parameter) else: for k in range(0, n_params): parameter_map = problem.getParameterMap(k) parameter = Tpetra.Vector(parameter_map, dtype="d") parameter[0] = sample[k] problem.setParameter(k, parameter) problem.performSolve() if problem.getCumulativeResponseContribution(0, F_id) > F_star[i]: P[i] += np.exp(-invC.dot(theta_star[i, :] - theta_0).dot(sample - theta_star[i, :])) P[i] = P_star[i] * P[i] / n_samples return P
def main(parallelEnv): comm = MPI.COMM_WORLD myGlobalRank = comm.rank # Create an Albany problem: filename = "input_dirichletT.yaml" parameter = Utils.createParameterList( filename, parallelEnv ) problem = Utils.createAlbanyProblem(parameter, parallelEnv) parameter_map_0 = problem.getParameterMap(0) parameter_0 = Tpetra.Vector(parameter_map_0, dtype="d") N = 200 p_min = -2. p_max = 2. # Generate N samples randomly chosen in [p_min, p_max]: p = np.random.uniform(p_min, p_max, N) QoI = np.zeros((N,)) # Loop over the N samples and evaluate the quantity of interest: for i in range(0, N): parameter_0[0] = p[i] problem.setParameter(0, parameter_0) problem.performSolve() response = problem.getResponse(0) QoI[i] = response.getData()[0] if myGlobalRank == 0: if printPlot: f, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(16,6)) ax1.hist(p) ax1.set_ylabel('Counts') ax1.set_xlabel('Random parameter') ax2.scatter(p, QoI) ax2.set_ylabel('Quantity of interest') ax2.set_xlabel('Random parameter') ax3.hist(QoI) ax3.set_ylabel('Counts') ax3.set_xlabel('Quantity of interest') plt.savefig('UQ.jpeg', dpi=800) plt.close()
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 test_all(self): cls = self.__class__ rank = cls.comm.getRank() file_dir = os.path.dirname(__file__) # Create an Albany problem: filename = "input_dirichlet_mixed_paramsT.yaml" parameter = Utils.createParameterList( file_dir + "/" + filename, cls.parallelEnv ) parameter.sublist("Discretization").set("1D Elements", 10) parameter.sublist("Discretization").set("2D Elements", 10) problem = Utils.createAlbanyProblem(parameter, cls.parallelEnv) g_target_before = 0.35681844 g_target_after = 0.17388298 g_target_2 = 0.19570272 p_0_target = 0.39886689 p_1_norm_target = 5.37319376038225 tol = 1e-8 problem.performSolve() response_before_analysis = problem.getResponse(0) problem.performAnalysis() para_0 = problem.getParameter(0) para_1 = problem.getParameter(1) print(para_0.getData()) print(para_1.getData()) para_1_norm = Utils.norm(para_1.getData(), cls.comm) print(para_1_norm) if rank == 0: self.assertTrue(np.abs(para_0[0] - p_0_target) < tol) self.assertTrue(np.abs(para_1_norm - p_1_norm_target) < tol) problem.performSolve() response_after_analysis = problem.getResponse(0) print("Response before analysis " + str(response_before_analysis.getData())) print("Response after analysis " + str(response_after_analysis.getData())) if rank == 0: self.assertTrue(np.abs(response_before_analysis[0] - g_target_before) < tol) self.assertTrue(np.abs(response_after_analysis[0] - g_target_after) < tol) parameter_map_0 = problem.getParameterMap(0) para_0_new = Tpetra.Vector(parameter_map_0, dtype="d") para_0_new[:] = 0.0 problem.setParameter(0, para_0_new) problem.performSolve() response = problem.getResponse(0) print("Response after setParameter " + str(response.getData())) if rank == 0: self.assertTrue(np.abs(response[0] - g_target_2) < tol)
def mixedImportanceSamplingEstimator(theta_0, C, theta_star, F_star, P_star, samples_0, problem, angle_1, angle_2, F_id=1, params_in_vector=True): invC = np.linalg.inv(C) n_l = len(F_star) P = np.zeros((n_l, )) n_samples = np.shape(samples_0)[0] n_params = np.shape(samples_0)[1] problem.updateCumulativeResponseContributionWeigth(0, 0, -1) problem.updateCumulativeResponseContributionWeigth(0, F_id, 0) # Loop over the lambdas for i in range(0, n_l): # Compute the normal of I - lambda F (= normal of F) n_theta_star = np.zeros((n_params, )) if params_in_vector: parameter_map = problem.getParameter(0) parameter = Tpetra.Vector(parameter_map, dtype="d") for j in range(0, n_params): parameter[j] = theta_star[i, j] problem.setParameter(0, parameter) else: for k in range(0, n_params): parameter_map = problem.getParameterMap(k) parameter = Tpetra.Vector(parameter_map, dtype="d") parameter[0] = theta_star[i, k] problem.setParameter(k, parameter) problem.performSolve() if params_in_vector: n_theta_star = -problem.getSensitivity(0, 0).getData(0) else: for k in range(0, n_params): n_theta_star[k] = -problem.getSensitivity(0, k).getData(0)[0] norm = np.linalg.norm(n_theta_star) n_theta_star /= norm # Loop over the samples for j in range(0, n_samples): vector_2 = samples_0[j, :] - theta_0 unit_vector_2 = vector_2 / np.linalg.norm(vector_2) dot_product = np.dot(n_theta_star, unit_vector_2) shifted_sample_angles = np.arccos(dot_product) sample = samples_0[j, :] + theta_star[i, :] - theta_0 if shifted_sample_angles < angle_1: current_F_above = True elif shifted_sample_angles > angle_2: current_F_above = False else: if params_in_vector: parameter_map = problem.getParameter(0) parameter = Tpetra.Vector(parameter_map, dtype="d") for j in range(0, n_params): parameter[j] = sample[j] problem.setParameter(0, parameter) else: for k in range(0, n_params): parameter_map = problem.getParameterMap(k) parameter = Tpetra.Vector(parameter_map, dtype="d") parameter[0] = sample[k] problem.setParameter(k, parameter) problem.performSolve() current_F_above = problem.getCumulativeResponseContribution( 0, F_id) > F_star[i] if current_F_above: P[i] += np.exp(-invC.dot(theta_star[i, :] - theta_0).dot(sample - theta_star[i, :])) P[i] = P_star[i] * P[i] / n_samples return P
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