cnchash 1.0.0__tar.gz

cnchash-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Xingchen He
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cnchash-1.0.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: cnchash
+Version: 1.0.0
+Summary: Python implementation of HASH v1.2 for earthquake focal mechanism determination
+Author-email: He XingChen <example@example.com>
+License: BSD 3-Clause
+Project-URL: Homepage, https://github.com/Chuan1937/NCHASH
+Project-URL: Documentation, https://cnchash.readthedocs.io
+Project-URL: Repository, https://github.com/Chuan1937/NCHASH
+Project-URL: Issues, https://github.com/Chuan1937/NCHASH/issues
+Keywords: seismology,earthquake,focal-mechanism,hash,beachball,p-wave,polarity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: numba>=0.56.0
+Requires-Dist: scipy>=1.7.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: myst-parser>=1.0; extra == "docs"
+Dynamic: license-file
+
+# NCHASH
+
+Python implementation of HASH for earthquake focal mechanism determination from P-wave polarities.
+
+![Python](https://img.shields.io/badge/python-3.10+-orange.svg)
+![License](https://img.shields.io/badge/license-BSD%203--blue.svg)
+![Numba](https://img.shields.io/badge/numba-0.53+-red.svg)
+![Numpy](https://img.shields.io/badge/numpy-1.19+-yellow.svg)
+![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)
+
+Python uses Numba JIT compilation optimization and vectorization, achieving speed improvements while maintaining complete consistency with the core Fortran algorithm.
+
+![Speed Comparison](docs/images/speed_comparison.png)
+
+## Performance
+
+| Metric | Python+Numba | Fortran | Speedup |
+|--------|-------------|---------|---------|
+| 24 events | 0.068s | 0.473s | **6.9x** |
+| Per event | 2.85ms | 19.7ms | **6.9x** |
+| 1000 events | 2.6s | 19.7s | **7.5x** |
+
+### For comprehensive benchmarks and analysis:
+
+![Comprehensive Comparison](docs/images/comprehensive_comparison.png)
+
+## Accuracy Verification
+
+![Accuracy Verification](docs/images/accuracy_verification.png)
+
+**Key Results:**
+- Dip error median: < 10° 
+- Rake error median: < 15° 
+- Core algorithm matches Fortran exactly 
+
+**Note:** Strike differences (40-80°) are normal - focal mechanisms have two orthogonal nodal planes that both satisfy polarity data.
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+```
+
+### Basic Usage (P-wave polarities only)
+
+```python
+from nchash import run_hash
+import numpy as np
+
+# Azimuths, takeoff angles, polarities, quality
+p_azi = np.array([45.0, 135.0, 225.0, 315.0])
+p_the = np.array([30.0, 45.0, 60.0, 75.0])
+p_pol = np.array([1, -1, 1, -1])  # 1=up, -1=down
+p_qual = np.array([0, 0, 0, 0])
+
+result = run_hash(p_azi, p_the, p_pol, p_qual)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+```
+
+### With S/P Amplitude Ratio
+
+```python
+from nchash import run_hash_with_amp
+import numpy as np
+
+# Same inputs as above, plus S/P amplitude ratios (log10 scale)
+# sp_amp = 0.0 means no amplitude data for that station
+sp_amp = np.array([0.3, -0.2, 0.5, 0.0])  # log10(S/P), 0.0 = no data
+
+result = run_hash_with_amp(p_azi, p_the, p_pol, sp_amp)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+print(f"Polarity misfit: {result['mfrac']*100:.1f}%")
+print(f"Amplitude misfit: {result['mavg']:.2f}")
+```
+
+## Features
+
+- Grid search for focal mechanism determination
+- Monte Carlo uncertainty analysis
+- S/P amplitude ratio constraint
+- Quality rating (A-D, E, F)
+- Multiple phase file formats
+- Core algorithm matches Fortran exactly
+
+## Documentation
+
+See [docs/README.md](docs/README.md) for full documentation including:
+- API reference
+- Algorithm details
+- File format specifications
+- Performance optimization
+
+## Run Tests
+
+```bash
+jupyter notebook HASH_Tests.ipynb
+```
+
+## Project Structure
+
+```
+nchash/
+├── core.py        # Grid search algorithm (focalmc)
+├── amp_subs.py    # S/P amplitude ratio (focalamp_mc)
+├── uncertainty.py # Uncertainty analysis (mech_prob)
+├── driver.py      # Main driver (run_hash, run_hash_with_amp)
+├── io.py          # File I/O
+└── utils.py       # Utilities
+
+HASH_complete/     # Complete Fortran code with examples
+```
+
+## Author
+
+He XingChen
+
+## License
+
+BSD 3-Clause
+
+## References
+
+Hardebeck, Jeanne L. and Peter M. Shearer, A new method for determining first-motion
+focal mechanisms, Bulletin of the Seismological Society of America, 92,
+2264-2276, 2002.
+
+Hardebeck, Jeanne L. and Peter M. Shearer, Using S/P Amplitude Ratios to
+Constrain the Focal Mechanisms of Small Earthquakes, Bulletin of the
+Seismological Society of America, 93, 2434-2444, 2003.

cnchash-1.0.0/README.md

@@ -0,0 +1,137 @@
+# NCHASH
+
+Python implementation of HASH for earthquake focal mechanism determination from P-wave polarities.
+
+![Python](https://img.shields.io/badge/python-3.10+-orange.svg)
+![License](https://img.shields.io/badge/license-BSD%203--blue.svg)
+![Numba](https://img.shields.io/badge/numba-0.53+-red.svg)
+![Numpy](https://img.shields.io/badge/numpy-1.19+-yellow.svg)
+![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)
+
+Python uses Numba JIT compilation optimization and vectorization, achieving speed improvements while maintaining complete consistency with the core Fortran algorithm.
+
+![Speed Comparison](docs/images/speed_comparison.png)
+
+## Performance
+
+| Metric | Python+Numba | Fortran | Speedup |
+|--------|-------------|---------|---------|
+| 24 events | 0.068s | 0.473s | **6.9x** |
+| Per event | 2.85ms | 19.7ms | **6.9x** |
+| 1000 events | 2.6s | 19.7s | **7.5x** |
+
+### For comprehensive benchmarks and analysis:
+
+![Comprehensive Comparison](docs/images/comprehensive_comparison.png)
+
+## Accuracy Verification
+
+![Accuracy Verification](docs/images/accuracy_verification.png)
+
+**Key Results:**
+- Dip error median: < 10° 
+- Rake error median: < 15° 
+- Core algorithm matches Fortran exactly 
+
+**Note:** Strike differences (40-80°) are normal - focal mechanisms have two orthogonal nodal planes that both satisfy polarity data.
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+```
+
+### Basic Usage (P-wave polarities only)
+
+```python
+from nchash import run_hash
+import numpy as np
+
+# Azimuths, takeoff angles, polarities, quality
+p_azi = np.array([45.0, 135.0, 225.0, 315.0])
+p_the = np.array([30.0, 45.0, 60.0, 75.0])
+p_pol = np.array([1, -1, 1, -1])  # 1=up, -1=down
+p_qual = np.array([0, 0, 0, 0])
+
+result = run_hash(p_azi, p_the, p_pol, p_qual)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+```
+
+### With S/P Amplitude Ratio
+
+```python
+from nchash import run_hash_with_amp
+import numpy as np
+
+# Same inputs as above, plus S/P amplitude ratios (log10 scale)
+# sp_amp = 0.0 means no amplitude data for that station
+sp_amp = np.array([0.3, -0.2, 0.5, 0.0])  # log10(S/P), 0.0 = no data
+
+result = run_hash_with_amp(p_azi, p_the, p_pol, sp_amp)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+print(f"Polarity misfit: {result['mfrac']*100:.1f}%")
+print(f"Amplitude misfit: {result['mavg']:.2f}")
+```
+
+## Features
+
+- Grid search for focal mechanism determination
+- Monte Carlo uncertainty analysis
+- S/P amplitude ratio constraint
+- Quality rating (A-D, E, F)
+- Multiple phase file formats
+- Core algorithm matches Fortran exactly
+
+## Documentation
+
+See [docs/README.md](docs/README.md) for full documentation including:
+- API reference
+- Algorithm details
+- File format specifications
+- Performance optimization
+
+## Run Tests
+
+```bash
+jupyter notebook HASH_Tests.ipynb
+```
+
+## Project Structure
+
+```
+nchash/
+├── core.py        # Grid search algorithm (focalmc)
+├── amp_subs.py    # S/P amplitude ratio (focalamp_mc)
+├── uncertainty.py # Uncertainty analysis (mech_prob)
+├── driver.py      # Main driver (run_hash, run_hash_with_amp)
+├── io.py          # File I/O
+└── utils.py       # Utilities
+
+HASH_complete/     # Complete Fortran code with examples
+```
+
+## Author
+
+He XingChen
+
+## License
+
+BSD 3-Clause
+
+## References
+
+Hardebeck, Jeanne L. and Peter M. Shearer, A new method for determining first-motion
+focal mechanisms, Bulletin of the Seismological Society of America, 92,
+2264-2276, 2002.
+
+Hardebeck, Jeanne L. and Peter M. Shearer, Using S/P Amplitude Ratios to
+Constrain the Focal Mechanisms of Small Earthquakes, Bulletin of the
+Seismological Society of America, 93, 2434-2444, 2003.

cnchash-1.0.0/cnchash.egg-info/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: cnchash
+Version: 1.0.0
+Summary: Python implementation of HASH v1.2 for earthquake focal mechanism determination
+Author-email: He XingChen <example@example.com>
+License: BSD 3-Clause
+Project-URL: Homepage, https://github.com/Chuan1937/NCHASH
+Project-URL: Documentation, https://cnchash.readthedocs.io
+Project-URL: Repository, https://github.com/Chuan1937/NCHASH
+Project-URL: Issues, https://github.com/Chuan1937/NCHASH/issues
+Keywords: seismology,earthquake,focal-mechanism,hash,beachball,p-wave,polarity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: numba>=0.56.0
+Requires-Dist: scipy>=1.7.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Requires-Dist: myst-parser>=1.0; extra == "docs"
+Dynamic: license-file
+
+# NCHASH
+
+Python implementation of HASH for earthquake focal mechanism determination from P-wave polarities.
+
+![Python](https://img.shields.io/badge/python-3.10+-orange.svg)
+![License](https://img.shields.io/badge/license-BSD%203--blue.svg)
+![Numba](https://img.shields.io/badge/numba-0.53+-red.svg)
+![Numpy](https://img.shields.io/badge/numpy-1.19+-yellow.svg)
+![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)
+
+Python uses Numba JIT compilation optimization and vectorization, achieving speed improvements while maintaining complete consistency with the core Fortran algorithm.
+
+![Speed Comparison](docs/images/speed_comparison.png)
+
+## Performance
+
+| Metric | Python+Numba | Fortran | Speedup |
+|--------|-------------|---------|---------|
+| 24 events | 0.068s | 0.473s | **6.9x** |
+| Per event | 2.85ms | 19.7ms | **6.9x** |
+| 1000 events | 2.6s | 19.7s | **7.5x** |
+
+### For comprehensive benchmarks and analysis:
+
+![Comprehensive Comparison](docs/images/comprehensive_comparison.png)
+
+## Accuracy Verification
+
+![Accuracy Verification](docs/images/accuracy_verification.png)
+
+**Key Results:**
+- Dip error median: < 10° 
+- Rake error median: < 15° 
+- Core algorithm matches Fortran exactly 
+
+**Note:** Strike differences (40-80°) are normal - focal mechanisms have two orthogonal nodal planes that both satisfy polarity data.
+
+## Quick Start
+
+```bash
+pip install -r requirements.txt
+```
+
+### Basic Usage (P-wave polarities only)
+
+```python
+from nchash import run_hash
+import numpy as np
+
+# Azimuths, takeoff angles, polarities, quality
+p_azi = np.array([45.0, 135.0, 225.0, 315.0])
+p_the = np.array([30.0, 45.0, 60.0, 75.0])
+p_pol = np.array([1, -1, 1, -1])  # 1=up, -1=down
+p_qual = np.array([0, 0, 0, 0])
+
+result = run_hash(p_azi, p_the, p_pol, p_qual)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+```
+
+### With S/P Amplitude Ratio
+
+```python
+from nchash import run_hash_with_amp
+import numpy as np
+
+# Same inputs as above, plus S/P amplitude ratios (log10 scale)
+# sp_amp = 0.0 means no amplitude data for that station
+sp_amp = np.array([0.3, -0.2, 0.5, 0.0])  # log10(S/P), 0.0 = no data
+
+result = run_hash_with_amp(p_azi, p_the, p_pol, sp_amp)
+
+print(f"Strike: {result['strike_avg']:.1f}")
+print(f"Dip: {result['dip_avg']:.1f}")
+print(f"Rake: {result['rake_avg']:.1f}")
+print(f"Quality: {result['quality']}")
+print(f"Polarity misfit: {result['mfrac']*100:.1f}%")
+print(f"Amplitude misfit: {result['mavg']:.2f}")
+```
+
+## Features
+
+- Grid search for focal mechanism determination
+- Monte Carlo uncertainty analysis
+- S/P amplitude ratio constraint
+- Quality rating (A-D, E, F)
+- Multiple phase file formats
+- Core algorithm matches Fortran exactly
+
+## Documentation
+
+See [docs/README.md](docs/README.md) for full documentation including:
+- API reference
+- Algorithm details
+- File format specifications
+- Performance optimization
+
+## Run Tests
+
+```bash
+jupyter notebook HASH_Tests.ipynb
+```
+
+## Project Structure
+
+```
+nchash/
+├── core.py        # Grid search algorithm (focalmc)
+├── amp_subs.py    # S/P amplitude ratio (focalamp_mc)
+├── uncertainty.py # Uncertainty analysis (mech_prob)
+├── driver.py      # Main driver (run_hash, run_hash_with_amp)
+├── io.py          # File I/O
+└── utils.py       # Utilities
+
+HASH_complete/     # Complete Fortran code with examples
+```
+
+## Author
+
+He XingChen
+
+## License
+
+BSD 3-Clause
+
+## References
+
+Hardebeck, Jeanne L. and Peter M. Shearer, A new method for determining first-motion
+focal mechanisms, Bulletin of the Seismological Society of America, 92,
+2264-2276, 2002.
+
+Hardebeck, Jeanne L. and Peter M. Shearer, Using S/P Amplitude Ratios to
+Constrain the Focal Mechanisms of Small Earthquakes, Bulletin of the
+Seismological Society of America, 93, 2434-2444, 2003.

cnchash-1.0.0/cnchash.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+cnchash.egg-info/PKG-INFO
+cnchash.egg-info/SOURCES.txt
+cnchash.egg-info/dependency_links.txt
+cnchash.egg-info/entry_points.txt
+cnchash.egg-info/requires.txt
+cnchash.egg-info/top_level.txt
+nchash/__init__.py
+nchash/amp_subs.py
+nchash/cli.py
+nchash/core.py
+nchash/driver.py
+nchash/io.py
+nchash/uncertainty.py
+nchash/utils.py
+nchash/velocity.py

cnchash-1.0.0/cnchash.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cnchash-1.0.0/cnchash.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nchash = nchash.cli:main

cnchash-1.0.0/cnchash.egg-info/requires.txt

@@ -0,0 +1,12 @@
+numpy>=1.20.0
+numba>=0.56.0
+scipy>=1.7.0
+
+[dev]
+ruff>=0.1.0
+pytest>=7.0.0
+
+[docs]
+sphinx>=5.0
+sphinx-rtd-theme>=1.0
+myst-parser>=1.0

cnchash-1.0.0/cnchash.egg-info/top_level.txt

@@ -0,0 +1 @@
+nchash

cnchash-1.0.0/nchash/__init__.py

@@ -0,0 +1,81 @@
+"""
+NCHASH - Python implementation of HASH v1.2 for earthquake focal mechanism inversion.
+
+This package provides a pure Python implementation of the HASH algorithm for
+determining earthquake focal mechanisms from polarities, with performance
+optimizations using numba and numpy.
+
+Author: He XingChen
+License: BSD 3-Clause
+"""
+
+__version__ = "1.0.0"
+__author__ = "He XingChen"
+
+from .amp_subs import (
+    focalamp_mc,
+    get_misf_amp,
+)
+from .core import (
+    focalmc,
+    get_gap,
+    get_misfit,
+)
+from .driver import (
+    run_hash,
+    run_hash_with_amp,
+    run_hash_from_file,
+)
+from .io import (
+    read_phase_file,
+    read_station_file,
+    read_velocity_model,
+    write_mechanism_output,
+)
+from .uncertainty import (
+    mech_avg,
+    mech_prob,
+    mech_rot,
+)
+from .utils import (
+    cross_product,
+    fp_coord,
+    normal_distribution_random,
+    strike_dip_rake_to_vectors,
+    to_cartesian,
+    vectors_to_strike_dip_rake,
+)
+from .velocity import (
+    get_tts,
+    make_table,
+)
+
+__all__ = [
+    # Main functions
+    "run_hash",
+    "run_hash_with_amp",
+    "run_hash_from_file",
+    # Core algorithms
+    "focalmc",
+    "focalamp_mc",
+    "mech_prob",
+    "mech_avg",
+    "mech_rot",
+    # Utilities
+    "get_misfit",
+    "get_misf_amp",
+    "get_gap",
+    "make_table",
+    "get_tts",
+    "cross_product",
+    "to_cartesian",
+    "fp_coord",
+    "normal_distribution_random",
+    "strike_dip_rake_to_vectors",
+    "vectors_to_strike_dip_rake",
+    # I/O
+    "read_phase_file",
+    "read_station_file",
+    "read_velocity_model",
+    "write_mechanism_output",
+]