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()
my_disp_y_worker = Epetra.Vector(my_worker_map)
my_force_x_worker = Epetra.Vector(my_worker_map)
my_force_y_worker = Epetra.Vector(my_worker_map)
#Temporary arrays
my_velocity_x = np.zeros_like(my_disp_x)
my_velocity_y = np.zeros_like(my_disp_y)
my_accel_x = np.zeros_like(my_disp_x)
my_accel_y = np.zeros_like(my_disp_y)
my_damage = np.zeros_like(my_x)
#Initialize output files
vector_variables = ['displacement']
scalar_variables = ['damage']
#Instantiate output file object
outfile = Ensight('output', vector_variables, scalar_variables, comm,
viz_path=VIZ_PATH)
#Print the temporary output arrays
if rank == 0:
print("Output variables requested:\n")
for item in vector_variables:
print(" " + item)
for item in scalar_variables:
print(" " + item)
print(" ")
#Find local nodes where boundary conditions should be applied
bc1_local_node_set = boundary_condition_set(BC1_POLYGON,zip(my_x.ravel(),my_y.ravel()),balanced_map)
bc2_local_node_set = boundary_condition_set(BC2_POLYGON,zip(my_x.ravel(),my_y.ravel()),balanced_map)
#Calculate a stable time step or use the user defined
if TIME_STEP == None:
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()
