def RunPostProc(self): """ Runs the post processing script. """ t0 = time.time() p = subprocess.Popen( "{0} viewer -noGUI {1}".format(self.abqlauncher, self.label + '_abqpostproc.py'), cwd = self.workdir,stdout = subprocess.PIPE, shell=True) trash = p.communicate() print trash[0] t1 = time.time() print '< Post Processed {0} in Abaqus: duration {1:.2f}s>'.format(self.label, t1 - t0) self.outputs = load(self.workdir + self.label + ".pckl")
def compute_C(E=1., nu=0.3, sy=0.01, abqlauncher='/opt/Abaqus/6.9/Commands/abaqus', workdir='workdir', name='indentation_axi_fancier', frames=50): ''' Computes the load prefactor C using Abaqus. Inputs: * E: sample's Young modulus. * nu: samples's Poisson's ratio * sy: sample's yield stress (von Mises yield criterion). * abqlauncher: absolute path to abaqus launcher. * wordir: path to working directory, can be relative. * name: name of simulation files. * frames: number of frames per step, increase if the simulation does not complete. Returns: * Load prefactor C (float) ''' import time, subprocess, os t0 = time.time() # Starting time recording path = workdir + '/' + name # Reading the INP target file f = open('indentation_axi_target.inp', 'r') inp = f.read() f.close() # Replace the targets in the file inp = inp.replace('#E', '{0}'.format(E)) inp = inp.replace('#NU', '{0}'.format(nu)) inp = inp.replace('#SY', '{0}'.format(sy)) inp = inp.replace('#FRAME', '{0}'.format(1. / frames)) # Creating a new inp file f = open(path + '.inp', 'w') f.write(inp) f.close() print 'Created INP file: {0}.inp'.format(path) # Then we run the simulation print 'Running simulation in Abaqus' p = subprocess.Popen( '{0} job={1} input={1}.inp interactive ask_delete=OFF'.format( abqlauncher, name), cwd=workdir, shell=True, stdout=subprocess.PIPE) trash = p.communicate() # Now we test run the post processing script print 'Post processing the simulation in Abaqus/Python' p = subprocess.Popen( [abqlauncher, 'viewer', 'noGUI=fancier_example_abq.py'], cwd='.', stdout=subprocess.PIPE) trash = p.communicate() # Getting back raw data data = load(workdir + '/' + name + '.pckl') # Post processing print 'Post processing the simulation in Python' if data['completed']: ref_node_label = data['ref_node_label'] force_hist = -data['RF2']['Node I_INDENTER.{0}'.format(ref_node_label)] disp_hist = -data['U2']['Node I_INDENTER.{0}'.format(ref_node_label)] trash, force_l = force_hist[ 0, 1].plotable() # Getting back force during loading trash, disp_l = disp_hist[ 0, 1].plotable() # Getting backdisplacement during loading trash, force_u = force_hist[2].plotable( ) # Getting back force during unloading trash, disp_u = disp_hist[2].plotable( ) # Getting backdisplacement during unloading C_factor = (force_hist[1] / disp_hist[1]**2).average() else: print 'Simulation aborted, probably because frame number is to low' C_factor = None t1 = time.time() print 'Time used: {0:.2e} s'.format(t1 - t0) return C_factor
def odb_postproc(workdir, name, iteration_count, H, n, E, nu, iteration_number, P10_test): import os from abapy.misc import load import matplotlib.pyplot as plt import numpy as np import pandas as pd from prettytable import PrettyTable strain_hardening_exponent = n # Extracting the raw data from the .pck1 file os.chdir(workdir) data = load(name + '.pckl') ref_node_label = data['ref_node_label'] force_hist = -data['RF2']['Node I_INDENTER.{0}'.format(ref_node_label)] disp_hist = -data['U2']['Node I_INDENTER.{0}'.format(ref_node_label)] # Getting back force & displacemt during loading and scaling units: displacement_loading = [1000*x for x in (disp_hist[0,0.5].toArray()[1])] force_loading = [1000*x for x in (force_hist[0,0.5].toArray()[1])] # Getting back force & displacemt during unloading and scaling units: disp_long = [1000*x for x in (disp_hist[1].toArray()[1])] force_long = [1000*x for x in (force_hist[1].toArray()[1])] # Trimming the trailing zeroes from the unloading dataset force_unloading = [i for n, i in enumerate(force_long) if i not in force_long[:n]] displacement_unloading = disp_long[:len(force_unloading)] # Parabolic Curve fit (E. Buckingham. Physical review, 4, 1914.) shows that the loading curve must be parabolic of the form P=C*h^2 Parray = force_loading h = displacement_loading hsquared = [x**2 for x in h] C_factor_array = np.divide(Parray[100:], hsquared[100:]) C_factor = np.mean(C_factor_array) disaplacement_loading_fit = displacement_loading force_loading_fit = C_factor*np.power(h,2) # Modify the loading curve to start at the same point at the curve fit: unload_dispstart = disaplacement_loading_fit[-1] Pmax = force_loading_fit[-1] if Pmax >= force_unloading[0]: force_unloading_mod = [Pmax]+force_unloading displacement_unloading_mod = [unload_dispstart]+displacement_unloading else: force_unloading_mod = np.minimum(force_unloading, Pmax) displacement_unloading_mod = displacement_unloading # Extracting all properties of interest for table ITERATION_Pmax = np.amax(force_loading) z = -0.001*np.concatenate([force_loading, force_unloading]) z = z[::-1] z = z.astype(np.float) z = -1000*z mZ = np.amax(z) mZ_index = np.where(z == mZ) iteration_force_unloading = z[:mZ_index[0][0]] w = -0.001*np.concatenate([displacement_loading, displacement_unloading]) w = w[::-1] w = w.astype(np.float) w = -1000*w iteration_displacment_unloading = w[:mZ_index[0][0]] if P10_test == 0: P10 = 0.1*ITERATION_Pmax point_type = "test" elif P10_test == 1: P10 = 0.1*ITERATION_Pmax #P10 = P10_test point_type = "train" else: print("ERROR in calculation of P10 location") hf1 = np.interp(1*P10, iteration_force_unloading, iteration_displacment_unloading) hf2 = np.interp(2*P10, iteration_force_unloading, iteration_displacment_unloading) hf3 = np.interp(3*P10, iteration_force_unloading, iteration_displacment_unloading) hf4 = np.interp(4*P10, iteration_force_unloading, iteration_displacment_unloading) hf5 = np.interp(5*P10, iteration_force_unloading, iteration_displacment_unloading) hf6 = np.interp(6*P10, iteration_force_unloading, iteration_displacment_unloading) hf7 = np.interp(7*P10, iteration_force_unloading, iteration_displacment_unloading) hf8 = np.interp(8*P10, iteration_force_unloading, iteration_displacment_unloading) hf9 = np.interp(9*P10, iteration_force_unloading, iteration_displacment_unloading) # Creation of dataframe row: df = pd.DataFrame([[ point_type, iteration_number, round(float(H), 10), round(float(strain_hardening_exponent), 10), E, nu, round(ITERATION_Pmax, 10), round(hf1, 10), round(hf2, 10), round(hf3, 10), round(hf4, 10), round(hf5, 10), round(hf6, 10), round(hf7, 10), round(hf8, 10), round(hf9, 10), round(P10, 10), round(C_factor, 10)]], columns = [ 'point_type', 'i', 'H', 'n', 'E', 'nu', 'Pmax', 'hf1', 'hf2', 'hf3', 'hf4', 'hf5', 'hf6', 'hf7', 'hf8', 'hf9', 'P10', 'C']) return df
elType = elType, abqlauncher = abqlauncher, cpus = cpus, is_3D = is_3D, compart = compart) # SIMULATION m.MakeMesh() if run_sim: m.MakeInp() m.Run() m.PostProc() # SOME PLOTS mesh = m.mesh outputs = load(workdir + label + '.pckl') if outputs['completed']: # Fields if export_fields == True : def field_func(outputs, step): """ A function that defines the scalar field you want to plot """ return outputs['field']['S'][step].vonmises() def plot_mesh(ax, mesh, outputs, step, field_func =None, zone = 'upper right', cbar = True, cbar_label = 'Z', cbar_orientation = 'horizontal', disp = True): """ A function that plots the deformed mesh with a given field on it. """ mesh2 = copy.deepcopy(mesh)
from abapy.misc import load import numpy as np from matplotlib import pyplot as plt # In this case, a 3D FEM simulation has beed performed and the results are stored in the file ``ContactData_berk.pckl``. # See ``Get_ContactData`` to understand how this data has been extracted from an Abaqus odb file. out = load('ContactData_berk.pckl') cd0 = out[1][-1] # First step data: loading cd1 = out[2][-1] # Second step data: unloading hmax = -cd0.min_altitude() p2, p1, p0 = cd0.contact_contour() x0, y0 = p0[:, 0], p0[:, 1] x1, y1 = p1[:, 0], p1[:, 1] x2, y2 = p2[:, 0], p2[:, 1] plt.figure() plt.clf() plt.title('Contact area contour') plt.plot(x0, y0, label='upper bound') plt.plot(x1, y1, label='middle') plt.plot(x2, y2, label='lower bound') plt.grid() plt.legend() plt.show()
from abapy.misc import load from matplotlib import pyplot as plt import matplotlib.gridspec as gridspec from matplotlib import mpl import numpy as np path_to_odb = '../../../../testing/' title0 = 'title0' title1 = 'title1' title2 = 'title2' N_levels = 10 # Number os isovalues levels = np.linspace(0., 0.3, N_levels) S = load(path_to_odb + 'indentation_S.pckl') mesh0 = load(path_to_odb + 'indentation_mesh.pckl') #mesh0 = mesh0['core_1'] point = (0., 0., 0.) normal = (1., 0., 0.) mesh1 = mesh0.apply_reflection(normal=normal, point=point) S = S[mesh0.nodes.labels.tolist()] x0, y0, z0, tri0 = mesh0.dump2triplot() xe0, ye0, ze0 = mesh0.get_edges() xb0, yb0, zb0 = mesh0.get_border() xlim0, ylim0, zlim0 = mesh0.nodes.boundingBox() x1, y1, z1, tri1 = mesh1.dump2triplot() xe1, ye1, ze1 = mesh1.get_edges() xb1, yb1, zb1 = mesh1.get_border() xlim2, ylim1, zlim1 = mesh1.nodes.boundingBox() field0 = S.get_component(12) # What to plot ? field1 = field0 # What other field to plot ?
from abapy.misc import load import numpy as np from matplotlib import pyplot as plt # In this case, a 3D FEM simulation has beed performed and the results are stored in the file ``ContactData_berk.pckl``. See ``Get_ContactData`` to understand how this data has been extracted from an Abaqus odb file. out = load('ContactData_berk.pckl') cd0 = out[1][-1] # First step data: loading cd1 = out[2][-1] # Second step data: unloading hmax = -cd0.min_altitude() # First let's map altitude and pressure on cartesian grids. x = np.linspace(-2., 2., 256) X, Y = np.meshgrid(x, x) Alt0, Press0 = cd0.interpolate(X, Y, method ='linear') Alt1, Press1 = cd1.interpolate(X, Y, method ='linear') Alt0 = Alt0 / hmax Alt1 = Alt1 / hmax # Now we wan to get some sections of the imprint s = np.linspace(0., 2., 256) s = np.append((-s)[::-1], s) theta0 = np.radians(0.01) theta1 = np.radians(15.) xs0 = np.cos(theta0) * s ys0 = np.sin(theta0) * s xs1 = np.cos(theta1) * s ys1 = np.sin(theta1) * s
# PYTHON POST PROCESSING SCRIPT # Run using python # Packages from abapy.misc import load import matplotlib.pyplot as plt import numpy as np # Setting up some pathes workdir = 'workdir' name = 'indentation_axi' # Getting back raw data data = load(workdir + '/' + name + '.pckl') # Post processing ref_node_label = data['ref_node_label'] force_hist = -data['RF2']['Node I_INDENTER.{0}'.format(ref_node_label)] disp_hist = -data['U2']['Node I_INDENTER.{0}'.format(ref_node_label)] # Getting back force during loading time, force_l = force_hist[0, 1].plotable() # Getting backdisplacement during loading time, disp_l = disp_hist[0, 1].plotable() # Getting back force during unloading time, force_u = force_hist[2].plotable() # Getting backdisplacement during unloading time, disp_u = disp_hist[2].plotable() # Dimensional analysis (E. Buckingham. Physical review, 4, 1914.) shows that the loading curve must be parabolic, let's build a parabolic fit
# PYTHON POST PROCESSING SCRIPT # Run using python # Packages from abapy.misc import load import matplotlib.pyplot as plt import numpy as np # Setting up some pathes workdir = 'workdir' name = 'indentation_axi' # Getting back raw data data = load(workdir + '/' + name + '.pckl') # Post processing ref_node_label = data['ref_node_label'] force_hist = -data['RF2']['Node I_INDENTER.{0}'.format(ref_node_label)] disp_hist = -data['U2']['Node I_INDENTER.{0}'.format(ref_node_label)] time, force_l = force_hist[0,1].plotable() # Getting back force during loading time, disp_l = disp_hist[0,1].plotable() # Getting backdisplacement during loading time, force_u = force_hist[2].plotable() # Getting back force during unloading time, disp_u = disp_hist[2].plotable() # Getting backdisplacement during unloading # Dimensional analysis (E. Buckingham. Physical review, 4, 1914.) shows that the loading curve must be parabolic, let's build a parabolic fit C_factor = (force_hist[1] / disp_hist[1]**2).average() disp_fit = np.array(disp_hist[0,1].toArray()[1]) force_fit = C_factor * disp_fit**2
def compute_C(E = 1. , nu = 0.3, sy = 0.01, abqlauncher = '/opt/Abaqus/6.9/Commands/abaqus', workdir = 'workdir', name = 'indentation_axi_fancier', frames = 50): ''' Computes the load prefactor C using Abaqus. Inputs: * E: sample's Young modulus. * nu: samples's Poisson's ratio * sy: sample's yield stress (von Mises yield criterion). * abqlauncher: absolute path to abaqus launcher. * wordir: path to working directory, can be relative. * name: name of simulation files. * frames: number of frames per step, increase if the simulation does not complete. Returns: * Load prefactor C (float) ''' import time, subprocess, os t0 = time.time() # Starting time recording path = workdir + '/' + name # Reading the INP target file f = open('indentation_axi_target.inp', 'r') inp = f.read() f.close() # Replace the targets in the file inp = inp.replace('#E', '{0}'.format(E)) inp = inp.replace('#NU', '{0}'.format(nu)) inp = inp.replace('#SY', '{0}'.format(sy)) inp = inp.replace('#FRAME', '{0}'.format(1./frames)) # Creating a new inp file f = open(path + '.inp', 'w') f.write(inp) f.close() print 'Created INP file: {0}.inp'.format(path) # Then we run the simulation print 'Running simulation in Abaqus' p = subprocess.Popen( '{0} job={1} input={1}.inp interactive ask_delete=OFF'.format(abqlauncher, name), cwd = workdir, shell=True, stdout = subprocess.PIPE) trash = p.communicate() # Now we test run the post processing script print 'Post processing the simulation in Abaqus/Python' p = subprocess.Popen( [abqlauncher, 'viewer', 'noGUI=fancier_example_abq.py'], cwd = '.',stdout = subprocess.PIPE ) trash = p.communicate() # Getting back raw data data = load(workdir + '/' + name + '.pckl') # Post processing print 'Post processing the simulation in Python' if data['completed']: ref_node_label = data['ref_node_label'] force_hist = -data['RF2']['Node I_INDENTER.{0}'.format(ref_node_label)] disp_hist = -data['U2']['Node I_INDENTER.{0}'.format(ref_node_label)] trash, force_l = force_hist[0,1].plotable() # Getting back force during loading trash, disp_l = disp_hist[0,1].plotable() # Getting backdisplacement during loading trash, force_u = force_hist[2].plotable() # Getting back force during unloading trash, disp_u = disp_hist[2].plotable() # Getting backdisplacement during unloading C_factor = (force_hist[1] / disp_hist[1]**2).average() else: print 'Simulation aborted, probably because frame number is to low' C_factor = None t1 = time.time() print 'Time used: {0:.2e} s'.format(t1-t0) return C_factor
from abapy.misc import load from matplotlib import pyplot as plt import matplotlib.gridspec as gridspec from matplotlib import mpl import numpy as np path_to_odb = '../../../../testing/' title0 = 'title0' title1 = 'title1' title2 = 'title2' N_levels = 10 # Number os isovalues levels = np.linspace(0., 0.3, N_levels) S = load(path_to_odb + 'indentation_S.pckl') mesh0 = load(path_to_odb + 'indentation_mesh.pckl') #mesh0 = mesh0['core_1'] point = (0., 0., 0.) normal = (1., 0., 0.) mesh1 = mesh0.apply_reflection(normal = normal, point = point) S = S[mesh0.nodes.labels.tolist()] x0, y0, z0, tri0 = mesh0.dump2triplot() xe0, ye0, ze0 = mesh0.get_edges() xb0, yb0, zb0 = mesh0.get_border() xlim0, ylim0, zlim0 = mesh0.nodes.boundingBox() x1, y1, z1, tri1 = mesh1.dump2triplot() xe1, ye1, ze1 = mesh1.get_edges() xb1, yb1, zb1 = mesh1.get_border() xlim2, ylim1, zlim1 = mesh1.nodes.boundingBox() field0 = S.get_component(12) # What to plot ?