def setUp(self): self.ok = quakelib.Okada() self.slip_rad = math.pi self.slip_vec = quakelib.Vec3(math.sin(self.slip_rad), math.cos(self.slip_rad), 0) self.dip_rad = math.pi / 2.0 # Tolerate at most a 1e-10 absolute difference in magnitude self.mag_tol = 1e-9
def testDispCalcFaultSize(self): baseline = [ 0.102036860007, 0.152747014539, 0.178027759544, 0.182776615629, 0.183223384675, 0.183254816562, 0.183256842643, 0.183256970265, 0.183256978257, 0.183256978757 ] for i in range(10): fault_length = math.pow(2, i) # Note that the location can't be too close or we trigger the boundary case and the results don't fit a curve loc = quakelib.Vec3(fault_length / 2.0, 1, 0) source_dim = quakelib.Vec3(fault_length, 1, 0) # Ensure displacement is within acceptable bounds disp = self.ok.calc_displacement_vector( loc, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) rel_err = abs(baseline[i] - disp.mag()) / baseline[i] self.assertTrue(rel_err < 1e-8)
def test_read_assign(self): x = quakelib.Vec3(1, 3, 5) self.assertEqual(x[0], 1) self.assertEqual(x[1], 3) self.assertEqual(x[2], 5) x[1] = -1 self.assertEqual(x[1], -1) self.assertRaises(IndexError, x.__getitem__, 3)
def testAddMultiRegular(self): lg2_num_pts = 2 num_dim_pts = 2**lg2_num_pts step = 1.0 / float(num_dim_pts) half_step = 1.0 / float(2 * num_dim_pts) quarter_step = 1.0 / float(2 * 2 * num_dim_pts) quarter_step_vec = quakelib.Vec3(quarter_step, quarter_step, quarter_step) vec00 = quakelib.Vec3(0, 0, 0) vec10 = quakelib.Vec3(1, 1, 1) rb = quakelib.RectBound3(vec00, vec10) octree = quakelib.Octree3(rb) pt_list = [[ quakelib.Vec3(x * step + half_step, y * step + half_step, z * step + half_step), x + y * num_dim_pts + z * num_dim_pts * num_dim_pts ] for x in range(num_dim_pts) for y in range(num_dim_pts) for z in range(num_dim_pts)] for pt in pt_list: self.assertTrue(octree.add_point(pt[0], pt[1])) num_branches = 0 for i in range(lg2_num_pts): num_branches += 8**i # Confirm that the number of branches is as expected self.assertEqual(octree.num_descendents() - octree.num_leaves(), num_branches) self.assertEqual(octree.num_leaves(), num_dim_pts**3) # Confirm that the tree is correctly balanced self.assertEqual(octree.max_depth(), lg2_num_pts) # Confirm that identical points return the same id for pt in pt_list: self.assertEqual( octree.get_leaf_containing_point(pt[0]).id(), pt[1]) # And that slightly offset points return the same id for pt in pt_list: self.assertEqual( octree.get_leaf_containing_point(pt[0] + quarter_step_vec).id(), pt[1]) for pt in pt_list: self.assertEqual( octree.get_leaf_containing_point(pt[0] - quarter_step_vec).id(), pt[1])
def testGreenSymmetricDGDV(self): source_dim = quakelib.Vec3(1, 1, 1) for x in range(-2, 8): for y in range(-2, 8): # Set up the test location and mirror location z = 0 xloc = source_dim[0] / 2.0 + 2**x yloc = 2**y zloc = -z orig_loc_dg = quakelib.Vec2(xloc, yloc) orig_loc_dv = quakelib.Vec3(xloc, yloc, zloc) xloc = source_dim[0] / 2.0 - 2**x yloc = -2**y mirror_loc_dg = quakelib.Vec2(xloc, yloc) mirror_loc_dv = quakelib.Vec3(xloc, yloc, zloc) # Calculate dudz orig_dg = self.ok.calc_dg(orig_loc_dg, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) mirror_dg = self.ok.calc_dg(mirror_loc_dg, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) orig_dv = self.ok.calc_dV(orig_loc_dv, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) mirror_dv = self.ok.calc_dV(mirror_loc_dv, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) abs_err_dg = abs(orig_dg + mirror_dg) abs_err_dv = abs(orig_dv + mirror_dv) self.assertTrue(abs_err_dg < self.mag_tol) self.assertTrue(abs_err_dv < self.mag_tol)
def testInvalidRB(self): rb = quakelib.RectBound3() vec = quakelib.Vec3() self.assertTrue(math.isnan(rb.max_length())) self.assertTrue(math.isnan(rb.center()[0])) self.assertEqual(rb.get_child_subdivision(vec), 0) self.assertFalse(rb.get_child_bound(0).valid()) self.assertFalse(rb.in_bound(vec)) self.assertNotEqual(rb, quakelib.RectBound3()) rb.extend_bound(vec) self.assertTrue(rb.valid())
def testNormalRB(self): vec00 = quakelib.Vec3(0.0, 0.0, 0.0) vec05 = quakelib.Vec3(0.5, 0.5, 0.5) vec10 = quakelib.Vec3(1.0, 1.0, 1.0) vecneg = quakelib.Vec3(-1.0, -1.0, -1.0) rb = quakelib.RectBound3(vec00, vec10) rb2 = quakelib.RectBound3(vec00, vec05) self.assertEqual(rb.max_length(), 1.0) self.assertEqual(rb.center(), vec05) self.assertEqual(rb.get_child_subdivision(vec00), 0) self.assertEqual(rb.get_child_subdivision(vec05), 0) self.assertEqual(rb.get_child_subdivision(vec10), 7) self.assertEqual(rb.get_child_bound(0), rb2) self.assertTrue(rb.in_bound(vec00)) self.assertTrue(rb.in_bound(vec05)) self.assertFalse(rb.in_bound(vec10)) self.assertFalse(rb.in_bound(vecneg)) rb.extend_bound(vecneg) self.assertTrue(rb.in_bound(vecneg)) rb.extend_bound(vec10) self.assertTrue(rb.in_bound(vec10))
def testGreenSymmetricTensor(self): source_dim = quakelib.Vec3(1, 1, 1) for x in range(-2, 8): for y in range(-2, 8): # Set up the test location and mirror location z = 0 xloc = source_dim[0] / 2.0 + 2**x yloc = 2**y zloc = -z orig_loc = quakelib.Vec3(xloc, yloc, zloc) xloc = source_dim[0] / 2.0 - 2**x yloc = -2**y mirror_loc = quakelib.Vec3(xloc, yloc, zloc) # Calculate tensor and determine shear/normal stresses orig_tensor = self.ok.calc_stress_tensor( orig_loc, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) mirror_tensor = self.ok.calc_stress_tensor( mirror_loc, source_dim[2], self.dip_rad, source_dim[0], source_dim[1], self.slip_vec[0], self.slip_vec[1], self.slip_vec[2], 1, 1) rake_vec = quakelib.Vec3(1, 0, 0) normal_vec = quakelib.Vec3(0, 1, 0) orig_stress_vec = orig_tensor * normal_vec mirror_stress_vec = mirror_tensor * normal_vec # Shear stresses should be exactly opposite in sign orig_shear_stress = orig_stress_vec.dot_product(rake_vec) mirror_shear_stress = mirror_stress_vec.dot_product(rake_vec) abs_err = abs(orig_shear_stress + mirror_shear_stress) self.assertTrue(abs_err < self.mag_tol) # Normal stresses orig_normal_stress = orig_stress_vec.dot_product(normal_vec) mirror_normal_stress = mirror_stress_vec.dot_product( normal_vec) abs_err = abs(orig_normal_stress + mirror_normal_stress) self.assertTrue(abs_err < self.mag_tol)
def test_index_error(self): x = quakelib.Vec3(1, 2, 3) y = quakelib.Vec2(1, 2) with self.assertRaises(OverflowError): x[-1] with self.assertRaises(OverflowError): x[-1] = 0 with self.assertRaises(IndexError): x[3] with self.assertRaises(IndexError): x[3] = 0 with self.assertRaises(OverflowError): y[-1] with self.assertRaises(OverflowError): y[-1] = 0 with self.assertRaises(IndexError): y[2] with self.assertRaises(IndexError): y[2] = 0
def testRBCreation(self): vec00 = quakelib.Vec3(0.0, 0.0, 0.0) vec05 = quakelib.Vec3(0.5, 0.5, 0.5) rb1 = quakelib.RectBound3(vec00, vec05) rb2 = quakelib.RectBound3(vec05, vec00) self.assertEqual(rb1, rb2)
fault_id = model.section(section).fault_id() try: if section not in fault_sections[fault_id]: fault_sections[fault_id].append(section) except KeyError: fault_sections[fault_id] = [section] new_sec_id_map = {} strike_diffs = [] segment_strikes = [] section_mean_xyz = {} ### Compute the mean xyz of each section from the elements for sid in section_elements.keys(): mean_xyz = quakelib.Vec3() for eid in section_elements[sid]: this_xyz = model.element_mean_xyz(eid) mean_xyz[0] += this_xyz[0] mean_xyz[1] += this_xyz[1] mean_xyz[2] += this_xyz[2] section_mean_xyz[sid] = mean_xyz / float(len(section_elements[sid])) for fid in fault_ids: section_lines = [] section_points_dict = {} sec_distances = {} point_distances = {} sec_points = [] section_ids = fault_sections[fid] first_section_id = min(section_ids)
def calculate_model_extents(self): #----------------------------------------------------------------------- # get info from the original file #----------------------------------------------------------------------- block_info_table = self.file.root.block_info_table #----------------------------------------------------------------------- # calculate the model extents #----------------------------------------------------------------------- print 'Calculating model extents' start_time = time.time() sys_max_z = -sys.float_info.max sys_min_z = sys.float_info.max sys_max_x = -sys.float_info.max sys_min_x = sys.float_info.max sys_max_y = -sys.float_info.max sys_min_y = sys.float_info.max for block in block_info_table: min_x = min((block['m_x_pt1'], block['m_x_pt2'], block['m_x_pt3'], block['m_x_pt4'])) max_x = max((block['m_x_pt1'], block['m_x_pt2'], block['m_x_pt3'], block['m_x_pt4'])) min_y = min((block['m_y_pt1'], block['m_y_pt2'], block['m_y_pt3'], block['m_y_pt4'])) max_y = max((block['m_y_pt1'], block['m_y_pt2'], block['m_y_pt3'], block['m_y_pt4'])) min_z = min((block['m_z_pt1'], block['m_z_pt2'], block['m_z_pt3'], block['m_z_pt4'])) max_z = max((block['m_z_pt1'], block['m_z_pt2'], block['m_z_pt3'], block['m_z_pt4'])) if min_x < sys_min_x: sys_min_x = min_x if max_x > sys_max_x: sys_max_x = max_x if min_y < sys_min_y: sys_min_y = min_y if max_y > sys_max_y: sys_max_y = max_y if min_z < sys_min_z: sys_min_z = min_z if max_z > sys_max_z: sys_max_z = max_z base_lat_lon_table = self.file.root.base_lat_lon conv = quakelib.Conversion(base_lat_lon_table[0], base_lat_lon_table[1]) ne_corner = conv.convert2LatLon( quakelib.Vec3(sys_max_x, sys_max_y, 0.0)) sw_corner = conv.convert2LatLon( quakelib.Vec3(sys_min_x, sys_min_y, 0.0)) self.file.close() print 'Done! {} seconds'.format(time.time() - start_time) print 'Creating new tables' table_start_time = time.time() self.file = tables.open_file(self.file_path, 'a') desc = { 'min_x': tables.Float64Col(dflt=0.0), 'max_x': tables.Float64Col(dflt=0.0), 'min_y': tables.Float64Col(dflt=0.0), 'max_y': tables.Float64Col(dflt=0.0), 'min_z': tables.Float64Col(dflt=0.0), 'max_z': tables.Float64Col(dflt=0.0), 'min_lat': tables.Float64Col(dflt=0.0), 'max_lat': tables.Float64Col(dflt=0.0), 'min_lon': tables.Float64Col(dflt=0.0), 'max_lon': tables.Float64Col(dflt=0.0) } model_extents = self.file.create_table('/', 'model_extents', desc, 'Model Extents') model_extents.row.append() model_extents.flush() model_extents.cols.min_x[0] = sys_min_x model_extents.cols.max_x[0] = sys_max_x model_extents.cols.min_y[0] = sys_min_y model_extents.cols.max_y[0] = sys_max_y model_extents.cols.min_z[0] = sys_min_z model_extents.cols.max_z[0] = sys_max_z model_extents.cols.min_lat[0] = sw_corner.lat() model_extents.cols.max_lat[0] = ne_corner.lat() model_extents.cols.min_lon[0] = sw_corner.lon() model_extents.cols.max_lon[0] = ne_corner.lon() print 'Done! {} seconds'.format(time.time() - table_start_time) #----------------------------------------------------------------------- # close the file and reopen it with the new table #----------------------------------------------------------------------- self.file.close() self.file = tables.open_file(self.file_path) print 'Total time {} seconds'.format(time.time() - start_time)
def test_cross_prod(self): self.assertEqual(self.x.cross(self.y), quakelib.Vec3()) self.assertEqual(self.y.cross(self.x), quakelib.Vec3()) self.assertEqual(self.x.cross(self.z), quakelib.Vec3(-5, -5, 5)) self.assertRaises(ValueError, quakelib.Vec2().cross, (quakelib.Vec2()))
def test_arithmetic(self): self.assertEqual(self.x * 2, self.y) self.assertEqual(self.x * 2 - self.y, quakelib.Vec3())
def setUp(self): self.x = quakelib.Vec3(1, 2, 3) self.y = quakelib.Vec3(2, 4, 6) self.z = quakelib.Vec3(-1, 3, 2) self.xax = quakelib.Vec3(1, 0, 0) self.yax = quakelib.Vec3(0, 1, 0)