reframodel 2025.11.1__tar.gz

reframodel-2025.11.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reframodel-2025.11.1/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include RefraModel *.py
+recursive-exclude RefraModel __pycache__
+recursive-exclude RefraModel *.pyc
+recursive-exclude RefraModel *.pyo

reframodel-2025.11.1/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: reframodel
+Version: 2025.11.1
+Summary: Seismic refraction modeling and inversion tool
+Author-email: Hermann Zeyen <hermann.zeyen@universite-paris-saclay.fr>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/HZeyen/reframodel
+Project-URL: Documentation, https://github.com/HZeyen/reframodel/wiki
+Project-URL: Repository, https://github.com/HZeyen/reframodel
+Project-URL: Issues, https://github.com/HZeyen/reframodel/issues
+Keywords: seismic,refraction,geophysics,inversion,modeling
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: PyQt5>=5.15.0
+Requires-Dist: pygimli>=1.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# RefraModel
+
+Seismic refraction modeling and inversion tool using PyGIMLi.
+
+## Features
+
+- Interactive geological model builder
+- Visual model editing and manipulation
+- Forward modeling of seismic refraction data
+- Inversion with flexible regularization
+- Body-specific velocity constraints
+- Anisotropic smoothing support
+
+## Installation
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/reframodel.git
+cd reframodel
+pip install -e .
+```
+
+### From PyPI (when published)
+
+```bash
+pip install reframodel
+```
+
+## Usage
+
+After installation, run the application:
+
+```bash
+reframodel
+```
+
+Or as a Python module:
+
+```bash
+python -m RefraModel
+```
+
+## Requirements
+
+- Python >= 3.8
+- numpy >= 1.20.0
+- matplotlib >= 3.3.0
+- PyQt5 >= 5.15.0
+- pygimli >= 1.3.0
+
+## License
+
+MIT License
+
+## Author
+
+Hermann Zeyen, University Paris-Saclay <hermann.zeyen@universite-paris-saclay.fr>

reframodel-2025.11.1/README.md

@@ -0,0 +1,58 @@
+# RefraModel
+
+Seismic refraction modeling and inversion tool using PyGIMLi.
+
+## Features
+
+- Interactive geological model builder
+- Visual model editing and manipulation
+- Forward modeling of seismic refraction data
+- Inversion with flexible regularization
+- Body-specific velocity constraints
+- Anisotropic smoothing support
+
+## Installation
+
+### From source
+
+```bash
+git clone https://github.com/yourusername/reframodel.git
+cd reframodel
+pip install -e .
+```
+
+### From PyPI (when published)
+
+```bash
+pip install reframodel
+```
+
+## Usage
+
+After installation, run the application:
+
+```bash
+reframodel
+```
+
+Or as a Python module:
+
+```bash
+python -m RefraModel
+```
+
+## Requirements
+
+- Python >= 3.8
+- numpy >= 1.20.0
+- matplotlib >= 3.3.0
+- PyQt5 >= 5.15.0
+- pygimli >= 1.3.0
+
+## License
+
+MIT License
+
+## Author
+
+Hermann Zeyen, University Paris-Saclay <hermann.zeyen@universite-paris-saclay.fr>

reframodel-2025.11.1/RefraModel/__init__.py

@@ -0,0 +1,4 @@
+"""
+RefraModel - Seismic refraction modeling and inversion
+"""
+__version__ = "25.11.1"

reframodel-2025.11.1/RefraModel/__main__.py

@@ -0,0 +1,7 @@
+"""
+Entry point for running RefraModel as a module: python -m reframodel
+"""
+from .main import main
+
+if __name__ == "__main__":
+    main()

reframodel-2025.11.1/RefraModel/editors/body_editor.py

@@ -0,0 +1,20 @@
+"""
+Body editing operations for geological model
+"""
+from ..geometry.bodies import BodyManager
+
+
+class BodyEditor:
+    """Handles editing of geological bodies"""
+    
+    def __init__(self):
+        self.body_manager = BodyManager()
+    
+    def edit_body(self, body_index, new_properties):
+        """Edit properties of a specific body"""
+        if 0 <= body_index < len(self.body_manager.bodies):
+            body = self.body_manager.bodies[body_index]
+            body.update(new_properties)
+            print(f"Updated body {body_index} with properties: {new_properties}")
+        else:
+            print("Body index out of range.")

reframodel-2025.11.1/RefraModel/editors/node_editor.py

@@ -0,0 +1,20 @@
+"""
+Node editing operations for geological model
+"""
+from ..geometry.points import PointManager
+
+
+class NodeEditor:
+    """Handles editing of nodes (points) in the model"""
+    
+    def __init__(self):
+        self.point_manager = PointManager(0, 100, 0, 100, 1, 1)
+    
+    def edit_node(self, node_index, new_coordinates):
+        """Edit coordinates of a specific node"""
+        if 0 <= node_index < len(self.point_manager.points):
+            point = self.point_manager.points[node_index]
+            point["x"], point["y"] = new_coordinates
+            print(f"Updated node {node_index} to coordinates: {new_coordinates}")
+        else:
+            print("Node index out of range.")

reframodel-2025.11.1/RefraModel/editors/property_editor.py

@@ -0,0 +1,24 @@
+"""
+Property editing operations for geological model
+"""
+from ..geometry.bodies import BodyManager
+
+
+class PropertyEditor:
+    """Handles editing of properties for geological bodies"""
+    
+    def __init__(self):
+        self.body_manager = BodyManager()
+    
+    def edit_property(self, body_index, property_name, new_value):
+        """Edit a specific property of a body"""
+        if 0 <= body_index < len(self.body_manager.bodies):
+            body = self.body_manager.bodies[body_index]
+            if property_name in body["prop_names"]:
+                prop_index = body["prop_names"].index(property_name)
+                body["props"][prop_index] = new_value
+                print(f"Updated property '{property_name}' of body {body_index} to {new_value}")
+            else:
+                print(f"Property '{property_name}' not found in body {body_index}.")
+        else:
+            print("Body index out of range.")

reframodel-2025.11.1/RefraModel/geometry/bodies.py

@@ -0,0 +1,83 @@
+"""
+Body management for geological model
+"""
+import numpy as np
+from matplotlib.path import Path
+
+
+class BodyManager:
+    """Manages geological bodies in the model"""
+    
+    def __init__(self):
+        self.bodies = []
+        self.nbody = -1
+    
+    def append_body(self, lines, directions, para_names, para_values=None, name=None):
+        """Add a new body to the list of bodies"""
+        self.nbody += 1
+        print(f"Body {self.nbody} created")
+        
+        body = {
+            "lines": lines,
+            "sense": directions,
+            "name": name or f"Body_{self.nbody}",
+            "prop_names": para_names,
+            "props": para_values or [0.] * len(para_names),
+            "cuts": [],
+            "constraint": "free",
+            "limits": [0., 10000.],
+            "corr_lengths": [0., 0.]
+        }
+        
+        self.bodies.append(body)
+    
+    def get_polygon(self, nb, points, lines):
+        """Get polygon coordinates for a body"""
+        b = self.bodies[nb]
+        line = lines[b["lines"][0]]
+        
+        if b["sense"][0] > 0:
+            x = [points[line["point1"]]["x"]]
+            y = [points[line["point1"]]["y"]]
+        else:
+            x = [points[line["point2"]]["x"]]
+            y = [points[line["point2"]]["y"]]
+        
+        for j, lin in enumerate(b["lines"]):
+            line = lines[lin]
+            if b["sense"][j] > 0:
+                x.append(points[line["point2"]]["x"])
+                y.append(points[line["point2"]]["y"])
+            else:
+                x.append(points[line["point1"]]["x"])
+                y.append(points[line["point1"]]["y"])
+        
+        return x, y
+    
+    def inside_body(self, xp, yp, points, lines):
+        """Check whether a point is inside a body"""
+        for i, b in enumerate(self.bodies):
+            x, y = self.get_polygon(i, points, lines)
+            path = Path(list(zip(x, y)))
+            if xp is None:
+                return -1, path
+            if path.contains_point((xp, yp)):
+                return i, path
+        return -1, None
+    
+    def get_vel_limits(self):
+        """Calculate minimum and maximum velocities"""
+        if not self.bodies:
+            return 1000., 5000.
+        
+        vmin = self.bodies[0]["props"][0]
+        vmax = vmin
+        for b in self.bodies:
+            vmin = min(vmin, b["props"][0])
+            vmax = max(vmax, b["props"][0])
+        
+        if vmin == vmax:
+            vmin -= 100.
+            vmax += 100.
+        
+        return vmin, vmax

reframodel-2025.11.1/RefraModel/geometry/lines.py

@@ -0,0 +1,94 @@
+"""
+Line management for geological model
+"""
+
+
+class LineManager:
+    """Manages lines connecting points"""
+    
+    def __init__(self):
+        self.lines = []
+        self.nline = -1
+    
+    def append_line(self, pt1, pt2, body=None):
+        """Append a line to the list"""
+        self.nline += 1
+        
+        line = {
+            "point1": pt1,
+            "point2": pt2,
+            "bodies": body or [],
+            "topo": False,
+            "bottom": False,
+            "left": False,
+            "right": False
+        }
+        
+        self.lines.append(line)
+    
+    def find_nearest_line(self, xp, yp, points):
+        """Find line nearest to a point in screen coordinates"""
+        lmin = -1
+        dmin = 1000000000.
+        
+        for i, lin in enumerate(self.lines):
+            pt = points[lin["point1"]]
+            x1 = pt["xscreen"]
+            y1 = pt["yscreen"]
+            pt = points[lin["point2"]]
+            x2 = pt["xscreen"]
+            y2 = pt["yscreen"]
+            
+            xcross, ycross, x_flag = self.crossing(x1, y1, x2, y2, xp, yp)
+            if x_flag:
+                d = (xp - xcross) ** 2 + (yp - ycross) ** 2
+                if d < dmin:
+                    dmin = d
+                    lmin = i
+        
+        return lmin
+    
+    @staticmethod
+    def crossing(x1, y1, x2, y2, xp, yp):
+        """Calculate crossing point of perpendicular line"""
+        dx = x2 - x1
+        dy = y2 - y1
+        
+        if dx == dy == 0:
+            return None, None, False
+        
+        vx = xp - x1
+        vy = yp - y1
+        
+        t = (vx * dx + vy * dy) / (dx ** 2 + dy ** 2)
+        xq = x1 + t * dx
+        yq = y1 + t * dy
+        
+        flag = True
+        if dx > dy:
+            if xq < min(x1, x2) or xq > max(x1, x2):
+                flag = False
+        else:
+            if yq < min(y1, y2) or yq > max(y1, y2):
+                flag = False
+        
+        return xq, yq, flag
+    
+    def check_line_exist(self, x, y, points):
+        """Check if a line already exists"""
+        import numpy as np
+        
+        for i, lin in enumerate(self.lines):
+            x1 = points[lin["point1"]]["x"]
+            x2 = points[lin["point2"]]["x"]
+            y1 = points[lin["point1"]]["y"]
+            y2 = points[lin["point2"]]["y"]
+            
+            if (np.isclose(x[0], x1) and np.isclose(y[0], y1) and
+                    np.isclose(x[1], x2) and np.isclose(y[1], y2)):
+                return i, 1
+            elif (np.isclose(x[1], x1) and np.isclose(y[1], y1) and
+                    np.isclose(x[0], x2) and np.isclose(y[0], y2)):
+                return i, -1
+        
+        return -1, None

reframodel-2025.11.1/RefraModel/geometry/points.py

@@ -0,0 +1,96 @@
+"""
+Point management for geological model
+"""
+import numpy as np
+
+
+class PointManager:
+    """Manages points in the model"""
+    
+    def __init__(self, xmin, xmax, ymin, ymax, eps_x, eps_y):
+        self.points = []
+        self.npoint = -1
+        self.xmin = xmin
+        self.xmax = xmax
+        self.ymin = ymin
+        self.ymax = ymax
+        self.eps_x = eps_x
+        self.eps_y = eps_y
+    
+    def append_point(self, xp, yp, xs, ys, body=None, line=None):
+        """Append a point to the list of points"""
+        self.npoint += 1
+        # Round coordinates to 2 decimals at creation
+        try:
+            xp = float(round(xp, 2))
+            yp = float(round(yp, 2))
+        except Exception:
+            pass
+        
+        point = {
+            "x": xp,
+            "y": yp,
+            "xscreen": xs,
+            "yscreen": ys,
+            "lines": line or [],
+            "bodies": body or [],
+            "topo": False,
+            "bottom": False,
+            "left": False,
+            "right": False
+        }
+        
+        # Check special positions
+        if np.isclose(yp, self.ymin):
+            point["bottom"] = True
+        if xp <= self.xmin + 0.1:
+            point["left"] = True
+        if xp >= self.xmax - 0.01:
+            point["right"] = True
+        
+        self.points.append(point)
+    
+    def find_nearest_point(self, xp, yp):
+        """Find the nearest point to given coordinates"""
+        if not self.points:
+            return -1
+        
+        pmin = -1
+        dmin = 1000000000.
+        
+        for i, p in enumerate(self.points):
+            d = (p["x"] - xp) ** 2 + (p["y"] - yp) ** 2
+            if d < dmin:
+                pmin = i
+                dmin = d
+        
+        return pmin
+    
+    def find_nearest_screen_point(self, xp, yp):
+        """Find nearest point in screen coordinates"""
+        if not self.points:
+            return -1
+        
+        pmin = -1
+        dmin = 1000000000.
+        
+        for i, p in enumerate(self.points):
+            d = (p["xscreen"] - xp) ** 2 + (p["yscreen"] - yp) ** 2
+            if d < dmin:
+                pmin = i
+                dmin = d
+        
+        return pmin
+    
+    def check_close(self, x, y):
+        """Check if point is near existing point"""
+        if not self.points:
+            return x, y, -1
+        
+        for i, p in enumerate(self.points):
+            xb = p["x"]
+            yb = p["y"]
+            if abs(x - xb) < self.eps_x and abs(y - yb) < self.eps_y:
+                return xb, yb, i
+        
+        return x, y, -1