def test_misorientation_angle(self): o1 = Orientation.from_euler((0., 0., 0.)) o2 = Orientation.from_euler((60., 0., 0.)) self.assertAlmostEqual( 180 / np.pi * o1.disorientation(o2, crystal_structure=Symmetry.triclinic)[0], 60) self.assertAlmostEqual( 180 / np.pi * o1.disorientation(o2, crystal_structure=Symmetry.cubic)[0], 30)
def test_IPF_color(self): o1 = Orientation.cube() # 001 // Z o2 = Orientation.from_euler([35.264, 45., 0.]) # 011 // Z o3 = Orientation.from_euler([0., 54.736, 45.]) # 111 // Z orientations = [o1, o2, o3] targets = [np.array([1., 0., 0.]), np.array([0., 1., 0.]), np.array([0., 0., 1.])] for case in range(2): o = orientations[case] print(o) target = targets[case] col = o.get_ipf_colour() print(col) for i in range(3): self.assertAlmostEqual(col[i], target[i])
def test_misorientation_matrix(self): for test_euler in self.test_eulers: o = Orientation.from_euler(test_euler) g = o.orientation_matrix() delta = np.dot(g, g.T) self.assertEqual( Orientation.misorientation_angle_from_delta(delta), 0.0)
def test_indexation(self): """Verify indexing solution from a known Laue pattern.""" euler_angles = (191.9, 69.9, 138.9) # degrees, /!\ not in fz orientation = Orientation.from_euler(euler_angles) # list of plane normals, obtained from the detector image hkl_normals = np.array( [[0.11066932863248755, 0.8110118739480003, 0.5744667440465002], [0.10259261224575777, 0.36808036454584847, -0.9241166599236196], [0.12497400210731163, 0.38160000643453934, 0.9158400154428944], [0.21941448008210823, 0.5527234994434788, -0.8039614537359691], [0.10188581412204267, -0.17110594738052967, -0.9799704259066699], [0.10832511255237177, -0.19018912890874434, 0.975752922227471], [0.13621754927492466, -0.8942526135605741, 0.4263297343719016], [0.04704092862601945, -0.45245473334950004, -0.8905458243704446]]) miller_indices = [(3, -5, 0), (5, 4, -2), (2, -5, -1), (3, -4, -5), (2, -2, 3), (-3, 4, -3), (3, -4, 3), (3, -2, 3), (-5, 5, -1), (5, -5, 1)] hkl_planes = [] for indices in miller_indices: (h, k, l) = indices hkl_planes.append(HklPlane(h, k, l, self.ni)) solutions = index(hkl_normals, hkl_planes, tol_angle=0.5, tol_disorientation=3.0) final_orientation = Orientation(solutions[0]) angle, ax1, ax2 = final_orientation.disorientation( orientation, crystal_structure=Symmetry.cubic) self.assertLess(angle * 180 / np.pi, 1.0)
def test_OrientationMatrix2Euler(self): for test_euler in self.test_eulers: o = Orientation.from_euler(test_euler) g = o.orientation_matrix() calc_euler = Orientation.OrientationMatrix2Euler(g) calc_euler2 = Orientation.OrientationMatrix2EulerSF(g) for i in range(3): self.assertAlmostEquals(calc_euler[i], test_euler[i])
def setUp(self): print('testing the Microstructure class') self.test_eulers = [(45., 45, 0.), (10., 20, 30.), (191.9, 69.9, 138.9)] self.micro = Microstructure() self.micro.name = 'test' for i in range(len(self.test_eulers)): euler = self.test_eulers[i] self.micro.grains.append(Grain(i + 1, Orientation.from_euler(euler)))
def test_move_to_fundamental_zone(self): o = Orientation.from_euler([191.9, 69.9, 138.9]) # move rotation to cubic FZ o_fz = o.move_to_FZ(symmetry=Symmetry.cubic, verbose=False) # double check new orientation in is the FZ self.assertTrue(o_fz.inFZ(symmetry=Symmetry.cubic)) # verify new Euler angle values val = np.array([303.402, 44.955, 60.896]) for i in range(3): self.assertAlmostEqual(o_fz.euler[i], val[i], 3)
def plot_euler(phi1, Phi, phi2, **kwargs): '''Directly plot a pole figure for a single orientation given its three Euler angles. :: PoleFigure.plot_euler(10, 20, 30) :param float phi1: first Euler angle (in degree). :param float Phi: second Euler angle (in degree). :param float phi2: third Euler angle (in degree). ''' PoleFigure.plot(Orientation.from_euler(np.array([phi1, Phi, phi2])), **kwargs)
def test_angle_zone(self): """Verify the angle between X and a particular zone axis expressed in (X, Y, Z), given a crystal orientation.""" # euler angles in degrees phi1 = 89.4 phi = 92.0 phi2 = 86.8 orientation = Orientation.from_euler([phi1, phi, phi2]) gt = orientation.orientation_matrix().transpose() # zone axis uvw = HklDirection(1, 0, 5, self.ni) ZA = gt.dot(uvw.direction()) if ZA[0] < 0: ZA *= -1 # make sur the ZA vector is going forward psi0 = np.arccos(np.dot(ZA, np.array([1., 0., 0.]))) self.assertAlmostEqual(psi0 * 180 / np.pi, 9.2922, 3)
def test_grain_geometry(self): m = Microstructure(name='test', autodelete=True) grain_map = np.ones((8, 8, 8), dtype=np.uint8) m.set_grain_map(grain_map, voxel_size=1.0) grain = m.grains.row grain['idnumber'] = 1 grain['orientation'] = Orientation.from_euler([10, 20, 30]).rod grain.append() m.grains.flush() m.recompute_grain_bounding_boxes() m.recompute_grain_centers() m.recompute_grain_volumes() bb1 = m.compute_grain_bounding_box(gid=1) self.assertEqual(bb1, ((0, 8), (0, 8), (0, 8))) c1 = m.compute_grain_center(gid=1).tolist() self.assertEqual(c1, [0., 0., 0.]) self.assertEqual(m.compute_grain_volume(gid=1), 512)
def test_dct_omega_angles(self): # test with a BCC Titanium lattice lambda_keV = 30 lambda_nm = 1.2398 / lambda_keV a = 0.3306 # lattice parameter in nm Ti_bcc = Lattice.cubic(a) (h, k, l) = (0, 1, 1) hkl = HklPlane(h, k, l, lattice=Ti_bcc) o = Orientation.from_euler((103.517, 42.911, 266.452)) theta = hkl.bragg_angle(lambda_keV, verbose=False) gt = o.orientation_matrix( ) # our B (here called gt) corresponds to g^{-1} in Poulsen 2004 A = h * gt[0, 0] + k * gt[1, 0] + l * gt[2, 0] B = -h * gt[0, 1] - k * gt[1, 1] - l * gt[2, 1] C = -2 * a * np.sin( theta )**2 / lambda_nm # the minus sign comes from the main equation Delta = 4 * (A**2 + B**2 - C**2) self.assertEqual(Delta > 0, True) t1 = (B - 0.5 * np.sqrt(Delta)) / (A + C) t2 = (B + 0.5 * np.sqrt(Delta)) / (A + C) # verifying A cos(w) + B sin(w) = C:' for t in (t1, t2): x = A * (1 - t**2) / (1 + t**2) + B * 2 * t / (1 + t**2) self.assertAlmostEqual(x, C, 2) # verifying (A + C) * t**2 - 2 * B * t + (C - A) = 0' for t in (t1, t2): self.assertAlmostEqual((A + C) * t**2 - 2 * B * t + (C - A), 0.0, 2) (w1, w2) = o.dct_omega_angles(hkl, lambda_keV, verbose=False) self.assertAlmostEqual(w1, 196.709, 2) self.assertAlmostEqual(w2, 28.334, 2) # test with an FCC Aluminium-Lithium lattice a = 0.40495 # lattice parameter in nm Al_fcc = Lattice.face_centered_cubic(a) hkl = HklPlane(-1, 1, 1, Al_fcc) o = Orientation.from_rodrigues([0.0499, -0.3048, 0.1040]) w1, w2 = o.dct_omega_angles(hkl, 40, verbose=False) self.assertAlmostEqual(w1, 109.2, 1) self.assertAlmostEqual(w2, 296.9, 1)
def load(file_path='experiment.txt'): with open(file_path, 'r') as f: dict_exp = json.load(f) name = dict_exp['Sample']['Name'] sample = Sample(name=name) sample.data_dir = dict_exp['Sample']['Data Dir'] sample.set_position(dict_exp['Sample']['Position']) if 'Geometry' in dict_exp['Sample']: sample_geo = ObjectGeometry() sample_geo.set_type(dict_exp['Sample']['Geometry']['Type']) sample.set_geometry(sample_geo) if 'Material' in dict_exp['Sample']: a, b, c = dict_exp['Sample']['Material']['Lengths'] alpha, beta, gamma = dict_exp['Sample']['Material']['Angles'] centering = dict_exp['Sample']['Material']['Centering'] symmetry = Symmetry.from_string( dict_exp['Sample']['Material']['Symmetry']) material = Lattice.from_parameters(a, b, c, alpha, beta, gamma, centering=centering, symmetry=symmetry) sample.set_material(material) if 'Microstructure' in dict_exp['Sample']: micro = Microstructure( name=dict_exp['Sample']['Microstructure']['Name'], file_path=os.path.dirname(file_path)) # crystal lattice if 'Lattice' in dict_exp['Sample']['Microstructure']: a, b, c = dict_exp['Sample']['Microstructure']['Lattice'][ 'Lengths'] alpha, beta, gamma = dict_exp['Sample']['Microstructure'][ 'Lattice']['Angles'] centering = dict_exp['Sample']['Microstructure']['Lattice'][ 'Centering'] symmetry = Symmetry.from_string( dict_exp['Sample']['Microstructure']['Lattice'] ['Symmetry']) lattice = Lattice.from_parameters(a, b, c, alpha, beta, gamma, centering=centering, symmetry=symmetry) micro.set_lattice(lattice) grain = micro.grains.row for i in range(len( dict_exp['Sample']['Microstructure']['Grains'])): dict_grain = dict_exp['Sample']['Microstructure']['Grains'][i] grain['idnumber'] = int(dict_grain['Id']) euler = dict_grain['Orientation']['Euler Angles (degrees)'] grain['orientation'] = Orientation.from_euler(euler).rod grain['center'] = np.array(dict_grain['Position']) grain['volume'] = dict_grain['Volume'] # if 'hkl_planes' in dict_grain: # grain.hkl_planes = dict_grain['hkl_planes'] grain.append() micro.grains.flush() sample.set_microstructure(micro) sample.microstructure.autodelete = True # lazy behaviour, we load only the grain_ids path, the actual array is loaded in memory if needed sample.grain_ids_path = dict_exp['Sample']['Grain Ids Path'] exp = Experiment() exp.set_sample(sample) source = XraySource() source.set_position(dict_exp['Source']['Position']) if 'Min Energy (keV)' in dict_exp['Source']: source.set_min_energy(dict_exp['Source']['Min Energy (keV)']) if 'Max Energy (keV)' in dict_exp['Source']: source.set_max_energy(dict_exp['Source']['Max Energy (keV)']) exp.set_source(source) for i in range(len(dict_exp['Detectors'])): dict_det = dict_exp['Detectors'][i] if dict_det['Class'] == 'Detector2d': det = Detector2d(size=dict_det['Size (pixels)']) det.ref_pos = dict_det['Reference Position (mm)'] if dict_det['Class'] == 'RegArrayDetector2d': det = RegArrayDetector2d(size=dict_det['Size (pixels)']) det.pixel_size = dict_det['Pixel Size (mm)'] det.ref_pos = dict_det['Reference Position (mm)'] if 'Min Energy (keV)' in dict_exp['Detectors']: det.tilt = dict_det['Tilts (deg)'] if 'Binning' in dict_det: det.set_binning(dict_det['Binning']) det.u_dir = np.array(dict_det['u_dir']) det.v_dir = np.array(dict_det['v_dir']) det.w_dir = np.array(dict_det['w_dir']) exp.add_detector(det) return exp
import numpy as np import vtk from pymicro.view.vtk_utils import lattice_3d, unit_arrow_3d, axes_actor, text, setup_camera, \ apply_orientation_to_actor, set_opacity from pymicro.view.scene3d import Scene3D from pymicro.crystal.microstructure import Orientation from pymicro.crystal.lattice import Lattice, HklDirection s3d = Scene3D(display=False, ren_size=(600, 600)) s3d.name = 'euler_angles_and_orientation_matrix' euler_angles = np.array([142.8, 32.0, 214.4]) (phi1, Phi, phi2) = euler_angles orientation = Orientation.from_euler(euler_angles) g = orientation.orientation_matrix() lab_frame = axes_actor(1, fontSize=50) lab_frame.SetCylinderRadius(0.02) s3d.add(lab_frame) crystal_frame = axes_actor(0.6, fontSize=50, axisLabels=None) crystal_frame.SetCylinderRadius(0.05) collection = vtk.vtkPropCollection() crystal_frame.GetActors(collection) for i in range(collection.GetNumberOfItems()): collection.GetItemAsObject(i).GetProperty().SetColor(0.0, 0.0, 0.0) apply_orientation_to_actor(crystal_frame, orientation) s3d.add(crystal_frame) a = 1.0 l = Lattice.face_centered_cubic(a) fcc_lattice = lattice_3d(l, crystal_orientation=orientation)
from pymicro.view.vtk_utils import * from pymicro.view.vtk_anim import * from pymicro.view.scene3d import Scene3D from pymicro.crystal.microstructure import Orientation from pymicro.crystal.lattice import Lattice s3d = Scene3D(display=True, ren_size=(600, 600)) euler_angles = np.array([142.8, 32.0, 214.4]) (phi1, Phi, phi2) = euler_angles orientation = Orientation.from_euler(euler_angles) scene = vtkAnimationScene(s3d.get_renderer(), s3d.renWin.GetSize()) scene.save_image = True scene.timer_incr = 1 scene.timer_end = 179 scene.verbose = False scene.prefix = 'euler_angles_anim' lab_frame = axes_actor(1, fontSize=50) lab_frame.SetCylinderRadius(0.02) s3d.add(lab_frame) crystal_frame = axes_actor(0.6, fontSize=50, axisLabels=None) crystal_frame.SetCylinderRadius(0.04) collection = vtk.vtkPropCollection() crystal_frame.GetActors(collection) for i in range(collection.GetNumberOfItems()): collection.GetItemAsObject(i).GetProperty().SetColor(0.0, 0.0, 0.0) crystal_frame.SetVisibility(0) s3d.add(crystal_frame)
def test_MaxSchimdFactor(self): o = Orientation.from_euler([0., 0., 0.]) oct_ss = SlipSystem.get_slip_systems(plane_type='111') self.assertAlmostEqual( max(o.compute_all_schmid_factors(oct_ss, verbose=True)), 0.4082, 4)
def test_SchimdFactor(self): o = Orientation.from_euler([0., 0., 0.]) ss = SlipSystem(HklPlane(1, 1, 1), HklDirection(0, 1, -1)) self.assertAlmostEqual(o.schmid_factor(ss), 0.4082, 4)
import vtk, numpy, os from pymicro.crystal.microstructure import Orientation, Grain from pymicro.crystal.texture import PoleFigure from pymicro.view.scene3d import Scene3D from pymicro.view.vtk_utils import pole_figure_3d, axes_actor, setup_camera ''' Create a 3d scene with a cubic crystal lattice at the center. Hkl planes are added to the lattice and their normal displayed. A sphere is added to show how a pole figure can be constructed. ''' base_name = os.path.splitext(__file__)[0] s3d = Scene3D(display=False, ren_size=(800, 800), name=base_name) orientation = Orientation.from_euler(numpy.array([142.8, 32.0, 214.4])) pf = PoleFigure(hkl='111') pf.microstructure.grains.append(Grain(1, orientation)) pole_figure = pole_figure_3d(pf, radius=1.0, show_lattice=True) # add all actors to the 3d scene s3d.add(pole_figure) axes = axes_actor(1.0, fontSize=60) s3d.add(axes) # set up camera cam = setup_camera(size=(1, 1, 1)) cam.SetViewUp(0, 0, 1) cam.SetPosition(0, -4, 0) cam.SetFocalPoint(0, 0, 0) s3d.set_camera(cam)
def test_Orientation(self): o = Orientation.from_euler([45, 45, 0]) self.assertAlmostEqual(o.phi1(), 45.) self.assertAlmostEqual(o.Phi(), 45.)
from pymicro.view.vtk_utils import * from pymicro.crystal.lattice import HklPlane from pymicro.crystal.microstructure import Orientation from math import sqrt import numpy as np ''' Create a 3d scene with a hexagonal crystal lattice. Hkl planes are added to the lattice and displayed. ''' # Create the Renderer and RenderWindow ren = vtk.vtkRenderer() ren.SetBackground(white) # crystal orientation o = Orientation.from_euler((15.0, -45.0, 0.0)) o = None # hexagonal lattice a = 1.0 # 0.321 # nm c = 1.5 # 0.521 # nm l = Lattice.hexagonal(a, c) grid = hexagonal_lattice_grid(l) print(np.array(HklPlane.four_to_three_indices(1, 0, -1, 0)) / 0.6) # prismatic 1 print(np.array(HklPlane.four_to_three_indices(0, 1, -1, 0)) / 0.6) # prismatic 2 print(np.array(HklPlane.four_to_three_indices(0, 1, -1, 1)) / 0.6 * 3) # pyramidal 1 print(np.array(HklPlane.four_to_three_indices(1, 1, -2, 2)) / 0.6 * 3) # pyramidal 2 print(np.array(HklPlane.four_to_three_indices(0, 0, 0, 1))) # basal
def test_in_fundamental_zone(self): rod = [0.1449, -0.0281, 0.0616] o = Orientation.from_rodrigues(rod) self.assertTrue(o.inFZ(symmetry=Symmetry.cubic)) o = Orientation.from_euler([191.9, 69.9, 138.9]) self.assertFalse(o.inFZ(symmetry=Symmetry.cubic))
def segment_grains(self, tol=5.): """Segment the grains based on the euler angle maps. The segmentation is carried out using a region growing algorithm based on an orientation similarity criterion. The id 0 is reserved to the background which is assigned to pixels with a confidence index lower than 0.2. Other pixels are first marqued as unlabeled using -1, then pixels are evaluated one by one. A new grain is created and non already assigned neighboring pixels are evaluated based on the crystal misorientation. If the misorientation is lower than `tol`, the pixel is assigned to the current grain and its neighbors added to the list of candidates. When no more candidates are present, the next pixel is evaluated and a new grain is created. :param tol: misorientation tolerance in degrees :return: a numpy array of the grain labels. """ # segment the grains grain_ids = np.zeros_like(self.iq, dtype='int') grain_ids += -1 # mark all pixels as non assigned # start by assigning bad pixel to grain 0 grain_ids[self.ci <= 0.2] = 0 n_grains = 0 for j in range(self.rows): for i in range(self.cols): if grain_ids[i, j] >= 0: continue # skip pixel # create new grain with the pixel as seed n_grains += 1 # print('segmenting grain %d' % n_grains) grain_ids[i, j] = n_grains candidates = [(i, j)] # apply region growing based on the angle misorientation (strong connectivity) while len(candidates) > 0: pixel = candidates.pop() # print('* pixel is {}, euler: {}'.format(pixel, np.degrees(euler[pixel]))) # get orientation of this pixel o = Orientation.from_euler(np.degrees(self.euler[pixel])) # look around this pixel east = (pixel[0] - 1, pixel[1]) north = (pixel[0], pixel[1] - 1) west = (pixel[0] + 1, pixel[1]) south = (pixel[0], pixel[1] + 1) neighbors = [east, north, west, south] # look at unlabeled connected pixels neighbor_list = [ n for n in neighbors if 0 <= n[0] < self.cols and 0 <= n[1] < self.rows and grain_ids[n] == -1 ] # print(' * neighbors list is {}'.format([east, north, west, south])) for neighbor in neighbor_list: # check misorientation o_neighbor = Orientation.from_euler( np.degrees(self.euler[neighbor])) mis, _, _ = o.disorientation( o_neighbor, crystal_structure=Symmetry.hexagonal) if mis * 180 / np.pi < tol: # add to this grain grain_ids[neighbor] = n_grains # add to the list of candidates candidates.append(neighbor) progress = 100 * np.sum(grain_ids >= 0) / (self.cols * self.rows) print('segmentation progress: {0:.2f} %'.format(progress), end='\r') print('\n%d grains were segmented' % len(np.unique(grain_ids))) return grain_ids
import numpy as np import os from pymicro.crystal.microstructure import Microstructure, Orientation, Grain from pymicro.crystal.texture import PoleFigure from matplotlib import pyplot as plt # read data from Z-set calculation (50% tension load) data = np.genfromtxt('../data/R_1g.dat') t, R11, R22, R33, R12, R23, R31, R21, R32, R13, _, _, _, _ = data.T step = 1 # plot every step point max_step = data.shape[0] # create a microstructure with the initial grain orientation micro = Microstructure(name='1g', autodelete=True) g = Grain(50, Orientation.from_euler((12.293, 149.266, -167.068))) micro.add_grains([(12.293, 149.266, -167.068)], grain_ids=[50]) ipf = PoleFigure(proj='stereo', microstructure=micro) ipf.mksize = 100 ipf.set_map_field('grain_id') fig = plt.figure(1, figsize=(6, 5)) # for IPF ax1 = fig.add_subplot(111, aspect='equal') print('** plotting the initial orientation (with label for legend) **') ipf.plot_sst(ax=ax1, mk='.', col='k', ann=False) ax1.set_title('grain rotation in tension') axis = np.array([0, 0, 1]) grain = micro.get_grain(50) cgid = Microstructure.rand_cmap().colors[grain.id] # color by grain id g = grain.orientation_matrix()
assembly.AddPart(hklplaneActor) return assembly ''' Create a 3d scene with the mesh outline. Two planes are used to figure out the crack. Both hkl planes are added at the crack tip and displayed. ''' # Create the 3D scene base_name = os.path.splitext(__file__)[0] s3d = Scene3D(display=False, ren_size=(800, 800), name=base_name) # specify the grain orientation o1 = Orientation.from_euler(numpy.array([45., 0., 0.])) # grain 1 # choose slip plane normals and directions to display in grain n1 = numpy.array([1.0, 1.0, -1.0]) l1 = numpy.array([1.0, 1.0, 2.0]) d1 = '[112]' n2 = numpy.array([1.0, 1.0, 1.0]) l2 = numpy.array([1.0, 1.0, -2.0]) d2 = '[11-2]' nld = [[n1, l1, d1], [n2, l2, d2]] # we use a unit lattice cell to represent the mesh l_xyz = Lattice.face_centered_cubic(1.0) g1 = create_mesh_outline_3d_with_planes(l_xyz, o1, nld) s3d.add(g1)
def load(file_path='experiment.txt'): with open(file_path, 'r') as f: dict_exp = json.load(f) sample = Sample() sample.set_name(dict_exp['Sample']['Name']) sample.set_position(dict_exp['Sample']['Position']) if 'Geometry' in dict_exp['Sample']: sample_geo = ObjectGeometry() sample_geo.set_type(dict_exp['Sample']['Geometry']['Type']) sample.set_geometry(sample_geo) if 'Material' in dict_exp['Sample']: a, b, c = dict_exp['Sample']['Material']['Lengths'] alpha, beta, gamma = dict_exp['Sample']['Material']['Angles'] centering = dict_exp['Sample']['Material']['Centering'] symmetry = Symmetry.from_string( dict_exp['Sample']['Material']['Symmetry']) material = Lattice.from_parameters(a, b, c, alpha, beta, gamma, centering=centering, symmetry=symmetry) sample.set_material(material) if 'Microstructure' in dict_exp['Sample']: micro = Microstructure( dict_exp['Sample']['Microstructure']['Name']) for i in range(len( dict_exp['Sample']['Microstructure']['Grains'])): dict_grain = dict_exp['Sample']['Microstructure']['Grains'][i] grain = Grain( dict_grain['Id'], Orientation.from_euler( dict_grain['Orientation']['Euler Angles (degrees)'])) grain.position = np.array(dict_grain['Position']) grain.volume = dict_grain['Volume'] micro.grains.append(grain) sample.set_microstructure(micro) exp = Experiment() exp.set_sample(sample) source = XraySource() source.set_position(dict_exp['Source']['Position']) if 'Min Energy (keV)' in dict_exp['Source']: source.set_min_energy(dict_exp['Source']['Min Energy (keV)']) if 'Max Energy (keV)' in dict_exp['Source']: source.set_max_energy(dict_exp['Source']['Max Energy (keV)']) exp.set_source(source) for i in range(len(dict_exp['Detectors'])): dict_det = dict_exp['Detectors'][i] if dict_det['Class'] == 'Detector2d': det = Detector2d(size=dict_det['Size (pixels)']) det.ref_pos = dict_det['Reference Position (mm)'] if dict_det['Class'] == 'RegArrayDetector2d': det = RegArrayDetector2d(size=dict_det['Size (pixels)']) det.pixel_size = dict_det['Pixel Size (mm)'] det.ref_pos = dict_det['Reference Position (mm)'] if 'Binning' in dict_det: det.set_binning(dict_det['Binning']) det.u_dir = np.array(dict_det['u_dir']) det.v_dir = np.array(dict_det['v_dir']) det.w_dir = np.array(dict_det['w_dir']) exp.add_detector(det) return exp
#!/usr/bin/env python import os, numpy as np from pymicro.crystal.microstructure import Microstructure, Grain, Orientation from pymicro.crystal.texture import PoleFigure from matplotlib import pyplot as plt, colors, cm if __name__ == '__main__': ''' Pole figure of a gold sample containing 6 grains with a strong <111> fiber texture. A Microstructure object is first created with the 6 grains of interest. The grain ids corerespond to the actual grain number (in an EBSD scan for instance). A PoleFigure object is then created using this microstructure and the pole figures (both direct and inverse) are drawn by calling the plot_pole_figures() method. ''' micro = Microstructure(name='Au_6grains') micro.grains.append(Grain(1158, Orientation.from_euler(np.array([344.776, 52.2589, 53.9933])))) micro.grains.append(Grain(1349, Orientation.from_euler(np.array([344.899, 125.961, 217.330])))) micro.grains.append(Grain(1585, Orientation.from_euler(np.array([228.039, 57.4791, 143.171])))) micro.grains.append(Grain(1805, Orientation.from_euler(np.array([186.741, 60.333, 43.311])))) micro.grains.append(Grain(1833, Orientation.from_euler(np.array([151.709, 55.0406, 44.1051])))) micro.grains.append(Grain(2268, Orientation.from_euler(np.array([237.262, 125.149, 225.615])))) # create pole figure (both direct and inverse) pf = PoleFigure(hkl='111', axis='Z', proj='stereo', microstructure=micro) pf.mksize = 100 pf.set_map_field('grain_id') pf.pflegend = True # this works well for a few grains pf.plot_pole_figures(plot_sst=True, display=False, save_as='png') image_name = os.path.splitext(__file__)[0] + '.png' print('writting %s' % image_name)