def get_LOS_vector(self, locations): """ calculate beta - the angle at earth center between reference point and satellite nadir """ utmZone = self.location_UTM_zone refPoint = vmath.Vector3(self.ref[0], self.ref[1], 0) satAltitude = self.satellite_altitude satAzimuth = self.satellite_azimuth satIncidence = self.ref_incidence earthRadius = self.local_earth_radius DEG2RAD = np.pi / 180. alpha = satIncidence * DEG2RAD beta = (earthRadius / (satAltitude + earthRadius)) * np.sin(alpha) beta = alpha - np.arcsin(beta) beta = beta / DEG2RAD # calculate angular separation of (x,y) from satellite track passing # through (origx, origy) with azimuth satAzimuth # Long lat **NOT** lat long origy, origx = utm.to_latlon(refPoint.x, refPoint.y, np.abs(utmZone), northern=utmZone > 0) xy = np.array([ utm.to_latlon(u[0], u[1], np.abs(utmZone), northern=utmZone > 0) for u in locations ]) y = xy[:, 0] x = xy[:, 1] angdist = self._ang_to_gc(x, y, origx, origy, satAzimuth) # calculate beta2, the angle at earth center between roaming point and # satellite nadir track, assuming right-looking satellite beta2 = beta - angdist beta2 = beta2 * DEG2RAD # calculate alpha2, the new incidence angle alpha2 = np.sin(beta2) / (np.cos(beta2) - (earthRadius / (earthRadius + satAltitude))) alpha2 = np.arctan(alpha2) alpha2 = alpha2 / DEG2RAD # calculate pointing vector satIncidence = 90 - alpha2 satAzimuth = 360 - satAzimuth los_x = -np.cos(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD) los_y = -np.sin(satAzimuth * DEG2RAD) * np.cos(satIncidence * DEG2RAD) los_z = np.sin(satIncidence * DEG2RAD) return vmath.Vector3(los_x, los_y, los_z)
def test_vector3(self): class HasVec3(properties.HasProperties): vec3 = properties.Vector3('simple vector') hv3 = HasVec3() hv3.vec3 = [1., 2., 3.] assert isinstance(hv3.vec3, vmath.Vector3) hv3.vec3 = 'east' assert np.allclose(hv3.vec3, [1., 0., 0.]) with self.assertRaises(ValueError): hv3.vec3 = 'around' with self.assertRaises(ValueError): hv3.vec3 = [1., 2.] with self.assertRaises(ValueError): hv3.vec3 = [[1., 2., 3.]] class HasLenVec3(properties.HasProperties): vec3 = properties.Vector3('length 5 vector', length=5) hv3 = HasLenVec3() hv3.vec3 = 'down' assert np.allclose(hv3.vec3, [0., 0., -5.]) assert isinstance(properties.Vector3.from_json([5., 6., 7.]), vmath.Vector3) assert properties.Vector3('').equal(vmath.Vector3(1., 2., 3.), vmath.Vector3(1., 2., 3.)) assert not properties.Vector3('').equal(vmath.Vector3(1., 2., 3.), np.array([1., 2., 3.]))
def test_los(self): interferogram_refx = 741140 interferogram_refy = 4230327 interferogram_ref_incidence = 23 local_earth_radius = 6386232 satellite_altitude = 788792 satellite_azimuth = 192 locationUTMzone = 35 locationE = 706216.0606 locationN = 4269238.9999 utmLoc = vmath.Vector3([locationE], [locationN], [0]) refPoint = vmath.Vector3(interferogram_refx, interferogram_refy, 0) LOS = oksar.getLOSvector( utmLoc, locationUTMzone, refPoint, satellite_altitude, satellite_azimuth, interferogram_ref_incidence, local_earth_radius ) true = vmath.Vector3([0.427051, -0.090772, 0.899660]) assert (LOS - true).length < 1e-5
def test_Vec3_subtraction_operator(): components1 = np.random.rand(3) components2 = np.random.rand(3) vec3_1py = vectormath.Vector3(*components1) vec3_2py = vectormath.Vector3(*components2) vec3_1cpp = NumCpp.Vec3(*components1) vec3_2cpp = NumCpp.Vec3(*components2) assert np.array_equal( np.round(vec3_1py - vec3_2py, DECIMALS_TO_ROUND), np.round((NumCpp.Vec3_minusVec3(vec3_1cpp, vec3_2cpp)).toNdArray().flatten(), DECIMALS_TO_ROUND)) components = np.random.rand(3) scaler = np.random.rand(1).item() vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert np.array_equal( np.round(vec3py - scaler, DECIMALS_TO_ROUND), np.round((NumCpp.Vec3_minusVec3Scaler(vec3cpp, scaler)).toNdArray().flatten(), DECIMALS_TO_ROUND)) components = np.random.rand(3) scaler = np.random.rand(1).item() vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert np.array_equal( np.round(-vec3py + scaler, DECIMALS_TO_ROUND), np.round((NumCpp.Vec3_minusScalerVec3(vec3cpp, scaler)).toNdArray().flatten(), DECIMALS_TO_ROUND))
def test_Vec3_cross(): components1 = np.random.rand(3) components2 = np.random.rand(3) vec3_1py = vectormath.Vector3(*components1) vec3_2py = vectormath.Vector3(*components2) vec3_1cpp = NumCpp.Vec3(*components1) vec3_2cpp = NumCpp.Vec3(*components2) assert np.array_equal(np.round(vec3_1py.cross(vec3_2py), DECIMALS_TO_ROUND), np.round(vec3_1cpp.cross(vec3_2cpp).toNdArray().flatten(), DECIMALS_TO_ROUND))
def test_Vec3_distance(): components1 = np.random.rand(3) components2 = np.random.rand(3) vec3_1py = vectormath.Vector3(*components1) vec3_2py = vectormath.Vector3(*components2) vec3_1cpp = NumCpp.Vec3(*components1) vec3_2cpp = NumCpp.Vec3(*components2) assert (round((vec3_2py - vec3_1py).length, DECIMALS_TO_ROUND) == round(vec3_1cpp.distance(vec3_2cpp), DECIMALS_TO_ROUND))
def simulation_grid(self): self.assert_valid vec, shape = vmath.ouv2vec(vmath.Vector3(self.O[0], self.O[1], 0), vmath.Vector3(self.U[0], self.U[1], 0), vmath.Vector3(self.V[0], self.V[1], 0), self.shape) return vec
def test_Vec3_dot(): components1 = np.random.rand(3) components2 = np.random.rand(3) vec3_1py = vectormath.Vector3(*components1) vec3_2py = vectormath.Vector3(*components2) vec3_1cpp = NumCpp.Vec3(*components1) vec3_2cpp = NumCpp.Vec3(*components2) assert (round(vec3_1py.dot(vec3_2py), DECIMALS_TO_ROUND) == round(vec3_1cpp.dot(vec3_2cpp), DECIMALS_TO_ROUND))
def test_Vec3_norm(): components = np.random.rand(3) vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert (round(vec3py.length, DECIMALS_TO_ROUND) == round(vec3cpp.norm(), DECIMALS_TO_ROUND))
def test_Vec3_multiplication_operator(): components = np.random.rand(3) scaler = np.random.rand(1).item() vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert np.array_equal(np.round(vec3py * scaler, DECIMALS_TO_ROUND), np.round((NumCpp.Vec3_multVec3Scaler(vec3cpp, scaler)).toNdArray().flatten(), DECIMALS_TO_ROUND)) components = np.random.rand(3) scaler = np.random.rand(1).item() vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert np.array_equal(np.round(vec3py * scaler, DECIMALS_TO_ROUND), np.round((NumCpp.Vec3_multScalerVec3(vec3cpp, scaler)).toNdArray().flatten(), DECIMALS_TO_ROUND))
def test_Vec3_normalize(): components = np.random.rand(3) vec3py = vectormath.Vector3(*components) vec3cpp = NumCpp.Vec3(*components) assert np.array_equal( np.round(vec3py.normalize(), DECIMALS_TO_ROUND), np.round(vec3cpp.normalize().toNdArray().flatten(), DECIMALS_TO_ROUND))
def lightmap(nm, cm, light, ambient): width, height = nm.size cwidth, cheight = cm.size if cwidth != width or cheight != height: print("Resolutions do not match.") exit() shaded = Image.new('RGBA', (width, height), color=(0, 0, 0, 0)) for y in range(0, height): if y % (height // 100) == 0: print("lm", y / height * 100) for x in range(0, width): (cr, cg, cb, ca) = cm.getpixel((x, y)) (r, g, b, a) = nm.getpixel((x, y)) if a != 0: normal = vmath.Vector3(\ (r/255 - 0.5) * 2, (g/255 - 0.5) * 2, (b/255 - 0.5) * 2) angle = normal.angle(light, 'deg') illumination = 1 - (angle / 180) illumination = ambient + (1 - ambient) * illumination cr = int(illumination * cr) cg = int(illumination * cg) cb = int(illumination * cb) shaded.putpixel((x, y), (cr, cg, cb, ca)) return shaded
def get_quaternion_from_vectors(target=None, source=None): """ 参考URL https://knowledge.shade3d.jp/knowledgebase/2%E3%81%A4%E3%81%AE%E3%83%99%E3%82%AF%E3%83%88%E3%83%AB%E3%81%8C%E4%BD%9C%E3%82%8B%E5%9B%9E%E8%BB%A2%E8%A1%8C%E5%88%97%E3%82%92%E8%A8%88%E7%AE%97-%E3%82%B9%E3%82%AF%E3%83%AA%E3%83%97%E3%83%88 ベクトルaをbに向かせるquaternionを求める. """ qw, qx, qy, qz = 1.0, 0.0, 0.0, 0.0 normalize = lambda x: np.array(vmath.Vector3(x).normalize()) src_vec = normalize(source) target_vec = normalize(target) cross_vec = np.cross(target_vec, src_vec) cross_vec_norm = -np.linalg.norm(cross_vec) cross_vec = normalize(cross_vec) epsilon = 0.0002 inner_vec = np.dot(src_vec, target_vec) if -epsilon < cross_vec_norm or 1.0 < inner_vec: if inner_vec < (epsilon - 1.0): trans_axis_src = np.array([-src_vec[1], src_vec[2], src_vec[0]]) c = normalize(np.cross(trans_axis_src, src_vec)) qw = 0.0 qx = c[0] qy = c[1] qz = c[2] else: e = cross_vec * math.sqrt(0.5 * (1.0 - inner_vec)) qw = math.sqrt(0.5 * (1.0 + inner_vec)) qx = e[0] qy = e[1] qz = e[2] return np.quaternion(qw, qx, qy, qz)
def test_Vec3_division_assignment_operator(): components1 = np.random.rand(3) scaler = np.random.rand(1).item() vec3_1py = vectormath.Vector3(*components1) vec3_1cpp = NumCpp.Vec3(*components1) vec3_1cpp /= scaler assert np.array_equal(np.round(vec3_1py / scaler, DECIMALS_TO_ROUND), np.round(vec3_1cpp.toNdArray().flatten(), DECIMALS_TO_ROUND))
def distance(player, enemy): diff = vectors.Vector3(0.0, 0.0, 0.0) diff.x = enemy.x - player.x diff.y = enemy.y - player.y diff.z = enemy.z - player.z distance = sqrt(diff.x**2 + diff.y**2 + diff.z**2) return abs(distance)
def test_los(self): dinar, dinar_fwd = oksar.example() dinar.ref = [741140, 4230327] dinar.ref_incidence = 23 dinar.local_earth_radius = 6386232 dinar.satellite_altitude = 788792 dinar.satellite_azimuth = 192 dinar.location_UTM_zone = 35 utmLoc = vmath.Vector3([706216.0606, 4269238.9999, 0]) # refPoint = vmath.Vector3(dinar.ref.x, dinar.ref.y, 0) LOS = dinar.get_LOS_vector(utmLoc) # compare against fortran code. true = vmath.Vector3([0.427051, -0.090772, 0.899660]) assert (LOS - true).length < 1e-5
def test_Vec3_subtraction_assignment_operator(): components1 = np.random.rand(3) components2 = np.random.rand(3) vec3_1py = vectormath.Vector3(*components1) vec3_2py = vectormath.Vector3(*components2) vec3_1cpp = NumCpp.Vec3(*components1) vec3_2cpp = NumCpp.Vec3(*components2) vec3_1cpp -= vec3_2cpp assert np.array_equal(np.round(vec3_1py - vec3_2py, DECIMALS_TO_ROUND), np.round(vec3_1cpp.toNdArray().flatten(), DECIMALS_TO_ROUND)) components1 = np.random.rand(3) scaler = np.random.rand(1).item() vec3_1py = vectormath.Vector3(*components1) vec3_1cpp = NumCpp.Vec3(*components1) vec3_1cpp -= scaler assert np.array_equal(np.round(vec3_1py - scaler, DECIMALS_TO_ROUND), np.round(vec3_1cpp.toNdArray().flatten(), DECIMALS_TO_ROUND))
def press_key_handler(arg1, x, y, z): global is_pressed inputVector = vmath.Vector3(x, y, z) print(arg1, x, y, z, inputVector.length) if inputVector.length > 15 and not is_pressed: keyboard.send('space') is_pressed = True elif is_pressed: is_pressed = False
def test_dynamic_getter(self): class HasDynamicProperty(properties.HasProperties): my_int = properties.Integer('an int') @properties.Integer('a dynamic int') def my_doubled_int(self): if self.my_int is None: raise ValueError('my_doubled_int depends on my_int') return self.my_int * 2 @properties.Vector3('a vector') def my_vector(self): self.validate() if self.my_int is None: raise ValueError('my_vector depends on my_int') val = [ float(val) for val in [self.my_int, self.my_int, self.my_doubled_int] ] return val @properties.Integer('another dynamic int') def my_tripled_int(self): if self.my_int: return self.my_int * 3 hdp = HasDynamicProperty() with self.assertRaises(ValueError): hdp.my_doubled_int assert hdp.my_tripled_int is None hdp.my_int = 10 assert hdp.my_doubled_int == 20 assert isinstance(hdp.my_vector, vectormath.Vector3) assert hdp.validate() with self.assertRaises(AttributeError): hdp.my_doubled_int = 50 with self.assertRaises(AttributeError): del hdp.my_doubled_int assert HasDynamicProperty._props['my_vector'].equal( vectormath.Vector3(0, 1, 2), vectormath.Vector3(0, 1, 2))
def displacement_vector(self): self.assert_valid vec = self.simulation_grid x, y = vec.x, vec.y DEG2RAD = 0.017453292519943 alpha = (self.beta + self.mu) / (self.beta + 2.0 * self.mu) # Here we could loop over models flt_x = self.center[0] flt_y = self.center[1] strike = self.strike dip = self.dip rake = self.rake slip = self.slip length = self.length hmin = self.depth_top hmax = self.depth_bottom rrake = (rake+90.0)*DEG2RAD sindip = np.sin(dip*DEG2RAD) w = (hmax-hmin)/sindip ud = slip*np.cos(rrake) us = -slip*np.sin(rrake) halflen = length/2.0 al2 = halflen al1 = -al2 aw1 = hmin/sindip aw2 = hmax/sindip if(hmin < 0.0): raise Exception('ERROR: Fault top above ground surface') if(hmin == 0.0): hmin = 0.00001 sstrike = (strike+90.0)*DEG2RAD ct = np.cos(sstrike) st = np.sin(sstrike) X = ct * (-flt_x + x) - st * (-flt_y + y) Y = ct * (-flt_y + y) + st * (-flt_x + x) u = self._dc3d3(alpha, X, Y, -dip, al1, al2, aw1, aw2, us, ud) UX = ct*u.x + st*u.y UY = -st*u.x + ct*u.y UZ = u.z return vmath.Vector3(UX, UY, UZ)
def press_key_handler(address, *args): global is_pressed global window inputVector = vmath.Vector3(args[0], args[1], args[2]) window.FindElement('_DEBUG_').Update(f'{address} {inputVector.length}\r\n', append=True) # print(arg1, x, y, z, inputVector.length) if inputVector.length > 15 and not is_pressed: keyboard.send('space') is_pressed = True elif is_pressed: is_pressed = False
def main(): with open("./inputs/day12.txt") as file: raw_input = file.read() names = ["Io", "Europa", "Ganymede", "Callisto"] moons = OrderedDict() matches = re.findall(r"^<x=(-*\d+), y=(-*\d+), z=(-*\d+)>$", raw_input, re.MULTILINE) for match in matches: moons[names.pop(0)] = { 'position': vmath.Vector3(int(match[0]), int(match[1]), int(match[2])), 'velocity': vmath.Vector3(0, 0, 0) } answer = 1 for dimension in ["x", "y", "z"]: steps = step_until_velocity_zero(copy.deepcopy(moons), dimension) answer = lcm(answer, steps) print(answer)
def main(): with open("./inputs/day12.txt") as file: raw_input = file.read() names = ["Io", "Europa", "Ganymede", "Callisto"] moons = OrderedDict() matches = re.findall(r"^<x=(-*\d+), y=(-*\d+), z=(-*\d+)>$", raw_input, re.MULTILINE) for match in matches: moons[names.pop(0)] = { 'position': vmath.Vector3(int(match[0]), int(match[1]), int(match[2])), 'velocity': vmath.Vector3(0, 0, 0) } for step in range(1, 1001): gravity = calculate_gravity(moons) moons = apply_gravity(moons, gravity) moons = apply_velocities(moons) if step == 1000: moons = calculate_energies(moons) print(int(sum([x['energy'] for _, x in moons.items()])))
def sobel(x, y, hm, sobelscale): s = [] for ny in range(1, -2, -1): for nx in range(-1, 2): value = hm.getpixel((x + nx, y + ny)) s.append(value) # if value != -2147483648: # else: # samples.append(hm.getpixel) normal = vmath.Vector3(0, 0, 0) scale = sobelscale normal.x = scale * -(s[2] - s[0] + 2 * (s[5] - s[3]) + s[8] - s[6]) normal.y = scale * -(s[6] - s[0] + 2 * (s[7] - s[1]) + s[8] - s[2]) normal.z = 1 normal.normalize() normal.x = normal.x * 0.5 + 0.5 normal.y = normal.y * 0.5 + 0.5 normal.z = normal.z + 0.5 return normal
def calculate_gravity(moons): moon_pairs = get_moon_pairs(tuple(moons.keys())) gravity = {name: [] for name in moons} for pair in moon_pairs: gravity[pair[0]].append( vmath.Vector3( get_velocity(moons[pair[0]]['position'].x, moons[pair[1]]['position'].x), 0, 0)) gravity[pair[1]].append( vmath.Vector3( get_velocity(moons[pair[1]]['position'].x, moons[pair[0]]['position'].x), 0, 0)) gravity[pair[0]].append( vmath.Vector3( 0, get_velocity(moons[pair[0]]['position'].y, moons[pair[1]]['position'].y), 0)) gravity[pair[1]].append( vmath.Vector3( 0, get_velocity(moons[pair[1]]['position'].y, moons[pair[0]]['position'].y), 0)) gravity[pair[0]].append( vmath.Vector3( 0, 0, get_velocity(moons[pair[0]]['position'].z, moons[pair[1]]['position'].z))) gravity[pair[1]].append( vmath.Vector3( 0, 0, get_velocity(moons[pair[1]]['position'].z, moons[pair[0]]['position'].z))) return gravity
dip=50, rake=90, slip=0.5, length=11578.907244622129, center=[773728.2977967655, 4223586.816611591], depth_top=0, depth_bottom=15000, O=[706216.0606, 4187318.9999], U=[81920, 0], V=[0, 81920], shape=(300, 200)) wv = 0.028333 rigidity = 30000000000 LOS = vmath.Vector3(0.3825, 0.0780, 0.9205) n = 300 O = vmath.Vector3(706216.0606, 4187318.9999, 0) U = vmath.Vector3(81920, 0, 0) V = vmath.Vector3(0, 81920, 0) vec, shape = vmath.ouv2vec(O, U, V, n) print(vec.shape) # strike=254 # dip=40 # rake=130 # slip=0.9209931290545376 # length=16384 # center=747176.0606,4228278.9999
from PIL import Image import numpy as np import vectormath as vmath import math from sphere import Sphere h, w = 800, 600 image = np.ndarray((w, h, 3), dtype=np.uint8) origin = vmath.Vector3(0, 0, 0) resolution = vmath.Vector2(w, h) sphere1 = Sphere(0, 0, 4, 1.0) sphere2 = Sphere(1.3, 1.3, 8, 1.0) spheres = [sphere1, sphere2] def normalize(min_val, max_val, val): return (val - min_val) / (max_val - min_val) def get_color(ray): distances = [] for s in spheres: distances.append(s.intesect(origin, ray)) min_distance = None for d in distances: if(d is not None): if(min_distance is None or d[0] < min_distance[0]):
def _dc3d3(self, alpha, X, Y, dip, al1, al2, aw1, aw2, disl1, disl2): F0 = 0.0 F1 = 1.0 F2 = 2.0 PI2 = 6.283185307179586 EPS = 1.0E-6 u = vmath.Vector3(F0, F0, F0) dub = vmath.Vector3(F0, F0, F0) # %%dccon0 subroutine # Calculates medium and fault dip constants c0_alp3 = (F1 - alpha) / alpha # PI2/360 pl8 = 0.017453292519943 c0_sd = np.sin(dip*pl8) c0_cd = np.cos(dip*pl8) if(np.abs(c0_cd) < EPS): c0_cd = F0 if(c0_sd > F0): c0_sd = F1 if(c0_sd < F0): c0_sd = -F1 c0_cdcd = c0_cd * c0_cd c0_sdcd = c0_sd * c0_cd # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% p = Y * c0_cd q = Y * c0_sd jxi = ((X - al1) * (X - al2)) <= F0 # BOOLEAN jet = ((p - aw1) * (p - aw2)) <= F0 # BOOLEAN for k in [1., 2.]: et = 0.0 if(k == 1): et = p-aw1 else: et = p-aw2 for j in [1., 2.]: xi = 0.0 if(j == 1): xi = X-al1 else: xi = X-al2 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # %%dccon2 subroutine # % calculates station geometry constants for finite source dc_max = np.max(np.abs(np.c_[xi, et, q])) # dc_max = max(np.abs(xi),max(np.abs(et),np.abs(q))) xi[(np.abs(xi/dc_max) < EPS) | (np.abs(xi) < EPS)] = F0 et[(np.abs(et/dc_max) < EPS) | (np.abs(et) < EPS)] = F0 q[(np.abs(q/dc_max) < EPS) | (np.abs(q) < EPS)] = F0 dc_xi = xi dc_et = et dc_q = q c2_r = np.sqrt(dc_xi*dc_xi + dc_et*dc_et + dc_q*dc_q) if np.any(c2_r == F0): raise Exception('singularity error ???') c2_y = dc_et * c0_cd + dc_q * c0_sd c2_d = dc_et * c0_sd - dc_q * c0_cd c2_tt = np.arctan(dc_xi * dc_et / (dc_q * c2_r)) c2_tt[dc_q == F0] = F0 rxi = c2_r + dc_xi c2_x11 = F1/(c2_r*rxi) c2_x11[(dc_xi < F0) & (dc_q == F0) & (dc_et == F0)] = F0 ret = c2_r + dc_et if np.any(ret < 1e-14): raise Exception('dccon2 b %f %f %f %f' % ( ret, c2_r, dc_et, dc_q, dc_xi )) c2_ale = np.log(ret) c2_y11 = F1/(c2_r*ret) ind = (dc_et < F0) & (dc_q == F0) & (dc_xi == F0) # if((c2_r-dc_et) < 1e-14): # raise Exception('dccon2 a %f %f %f %f %f' % ( # c2_3-dc_et, c2_r, dc_et, dc_q, dc_xi) # ) c2_ale[ind] = -np.log(c2_r[ind]-dc_et[ind]) c2_y11[ind] = F0 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if np.any( ( (q == F0) & ( ((jxi) & (et == F0)) | ((jet) & (xi == F0)) ) ) | (c2_r == F0) ): raise Exception('singular problems: 2') # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # ub subroutine # part B of displacement and strain at depth due to buried # faults in semi-infinite medium rd = c2_r + c2_d if np.any(rd < 1e-14): raise Exception('ub %f %f %f %f %f %f' % ( rd, c2_r, c2_d, xi, et, q )) ai3 = 0.0 ai4 = 0.0 if(c0_cd != F0): # xx replaces x in original subroutine xx = np.sqrt(xi*xi+q*q) ai4 = F1/c0_cdcd * (xi/rd*c0_sdcd + F2*np.arctan( ( et*(xx+q*c0_cd) + xx*(c2_r+xx)*c0_sd ) / (xi*(c2_r+xx)*c0_cd) )) ai4[xi == F0] = F0 ai3 = (c2_y*c0_cd/rd - c2_ale + c0_sd*np.log(rd)) / c0_cdcd else: rd2 = rd*rd ai3 = (et/rd + c2_y*q/rd2 - c2_ale) / F2 ai4 = xi*c2_y/rd2/F2 ai1 = -xi/rd*c0_cd - ai4*c0_sd ai2 = np.log(rd) + ai3*c0_sd qx = q*c2_x11 qy = q*c2_y11 # strike-slip contribution if(disl1 != 0.0): du2x = - xi*qy - c2_tt - c0_alp3 * ai1 * c0_sd du2y = - q/c2_r + c0_alp3*c2_y/rd*c0_sd du2z = q*qy - c0_alp3*ai2*c0_sd du2 = vmath.Vector3(du2x, du2y, du2z) dub = du2 * (disl1 / PI2) else: dub = vmath.Vector3() # dip-slip contribution if(disl2 != F0): du2x = - q/c2_r + c0_alp3 * ai3 * c0_sdcd du2y = - et*qx - c2_tt - c0_alp3 * xi / rd * c0_sdcd du2z = q*qx + c0_alp3 * ai4 * c0_sdcd du2 = vmath.Vector3(du2x, du2y, du2z) dub = dub + (du2 * (disl2 / PI2)) # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% dux = dub.x duy = dub.y*c0_cd - dub.z*c0_sd duz = dub.y*c0_sd + dub.z*c0_cd du = vmath.Vector3(dux, duy, duz) if((j+k) != 3): u = + du + u else: u = - du + u return u
import vectormath as vmath import math from PIL import Image, ImageDraw Image.MAX_IMAGE_PIXELS = 1061683200 SCALE = 30 smoothness = 15 gradient = [(0, "#502910"), (35, "#e3b88d"), (50, "#dfdad6")] sobelScale = -0.000000034 light = vmath.Vector3(1, 0.2, 0.8).normalize() ambientPercentage = 0.12
def plot_displacement(self, eq=None, ax=None, wrap=True, mask_opacity=0.2): if eq is not None: assert isinstance(eq, EarthquakeInterferogram) if ax is None: plt.figure() ax = plt.subplot(111) vectorNx = ( np.r_[ 0, np.cumsum( (self.U[0]/self.shape[0],) * self.shape[0] ) ] + self.O[0] ) vectorNy = ( np.r_[ 0, np.cumsum( (self.V[1]/self.shape[1],) * self.shape[1] ) ] + self.O[1] ) DIR = self.displacement_vector grid = self.simulation_grid if eq is None: LOS = vmath.Vector3(0, 0, 1) else: LOS = eq.get_LOS_vector(grid) data = DIR.dot(LOS) data = np.flipud(data.reshape(self.shape, order='F').T) # data[data == 0] = np.nan # data *= self.scaling if wrap and eq is not None: cmap = plt.cm.hsv data = data % eq.satellite_fringe_interval vmin, vmax = 0.0, eq.satellite_fringe_interval else: cmap = plt.cm.jet vmin = np.nanmin(data) vmax = np.nanmax(data) out = ax.pcolormesh( vectorNx, vectorNy, np.ma.masked_where(np.isnan(data), data), vmin=vmin, vmax=vmax, cmap=cmap ), ax.axis('equal') ax.set_xlabel('Easting, m') ax.set_ylabel('Northing, m') cb = plt.colorbar(out[0], ax=ax) cb.set_label('Displacement, m') if eq is not None: mask = eq.plot_mask(ax=ax, opacity=mask_opacity) out = out[0], mask return out