def main(): #Create the PD object nodes=10000 problem = PD(nodes,10.0) comm = problem.comm #Define the initial guess init_ps_guess = problem.get_ps_init() ps_graph = problem.get_xy_balanced_neighborhood_graph() p_local_indices = problem.p_local_indices s_local_indices = problem.s_local_indices time_stepping = problem.time_stepping s_local_overlap_indices = problem.s_local_overlap_indices problem.saturation_n = problem.ps_overlap[s_local_overlap_indices] ps_overlap_importer = problem.get_xy_overlap_importer() ps_overlap_map = problem.get_xy_overlap_map() my_ps_overlap = problem.my_ps_overlap #Initialize and change some NOX settings nl_params = NOX.Epetra.defaultNonlinearParameters(problem.comm,2) nl_params["Line Search"]["Method"] = "Polynomial" ls_params = nl_params["Linear Solver"] ls_params["Preconditioner Operator"] = "Use Jacobian" ls_params["Preconditioner"] = "New Ifpack" #Establish parameters for ParaView Visualization VIZ_PATH='/Applications/paraview.app/Contents/MacOS/paraview' vector_variables = ['displacement'] scalar_variables = ['pressure','saturation'] outfile = Ensight('output',vector_variables, scalar_variables, problem.comm, viz_path=VIZ_PATH) end_range = 5 ############## Reading simulations results from previous run ########## for j in range(problem.size): if problem.rank == j: pre_sol = np.load('sol_out'+'-'+str(j)+'.npy') pre_sat = np.load('sat_out'+'-'+str(j)+'.npy') init_ps_guess[p_local_indices]=pre_sol[p_local_indices] init_ps_guess[s_local_indices]= pre_sol[s_local_indices] problem.saturation_n = pre_sat for i in range(end_range): print i """ USE Finite Difference Coloring to compute jacobian. Distinction is made between fdc and solver, as fdc handles export to overlap automatically """ problem.jac_comp = True fdc_pressure = NOX.Epetra.FiniteDifferenceColoring( nl_params, problem, init_ps_guess, ps_graph, False, False) fdc_pressure.computeJacobian(init_ps_guess) jacobian = fdc_pressure.getUnderlyingMatrix() jacobian.FillComplete() problem.jac_comp = False #Create NOX solver object, solve for pressure and saturation solver = NOX.Epetra.defaultSolver(init_ps_guess, problem, problem, jacobian,nlParams = nl_params, maxIters=500, wAbsTol=None, wRelTol=None, updateTol=None, absTol = 5.0e-5, relTol = None) solveStatus = solver.solve() finalGroup = solver.getSolutionGroup() solution = finalGroup.getX() #resetting the initial conditions init_ps_guess[p_local_indices]=solution[p_local_indices] #start from the initial guess of zero init_ps_guess[s_local_indices]= solution[s_local_indices] #saturation_n = solution[s_local_indices] my_ps_overlap.Import( solution, ps_overlap_importer, Epetra.Insert ) problem.saturation_n = my_ps_overlap[s_local_overlap_indices] #plotting the results sol_pressure = solution[p_local_indices] sol_saturation = solution[s_local_indices] ################ Write Date to Ensight Outfile ################# time = i * problem.time_stepping outfile.write_geometry_file_time_step(problem.my_x, problem.my_y) outfile.write_vector_variable_time_step('displacement', [0.0*problem.my_x,0.0*problem.my_y], time) outfile.write_scalar_variable_time_step('saturation', sol_saturation, time) outfile.write_scalar_variable_time_step('pressure', sol_pressure, time) outfile.append_time_step(time) outfile.write_case_file(comm) ################################################################ ############### Saving results to be used for future runs ############## for i in range(problem.size): if problem.rank == i: np.save('sol_out'+'-'+str(i),solution) np.save('sat_out'+'-'+str(i),problem.saturation_n) outfile.finalize()
#time_step = compute_stable_time_step(my_x, my_y, my_disp_x, my_disp_y, #my_families, my_ref_mag_state, my_weighted_volume, my_volumes, #my_number_of_nodes, BULK_MODULUS,RHO) #Dump plots if iteration % PLOT_DUMP_FREQ == 0 or iteration == (MAX_ITER-1): if VERBOSE and rank == 0: print "Writing plot file..." #Compute the damage my_damage = 1.0 - ma.mean(my_influence_state / my_ref_influence_state,axis=1) outfile.write_geometry_file_time_step(my_x, my_y) outfile.write_vector_variable_time_step('displacement', [my_disp_x,my_disp_y], time) outfile.write_scalar_variable_time_step('damage', my_damage, time) outfile.append_time_step(time) outfile.write_case_file(comm) #Update the progress bar if not VERBOSE and rank == 0: progress.update(iteration + 1) #Finalize plotfiles outfile.finalize() #Wrap up the progress bar printing if not VERBOSE and rank == 0: progress.finish()
def main(): #Create the PD object i = 0 nodes = 10 problem = PD(nodes, 10.0) problem.nodes_number = nodes pressure_const = problem.pressure_const comm = problem.comm #Define the initial guess field_graph = problem.get_balanced_field_graph() init_vel_guess = Epetra.Vector(problem.get_balanced_field_map()) ux_local_indices = problem.ux_local_indices uy_local_indices = problem.uy_local_indices time_stepping = problem.time_stepping uy_overlap_indices = problem.uy_overlap_indices ux_overlap_indices = problem.ux_overlap_indices #problem.velocity_y_n = problem.vel_overlap[uy_overlap_indices] neighborhood_graph = problem.get_balanced_neighborhood_graph() num_owned = 2.0 * neighborhood_graph.NumMyRows() #neighbors = problem.my_neighbors #node_number = neighbors.shape[0] #neighb_number = neighbors.shape[1] #size_upscaler = (node_number , neighb_number) #problem.up_scaler = np.ones(size_upscaler) horizon = problem.horizon #volumes = problem.my_volumes #size = ref_mag_state.shape #one = np.ones(size) #omega =one #problem.omega = omega #linear = 0 init_guess = problem.init_guess vel_overlap_importer = problem.get_field_overlap_importer() field_overlap_map = problem.get_field_overlap_map() #Initialize and change some NOX settings nl_params = NOX.Epetra.defaultNonlinearParameters(problem.comm, 2) nl_params["Line Search"]["Method"] = "Polynomial" ls_params = nl_params["Linear Solver"] ls_params["Preconditioner Operator"] = "Use Jacobian" ls_params["Preconditioner"] = "New Ifpack" #Establish parameters for ParaView Visualization VIZ_PATH = '/Applications/paraview.app/Contents/MacOS/paraview' vector_variables = ['displacement'] scalar_variables = ['velocity_x', 'velocity_y'] outfile = Ensight('output', vector_variables, scalar_variables, problem.comm, viz_path=VIZ_PATH) problem.velocity_y_n = problem.my_field_overlap[:-1:2] problem.velocity_x_n = problem.my_field_overlap[1::2] problem.current_solution = problem.my_field_overlap end_range = 1000 for i in range(end_range): print(i) problem.jac_comp = True fdc_velocity = NOX.Epetra.FiniteDifferenceColoring( nl_params, problem, init_guess, field_graph, False, False) fdc_velocity.computeJacobian(init_guess) jacobian = fdc_velocity.getUnderlyingMatrix() jacobian.FillComplete() problem.jac_comp = False #Create NOX solver object, solve for velocity_x and velocity_y if i < 1: solver = NOX.Epetra.defaultSolver(init_guess, problem, problem, jacobian, nlParams=nl_params, maxIters=10, wAbsTol=None, wRelTol=None, updateTol=None, absTol=8.0e-7, relTol=None) else: solver = NOX.Epetra.defaultSolver(init_guess, problem, problem, jacobian, nlParams=nl_params, maxIters=100, wAbsTol=None, wRelTol=None, updateTol=None, absTol=1.0e-6, relTol=None) solveStatus = solver.solve() finalGroup = solver.getSolutionGroup() solution = finalGroup.getX() #problem.current_solution = solution #resetting the initial conditions init_vel_guess[ux_local_indices] = solution[ux_local_indices] #start from the initial guess of zero init_vel_guess[uy_local_indices] = solution[uy_local_indices] #velocity_y_n = solution[uy_local_indices] problem.my_field_overlap.Import(solution, vel_overlap_importer, Epetra.Insert) problem.velocity_y_n = problem.my_field_overlap[:-1:2] problem.velocity_x_n = problem.my_field_overlap[1::2] #plotting the results sol_velocity_x = solution[ux_local_indices] #print (uy_local_indices) #ttt.sleep(1) sol_velocity_y = solution[uy_local_indices] velocity_x = problem.velocity_x_n velocity_y = problem.velocity_y_n init_guess = solution x_out = comm.GatherAll(problem.my_x).flatten() y_out = comm.GatherAll(problem.my_y).flatten() v_x = comm.GatherAll(sol_velocity_x).flatten() v_y = comm.GatherAll(sol_velocity_y).flatten() #velocity_total = (v_x **2 + v_y **2 )** 0.5 #v_out = comm.GatherAll(velocity_total).flatten() #if i%100==0: # print ("saving outputs") # if problem.rank==0: # plt.scatter(x_out,y_out,c=v_out) # file_name= "pressure"+"_"+str(i) # plt.savefig(file_name+".png") ################ Write Date to Ensight Outfile ################# time = i * problem.time_stepping outfile.write_geometry_file_time_step(problem.my_x, problem.my_y) outfile.write_vector_variable_time_step( 'displacement', [0.0 * problem.my_x, 0.0 * problem.my_y], time) outfile.write_scalar_variable_time_step('velocity_y', sol_velocity_y, time) outfile.write_scalar_variable_time_step('velocity_x', sol_velocity_x, time) outfile.append_time_step(time) outfile.write_case_file(comm) ################################################################ print("wrote ensight files") outfile.finalize()