cfs-python 0.1.0__py3-none-any.whl

cfs_lib/coulomb_math.py

@@ -0,0 +1,142 @@
+import numpy as np
+
+def calc_coulomb(strike_m, dip_m, rake_m, friction_m, ss):
+    """
+    Calculates shear, normal, and Coulomb stresses on a given fault.
+    strike_m, dip_m, rake_m, friction_m: 1D numpy arrays of shape (n,)
+    ss: 2D numpy array of shape (6, n) [SXX, SYY, SZZ, SYZ, SXZ, SXY]
+    Returns shear, normal, coulomb (each shape (n,))
+    """
+    n = len(strike_m)
+    friction = float(friction_m[0]) if isinstance(friction_m, np.ndarray) else friction_m
+
+    # adjustment for coordinate system from Aki & Richards
+    c1 = strike_m >= 180.0
+    c2 = strike_m < 180.0
+    
+    strike = (strike_m - 180.0) * c1 + strike_m * c2
+    dip = -1.0 * dip_m * c1 + dip_m * c2
+    rake_m = rake_m - 90.0
+    
+    c1 = rake_m <= -180.0
+    c2 = rake_m > -180.0
+    rake = (360.0 + rake_m) * c1 + rake_m * c2
+    
+    strike = np.deg2rad(strike)
+    dip = np.deg2rad(dip)
+    rake = np.deg2rad(rake)
+    
+    # Rake rotation
+    rsc = -rake
+    mtran = np.zeros((3, 3, n), dtype=np.float64)
+    # create xrotate matrix for each n
+    # rr = makehgtform('xrotate', rsc); in python:
+    # [1, 0, 0; 0, cos(a), -sin(a); 0, sin(a), cos(a)]
+    for i in range(n):
+        c_a = np.cos(rsc[i])
+        s_a = np.sin(rsc[i])
+        mtran[:, :, i] = np.array([
+            [1.0, 0.0, 0.0],
+            [0.0, c_a, -s_a],
+            [0.0, s_a, c_a]
+        ])
+
+    ver = np.pi / 2.0
+    
+    c1 = strike >= 0.0
+    c2 = strike < 0.0
+    c3 = strike <= ver
+    c4 = strike > ver
+    
+    c24 = c2 | c4
+    
+    d1 = dip >= 0.0
+    d2 = dip < 0.0
+    
+    xbeta = -1.0 * strike * d1 + (np.pi - strike) * d2
+    ybeta = (np.pi - strike) * d1 + -1.0 * strike * d2
+    zbeta = (ver - strike) * d1 + (-1.0 * ver - strike) * d2 * c1 * c3 + (np.pi + ver - strike) * d2 * c24
+    
+    xdel = ver - np.abs(dip)
+    ydel = np.abs(dip)
+    zdel = np.zeros(n)
+    
+    xl = np.cos(xdel) * np.cos(xbeta)
+    xm = np.cos(xdel) * np.sin(xbeta)
+    xn = np.sin(xdel)
+    yl = np.cos(ydel) * np.cos(ybeta)
+    ym = np.cos(ydel) * np.sin(ybeta)
+    yn = np.sin(ydel)
+    zl = np.cos(zdel) * np.cos(zbeta)
+    zm = np.cos(zdel) * np.sin(zbeta)
+    zn = np.sin(zdel)
+    
+    t = np.zeros((6, 6, n), dtype=np.float64)
+    
+    t[0, 0, :] = xl * xl
+    t[0, 1, :] = xm * xm
+    t[0, 2, :] = xn * xn
+    t[0, 3, :] = 2.0 * xm * xn
+    t[0, 4, :] = 2.0 * xn * xl
+    t[0, 5, :] = 2.0 * xl * xm
+    
+    t[1, 0, :] = yl * yl
+    t[1, 1, :] = ym * ym
+    t[1, 2, :] = yn * yn
+    t[1, 3, :] = 2.0 * ym * yn
+    t[1, 4, :] = 2.0 * yn * yl
+    t[1, 5, :] = 2.0 * yl * ym
+    
+    t[2, 0, :] = zl * zl
+    t[2, 1, :] = zm * zm
+    t[2, 2, :] = zn * zn
+    t[2, 3, :] = 2.0 * zm * zn
+    t[2, 4, :] = 2.0 * zn * zl
+    t[2, 5, :] = 2.0 * zl * zm
+    
+    t[3, 0, :] = yl * zl
+    t[3, 1, :] = ym * zm
+    t[3, 2, :] = yn * zn
+    t[3, 3, :] = ym * zn + zm * yn
+    t[3, 4, :] = yn * zl + zn * yl
+    t[3, 5, :] = yl * zm + zl * ym
+    
+    t[4, 0, :] = zl * xl
+    t[4, 1, :] = zm * xm
+    t[4, 2, :] = zn * xn
+    t[4, 3, :] = xm * zn + zm * xn
+    t[4, 4, :] = xn * zl + zn * xl
+    t[4, 5, :] = xl * zm + zl * xm
+    
+    t[5, 0, :] = xl * yl
+    t[5, 1, :] = xm * ym
+    t[5, 2, :] = xn * yn
+    t[5, 3, :] = xm * yn + ym * xn
+    t[5, 4, :] = xn * yl + yn * xl
+    t[5, 5, :] = xl * ym + yl * xm
+    
+    sn = np.zeros((6, n), dtype=np.float64)
+    sn9 = np.zeros((3, 3, n), dtype=np.float64)
+    
+    for k in range(n):
+        sn[:, k] = np.dot(t[:, :, k], ss[:, k])
+        
+        sn9[0, 0, k] = sn[0, k]
+        sn9[0, 1, k] = sn[5, k]
+        sn9[0, 2, k] = sn[4, k]
+        
+        sn9[1, 0, k] = sn[5, k]
+        sn9[1, 1, k] = sn[1, k]
+        sn9[1, 2, k] = sn[3, k]
+        
+        sn9[2, 0, k] = sn[4, k]
+        sn9[2, 1, k] = sn[3, k]
+        sn9[2, 2, k] = sn[2, k]
+        
+        sn9[:, :, k] = np.dot(sn9[:, :, k], mtran[:, :, k])
+        
+    shear = sn9[0, 1, :]
+    normal = sn9[0, 0, :]
+    coulomb = shear + friction * normal
+    
+    return shear, normal, coulomb

cfs_lib/io_parser.py

@@ -0,0 +1,165 @@
+import re
+import numpy as np
+
+def open_input_file_cui(filename):
+    """
+    Parses a Coulomb 3.3 format text file.
+    Returns: xvec, yvec, z, el, kode, pois, young, cdepth, fric, rstress
+    """
+    with open(filename, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = f.readlines()
+        
+    num = 0
+    pois = 0.25
+    cdepth = 7.5
+    young = 8e5
+    fric = 0.4
+    rstress = [0.0, 0.0, 0.0]
+    
+    grid = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # xstart, ystart, xend, yend, xinc, yinc
+    map_info = {}
+    cross_section = {}
+    
+    in_fault_elements = False
+    in_grid_params = False
+    faults = []
+    
+    for i, line in enumerate(lines):
+        # We need to read PR1, YOUNG'S, FRIC. COEFFICIENT, SIGMA1-SIGMA3, Grid parameters
+        up_line = line.upper()
+        
+        if "PR1=" in up_line:
+            parts = line.split()
+            try:
+                pois = float(parts[1])
+                cdepth = float(parts[5])
+            except: pass
+                
+        if "YOUNG'S MODULUS" in up_line:
+            try: young = float(line.split()[0])
+            except: pass
+            
+        if "FRIC. COEFFICIENT" in up_line:
+            try: fric = float(line.split()[0])
+            except: pass
+            
+        if "SIGMA1-SIGMA3" in up_line:
+            floats = [float(s) for s in re.findall(r'-?\d+\.?\d*', line)]
+            if len(floats) >= 3:
+                rstress = floats[:3]
+                
+        if "X-START" in up_line:
+            in_grid_params = True
+            
+        if "XXX" in up_line:
+            in_fault_elements = not in_fault_elements
+            continue
+
+        if in_fault_elements:
+            parts = line.split()
+            if len(parts) >= 11:
+                try:
+                    xs, ys, xf, yf = map(float, parts[1:5])
+                    kode = int(parts[5])
+                    
+                    if "RAKE" in " ".join(lines).upper():
+                        rake, netslip, dip, top, bottom = map(float, parts[6:11])
+                        latslip = np.cos(np.deg2rad(rake)) * netslip * -1.0
+                        dipslip = np.sin(np.deg2rad(rake)) * netslip
+                    else:
+                        latslip, dipslip, dip, top, bottom = map(float, parts[6:11])
+                        
+                    faults.append([xs, ys, xf, yf, latslip, dipslip, dip, top, bottom, kode])
+                except ValueError:
+                    pass
+
+        # reading grid info
+        if "CROSS SECTION DEFAULT" in up_line:
+            in_grid_params = False
+            in_fault_elements = False
+            continue
+        elif "MAP INFO" in up_line:
+            in_grid_params = False
+            in_fault_elements = False
+            continue
+
+        if in_grid_params and "=" in line:
+            parts = line.split("=")
+            if len(parts) == 2:
+                try:
+                    val = float(parts[1].split()[0])
+                    if "X-start" in up_line: grid[0] = val
+                    elif "Y-start" in up_line: grid[1] = val
+                    elif "X-finish" in up_line: grid[2] = val
+                    elif "Y-finish" in up_line: grid[3] = val
+                    elif "X-inc" in up_line: grid[4] = val
+                    elif "Y-inc" in up_line:
+                        grid[5] = val
+                        in_grid_params = False
+                except:
+                    pass
+
+        # We can just look for specific keywords for map info and cross section
+        if "=" in line:
+            parts = line.split("=")
+            if len(parts) == 2:
+                try:
+                    val = float(parts[1].split()[0])
+                    # Cross section
+                    if "START-X" in up_line and "DEFAULT" not in up_line and not in_grid_params: cross_section["start_x"] = val
+                    elif "START-Y" in up_line and not in_grid_params: cross_section["start_y"] = val
+                    elif "FINISH-X" in up_line and not in_grid_params: cross_section["finish_x"] = val
+                    elif "FINISH-Y" in up_line and not in_grid_params: cross_section["finish_y"] = val
+                    
+                    # Map Info
+                    elif "MIN. LON" in up_line: map_info["min_lon"] = val
+                    elif "MAX. LON" in up_line: map_info["max_lon"] = val
+                    elif "ZERO LON" in up_line: map_info["zero_lon"] = val
+                    elif "MIN. LAT" in up_line: map_info["min_lat"] = val
+                    elif "MAX. LAT" in up_line: map_info["max_lat"] = val
+                    elif "ZERO LAT" in up_line: map_info["zero_lat"] = val
+                except:
+                    pass
+
+    if len(faults) == 0:
+        raise ValueError("No valid faults found in the input file.")
+        
+    faults = np.array(faults)
+    el = faults[:, :9]
+    kode = faults[:, 9].astype(int)
+    
+    # safeguard grid increments to prevent memory error
+    xin = max(grid[4], 0.001)
+    yin = max(grid[5], 0.001)
+    
+    xvec = np.arange(grid[0], grid[2] + xin*0.5, xin)
+    yvec = np.arange(grid[1], grid[3] + yin*0.5, yin)
+    z = cdepth
+
+    # Default missing map info to 0.0
+    for k in ["min_lon", "max_lon", "zero_lon", "min_lat", "max_lat", "zero_lat"]:
+        if k not in map_info:
+            map_info[k] = 0.0
+
+    return xvec, yvec, z, el, kode, pois, young, cdepth, fric, rstress, map_info, cross_section
+
+
+def open_batch_file(filename):
+    with open(filename, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = f.readlines()
+        
+    data = []
+    for line in lines[2:]:
+        parts = line.split()
+        if len(parts) >= 6:
+            try:
+                data.append([float(x) for x in parts[:6]])
+            except: pass
+            
+    data = np.array(data)
+    pos = data[:, :3]
+    strike = data[:, 3]
+    dip = data[:, 4]
+    rake = data[:, 5]
+    
+    return pos, strike, dip, rake

cfs_lib/main.py

@@ -0,0 +1,173 @@
+import numpy as np
+from .io_parser import open_input_file_cui, open_batch_file
+from .okada_wrapper import okada_elastic_halfspace
+from .coulomb_math import calc_coulomb
+
+def coulomb_cui(sourceFileName='test.dat', calcFunction='deformation', receiver='30/90/180', batchFileName='test.dat', parse_only=False, grid_params=None):
+    """
+    Python entry point for Coulomb calculations.
+    """
+    # Parse input file
+    try:
+        xvec, yvec, z, el, kode, pois, young, cdepth, fric, rstress = open_input_file_cui(sourceFileName)
+    except FileNotFoundError:
+        print(f"File {sourceFileName} not found.")
+        return None, None
+        
+    # If explicit grid params are provided (e.g. from UI), override the file ones
+    if grid_params:
+        x_start, x_end, x_inc = grid_params['min_x'], grid_params['max_x'], grid_params['inc']
+        y_start, y_end, y_inc = grid_params['min_y'], grid_params['max_y'], grid_params['inc']
+        cdepth = grid_params['depth']
+        
+        # recreate xvec, yvec
+        xvec = np.arange(x_start, x_end + x_inc, x_inc)
+        yvec = np.arange(y_start, y_end + y_inc, y_inc)
+    
+    if parse_only:
+        # Just return the faults and grid params for UI preview
+        results_dict = {
+            "faults": el.tolist(),
+            "x": xvec.tolist(),
+            "y": yvec.tolist(),
+            "cdepth": cdepth
+        }
+        return "parsed", results_dict
+        return None
+        
+    if calcFunction == 'deformation':
+        print(f"Calculating deformation for {sourceFileName}...")
+        dc3d = okada_elastic_halfspace(xvec, yvec, el, young, pois, cdepth, kode)
+        fout = 'halfspace_def_out.dat'
+        with open(fout, 'w') as f:
+            f.write("x y z ux uy uz sxx syy szz syz sxz sxy\n")
+            f.write("(km) (km) (km) (m) (m) (m) (bar) (bar) (bar) (bar) (bar) (bar)\n")
+            for i in range(dc3d.shape[0]):
+                # print 1:2, 5:14 (0-based: 0, 1 and 4-13)
+                row = dc3d[i]
+                arr = [row[0], row[1]] + list(row[4:14])
+                # format string
+                fmt = "".join([f"{x:10.4f}" for x in arr])
+                f.write(fmt + " \n")
+        print(f"Done. Wrote to {fout}")
+        results_dict = {
+            "x": dc3d[:, 0].tolist(),
+            "y": dc3d[:, 1].tolist(),
+            "z": dc3d[:, 4].tolist(),
+            "ux": dc3d[:, 5].tolist(),
+            "uy": dc3d[:, 6].tolist(),
+            "uz": dc3d[:, 7].tolist(),
+            "sxx": dc3d[:, 8].tolist(),
+            "syy": dc3d[:, 9].tolist(),
+            "szz": dc3d[:, 10].tolist(),
+            "syz": dc3d[:, 11].tolist(),
+            "sxz": dc3d[:, 12].tolist(),
+            "sxy": dc3d[:, 13].tolist(),
+            "faults": el.tolist()
+        }
+        return fout, results_dict
+        
+    elif calcFunction == 'coulomb':
+        print(f"Calculating coulomb for {sourceFileName} at {receiver}...")
+        dc3d = okada_elastic_halfspace(xvec, yvec, el, young, pois, cdepth, kode)
+        
+        parts = receiver.split('/')
+        strike_m = float(parts[0]) * np.ones(dc3d.shape[0])
+        dip_m = float(parts[1]) * np.ones(dc3d.shape[0])
+        rake_m = float(parts[2]) * np.ones(dc3d.shape[0])
+        friction_m = fric * np.ones(dc3d.shape[0])
+        
+        # passed array: ss is dc3d(:, 9:14)' -> shape (6, ncell) in MATLAB
+        # python dc3d is shape (n, 14), 8-13 is stress (sxx_n to sxy_n)
+        ss = dc3d[:, 8:14].T
+        
+        shear, normal, coulomb = calc_coulomb(strike_m, dip_m, rake_m, friction_m, ss)
+        
+        fout = 'coulomb_out.dat'
+        with open(fout, 'w') as f:
+            f.write("x y z strike dip rake shear normal coulomb\n")
+            f.write("(km) (km) (km) (deg) (deg) (deg) (bar) (bar) (bar)\n")
+            for i in range(dc3d.shape[0]):
+                f.write(f"{dc3d[i,0]:10.4f}{dc3d[i,1]:10.4f}{dc3d[i,4]:10.4f}")
+                f.write(f"{strike_m[i]:7.1f}{dip_m[i]:6.1f}{rake_m[i]:8.1f}")
+                f.write(f"{shear[i]:10.4f}{normal[i]:10.4f}{coulomb[i]:10.4f} \n")
+        print(f"Done. Wrote to {fout}")
+        results_dict = {
+            "x": dc3d[:, 0].tolist(),
+            "y": dc3d[:, 1].tolist(),
+            "z": dc3d[:, 4].tolist(),
+            "ux": dc3d[:, 5].tolist(),
+            "uy": dc3d[:, 6].tolist(),
+            "uz": dc3d[:, 7].tolist(),
+            "sxx": dc3d[:, 8].tolist(),
+            "syy": dc3d[:, 9].tolist(),
+            "szz": dc3d[:, 10].tolist(),
+            "syz": dc3d[:, 11].tolist(),
+            "sxz": dc3d[:, 12].tolist(),
+            "sxy": dc3d[:, 13].tolist(),
+            "shear": shear.tolist(),
+            "normal": normal.tolist(),
+            "coulomb": coulomb.tolist(),
+            "faults": el.tolist()
+        }
+        return fout, results_dict
+        
+    elif calcFunction == 'batch':
+        print(f"Calculating batch from {batchFileName} using {sourceFileName}...")
+        try:
+            pos, strike_m, dip_m, rake_m = open_batch_file(batchFileName)
+        except FileNotFoundError:
+            print(f"Batch file {batchFileName} not found.")
+            return None
+            
+        x_g, y_g, z_g = pos[:, 0], pos[:, 1], pos[:, 2] # actually -z in okada
+        cdepth_i = -z_g 
+        
+        # call okada_elastic_halfspace with all points
+        res = okada_elastic_halfspace(x_g, y_g, el, young, pois, cdepth_i, kode)
+        dc3d = res
+        
+        # res shape (n_batch, 14), ss needed shape (6, n_batch) -> 8:14 transposed
+        ss = res[:, 8:14].T
+        
+        s, n_s, c = calc_coulomb(strike_m, dip_m, rake_m, np.full(pos.shape[0], fric), ss)
+        shear = s
+        normal = n_s
+        coulomb = c
+            
+        fout = 'coulomb_out.dat'
+        with open(fout, 'w') as f:
+            f.write("x y z strike dip rake shear normal coulomb\n")
+            f.write("(km) (km) (km) (deg) (deg) (deg) (bar) (bar) (bar)\n")
+            for i in range(dc3d.shape[0]):
+                f.write(f"{dc3d[i,0]:10.4f}{dc3d[i,1]:10.4f}{dc3d[i,4]:10.4f}")
+                f.write(f"{strike_m[i]:7.1f}{dip_m[i]:6.1f}{rake_m[i]:8.1f}")
+                f.write(f"{shear[i]:10.4f}{normal[i]:10.4f}{coulomb[i]:10.4f} \n")
+        print(f"Done. Wrote to {fout}")
+        results_dict = {
+            "x": dc3d[:, 0].tolist(),
+            "y": dc3d[:, 1].tolist(),
+            "z": dc3d[:, 4].tolist(),
+            "ux": dc3d[:, 5].tolist(),
+            "uy": dc3d[:, 6].tolist(),
+            "uz": dc3d[:, 7].tolist(),
+            "sxx": dc3d[:, 8].tolist(),
+            "syy": dc3d[:, 9].tolist(),
+            "szz": dc3d[:, 10].tolist(),
+            "syz": dc3d[:, 11].tolist(),
+            "sxz": dc3d[:, 12].tolist(),
+            "sxy": dc3d[:, 13].tolist(),
+            "shear": shear.tolist(),
+            "normal": normal.tolist(),
+            "coulomb": coulomb.tolist(),
+            "faults": el.tolist()
+        }
+        return fout, results_dict
+    else:
+        print("Invalid calcFunction")
+        return None, None
+        
+if __name__ == "__main__":
+    import sys
+    # test defaults
+    coulomb_cui()