diff --git a/.cursorignore b/.cursorignore new file mode 100644 index 0000000..fa3502f --- /dev/null +++ b/.cursorignore @@ -0,0 +1,6 @@ +/docs/ +/.venv/ +/data/ +/img/ +/demo/ +/LICENSE \ No newline at end of file diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml index 6d9b3a8..4f8eecf 100644 --- a/.github/workflows/format.yml +++ b/.github/workflows/format.yml @@ -1,6 +1,6 @@ name: Make sure code is ruff-formatted 🐢 -on: +"on": # Run format checks on pull_request events pull_request: types: [opened, reopened, synchronize, ready_for_review] @@ -14,21 +14,21 @@ jobs: name: Make sure code is ruff-formatted 🐢 runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v4 - - name: Set up Python 3.12 - uses: actions/setup-python@v5 - with: - python-version: '3.12' + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: '3.12' - - name: Install dependencies - shell: bash -el {0} - run: | - python -m pip install --upgrade pip - python -m pip install ruff - python -m pip install -e ".[dev]" + - name: Install dependencies + run: | + # Setup pip + python -m pip install --upgrade pip + # Install dependencies including ruff + python -m pip install -e ".[dev]" - - name: Check formatting with ruff - run: | - python -m ruff format . --check - python -m ruff check . \ No newline at end of file + - name: Check formatting with ruff + run: | + ruff format . --check + ruff check . diff --git a/.github/workflows/pylint.yml b/.github/workflows/pylint.yml index ea575b7..de04f93 100644 --- a/.github/workflows/pylint.yml +++ b/.github/workflows/pylint.yml @@ -1,6 +1,6 @@ name: Static code analysis πŸ”Ž -on: +"on": # Run static code analysis on pull_request events pull_request: types: [opened, reopened, synchronize, ready_for_review] @@ -14,31 +14,54 @@ jobs: name: Static code analysis πŸ”Ž runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v4 - - name: Set up Python 3.12 - uses: actions/setup-python@v5 - with: - python-version: '3.12' + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install pylint - python -m pip install -e ".[dev]" + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e ".[dev]" - - name: Run pylint analysis - # Using .pylintrc with comprehensive configuration for scientific code - run: | - python -m pylint --output-format=parseable --output=pylint-report.txt weac/ tests/ - echo - echo 'Error type counts:' - grep -oP '[A-Z]\d+\([a-z\-]+\)' pylint-report.txt | sort | uniq -c | sort -nr - echo - echo 'Errors per file:' - grep -oP '^[\w\-\/]+\.py' pylint-report.txt | sort | uniq -c | sort -nr - echo - echo 'Total errors:' - grep -oP '^[\w\-\/]+\.py' pylint-report.txt | wc -l - echo - grep 'Your code' pylint-report.txt \ No newline at end of file + - name: Run pylint analysis + # Using repository pylint config (pyproject.toml) with comprehensive settings for scientific code + run: | + exit_code=0 + python -m pylint --output-format=parseable --output=pylint-report.txt weac/ tests/ || exit_code=$? + echo "Pylint finished with exit code $exit_code." + echo + echo "Pylint exit code meaning:" + if [ $exit_code -eq 0 ]; then echo "-> No issues found"; fi + if [ $((exit_code & 1)) -ne 0 ]; then echo "-> Fatal message issued"; fi + if [ $((exit_code & 2)) -ne 0 ]; then echo "-> Error message issued"; fi + if [ $((exit_code & 4)) -ne 0 ]; then echo "-> Warning message issued"; fi + if [ $((exit_code & 8)) -ne 0 ]; then echo "-> Refactor message issued"; fi + if [ $((exit_code & 16)) -ne 0 ]; then echo "-> Convention message issued"; fi + if [ $((exit_code & 32)) -ne 0 ]; then echo "-> Usage error"; fi + echo + + echo 'Error type counts:' + grep -oP '[A-Z]\d+\([a-z\-]+\)' pylint-report.txt | sort | uniq -c | sort -nr + echo + echo 'Errors per file:' + grep -oP '^[\w\-\/]+\.py' pylint-report.txt | sort | uniq -c | sort -nr + echo + echo 'Total errors:' + grep -oP '^[\w\-\/]+\.py' pylint-report.txt | wc -l + echo + grep 'Your code' pylint-report.txt || true + + # Fail on fatal, error, and usage error. + # These are severe and should block PRs. + # Warnings (4), refactors (8), and conventions (16) will not cause a failure. + fail_on_codes=$((1 | 2 | 32)) + if [ $((exit_code & fail_on_codes)) -ne 0 ]; then + echo "Failing CI due to fatal/error/usage messages from pylint." + exit 1 + else + echo "Pylint check passed. No fatal/error/usage messages." + fi diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 1b28f99..af0b6aa 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -1,8 +1,8 @@ name: Run unit tests πŸ€– # Trigger conditions for the workflow -on: - # Run tests on pull_request events +"on": + # Run unit tests on pull_request events pull_request: types: [opened, reopened, synchronize, ready_for_review] # Allow this workflow to be called by other workflows @@ -15,17 +15,20 @@ jobs: name: Run unit tests πŸ€– runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v4 - - name: Set up Python 3.12 - uses: actions/setup-python@v5 - with: - python-version: '3.12' + - name: Set up Python 3.12 + uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: 'pip' + cache-dependency-path: | + pyproject.toml + check-latest: true + - name: Install dependencies + run: | + python -m pip install --upgrade pip + python -m pip install -e . - - name: Install dependencies - run: | - python -m pip install --upgrade pip - python -m pip install -e . - - - name: Run tests - run: python tests/run_tests.py \ No newline at end of file + - name: Run tests + run: python tests/run_tests.py diff --git a/.gitignore b/.gitignore index 2d636d8..6652426 100644 --- a/.gitignore +++ b/.gitignore @@ -18,10 +18,32 @@ dist/ # IDE setup .vscode/ +# Environments +.venv/ +venv/ +.python-version +.weac-reference/ +.venv* + +# Secrets +.env +.env.local +.env.* + +# Caches +.ruff_cache/ +.pytest_cache/ +.mypy_cache/ + +# Coverage +.coverage +coverage.xml # misc *.stats plots/ test/ scratch/ +temp* +old* .weac-reference/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..7171001 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,5 @@ +[submodule "data"] + path = data + url = https://github.com/2phi/weac-data-hub.git + shallow = true + branch = main diff --git a/README.md b/README.md index 05f19ed..e368fa6 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ Report a bug Β· Request a feature Β· Read the docs Β· - Cite the software + Cite the software


@@ -65,6 +65,7 @@ ## Contents + 1. [About the project](#about-the-project) 2. [Installation](#installation) 3. [Usage](#usage) @@ -74,8 +75,6 @@ 7. [License](#license) 8. [Contact](#contact) - - ## About the project @@ -120,11 +119,15 @@ git clone https://github.com/2phi/weac ``` for local use. -Needs (see also [requirements.txt](https://github.com/2phi/weac/blob/main/weac/requirements.txt)): -- [Python](https://www.python.org/downloads/release/python-3100/) ≥ 3.10 -- [Numpy](https://numpy.org/) ≥ 2.0.1 -- [Scipy](https://www.scipy.org/) ≥ 1.14.0 -- [Matplotlib](https://matplotlib.org/) ≥ 3.9.1 +Needs (runtime dependencies are declared in [pyproject.toml](https://github.com/2phi/weac/blob/main/pyproject.toml)): + +- [Python](https://www.python.org/downloads/release/python-3120/) β‰₯ 3.12 +- [Numpy](https://numpy.org/) β‰₯ 2.0.1 +- [Scipy](https://www.scipy.org/) β‰₯ 1.14.0 +- [Matplotlib](https://matplotlib.org/) β‰₯ 3.9.1 +- [Pydantic](https://docs.pydantic.dev/latest/) β‰₯ 2.11.7 +- [Snowpylot](https://github.com/connellymk/snowpylot) β‰₯ 1.1.3 + ## Usage @@ -132,55 +135,141 @@ Needs (see also [requirements.txt](https://github.com/2phi/weac/blob/main/weac/r The following describes the basic usage of WEAC. Please refer to the [demo](https://github.com/2phi/weac/blob/main/demo/demo.ipynb) for more examples and read the [documentation](https://2phi.github.io/weac/) for details. Load the module. + ```python import weac ``` -Choose a snow profile from the database (see [demo](https://github.com/2phi/weac/blob/main/demo/demo.ipynb)) or create your own as a 2D array where the columns are density (kg/m^2) and layer thickness (mm). One row corresponds to one layer counted from top (below surface) to bottom (above weak layer). + +Choose a snow profile from the preconfigured profiles (see `dummy_profiles` in [demo](https://github.com/2phi/weac/blob/main/demo/demo.ipynb)) or create your own using the `Layer` Pydantic class. One row corresponds to one layer counted from top (below surface) to bottom (above weak layer). + ```python -myprofile = [[170, 100], # (1) surface layer - [190, 40], # (2) - [230, 130], # : - [250, 20], # : - [210, 70], # (i) - [380, 20], # : - [280, 100]] # (N) last slab layer above weak layer +from weac.components import Layer + +layers = [ + Layer(rho=170, h=100), # (1) surface layer + Layer(rho=190, h=40), # (2) + Layer(rho=230, h=130), # : + Layer(rho=250, h=20), + Layer(rho=210, h=70), + Layer(rho=380, h=20), # : + Layer(rho=280, h=100) # (N) last slab layer above weak layer +] ``` -Create a model instance with optional custom layering. + +Create a WeakLayer instance that lies underneath the slab. + ```python -skier = weac.Layered(system='skier', layers=myprofile) +from weac.components import WeakLayer + +weak_layer = WeakLayer(rho=125, h=20) ``` -Calculate lists of segment lengths, locations of foundations, and position and magnitude of skier loads from the inputs total length `L` (mm), crack length `a` (mm), and skier weight `m` (kg). We can choose to analyze the situtation before a crack appears even if a crack length > 0 is set by replacing the `'crack'` key thorugh the `'nocrack'` key. + +Create a Scenario that defines the environment and setup that the slab and weak layer will be evaluated in. + ```python -segments = skier.calc_segments(L=10000, a=300, m=80)['crack'] +from weac.components import ScenarioConfig, Segment + +# Example 1: SKIER +skier_config = ScenarioConfig( + system_type='skier', + phi=30, +) +skier_segments = [ + Segment(length=5000, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=80), + Segment(length=0, has_foundation=False, m=0), + Segment(length=5000, has_foundation=True, m=0), +] # Scenario is a skier of 80 kg standing on a 10 meter long slab at a 30 degree angle + +# Exampel 2: PST +pst_config = ScenarioConfig( + system_type='pst-', # Downslope cut + phi=30, # (counterclockwise positive) + cut_length=300, +) +pst_segments = [ + Segment(length=5000, has_foundation=True, m=0), + Segment(length=300, has_foundation=False, m=0), # Crack Segment +] # Scenario is Downslope PST with a 300mm cut ``` -Assemble the system of linear equations and solve the boundary-value problem for the free constants `C` providing the inclination `phi` (counterclockwise positive) in degrees. + +Create a SystemModel instance that combines the inputs and handles system solving and field-quantity extraction. + +```python +from weac.components import Config, ModelInput +from weac.core.system_model import SystemModel + +# Example: build a model for the skier scenario defined above +model_input = ModelInput( + weak_layer=weak_layer, + scenario_config=skier_config, + layers=custom_layers, + segments=skier_segments, +) +system_config = Config( + touchdown=True +) +skier_system = SystemModel( + model_input=model_input, + config=system_config, +) +``` + +Unknown constants are cached_properties; calling `skier_system.unknown_constants` solves the system of linear equations and extracts the constants. + ```python -C = skier.assemble_and_solve(phi=38, **segments) +C = skier_system.unknown_constants ``` + +Analyzer handles rasterization + computation of involved slab and weak-layer properties `Sxx`, `Sxz`, etc. Prepare the output by rasterizing the solution vector at all horizontal positions `xsl` (slab). The result is returned in the form of the ndarray `z`. We also get `xwl` (weak layer) that only contains x-coordinates that are supported by a foundation. + ```python -xsl, z, xwl = skier.rasterize_solution(C=C, phi=38, **segments) +from weac.analysis.analyzer import Analyzer + +skier_analyzer = Analyzer(skier_system) +xsl_skier, z_skier, xwl_skier = skier_analyzer.rasterize_solution(mode="cracked") +Gdif, GdifI, GdifII = skier_analyzer.differential_ERR() +Ginc, GincI, GincII = skier_analyzer.incremental_ERR() +# and Sxx, Sxz, Tzz, principal stress, incremental_potential, ... ``` + Visualize the results. + ```python +from weac.analysis.plotter import Plotter + +plotter = Plotter() +# Visualize slab profile +fig = plotter.plot_slab_profile( + weak_layers=weak_layer, + slabs=skier_system.slab, +) + # Visualize deformations as a contour plot -weac.plot.deformed(skier, xsl=xsl_skier, xwl=xwl_skier, z=z_skier, - phi=inclination, window=200, scale=200, - field='principal') +fig = plotter.plot_deformed( + xsl_skier, xwl_skier, z_skier, skier_analyzer, scale=200, window=200, aspect=2, field="Sxx" +) # Plot slab displacements (using x-coordinates of all segments, xsl) -weac.plot.displacements(skier, x=xsl, z=z, **segments) - +plotter.plot_displacements(skier_analyzer, x=xsl_skier, z=z_skier) # Plot weak-layer stresses (using only x-coordinates of bedded segments, xwl) -weac.plot.stresses(skier, x=xwl, z=z, **segments) +plotter.plot_stresses(skier_analyzer, x=xwl_skier, z=z_skier) ``` -Compute output quantities for exporting or plotting. -```python -# Slab deflections (using x-coordinates of all segments, xsl) -x_cm, w_um = skier.get_slab_deflection(x=xsl, z=z, unit='um') -# Weak-layer shear stress (using only x-coordinates of bedded segments, xwl) -x_cm, tau_kPa = skier.get_weaklayer_shearstress(x=xwl, z=z, unit='kPa') +Compute output/field quantities for exporting or plotting. + +```python +# Compute stresses in kPa in the weaklayer +tau = skier_system.fq.tau(Z=z_skier, unit='kPa') +sig = skier_system.fq.sig(Z=z_skier, unit='kPa') + +w = skier_system.fq.w(Z=z_skier, unit='um') +# Example evaluation vertical displacement at top/mid/bottom of the slab +u_top = skier_system.fq.u(Z=z_skier, h0=top, unit='um') +u_mid = skier_system.fq.u(Z=z_skier, h0=mid, unit='um') +u_bot = skier_system.fq.u(Z=z_skier, h0=bot, unit='um') +psi = skier_system.fq.psi(Z=z_skier, unit='deg') ``` @@ -188,33 +277,50 @@ x_cm, tau_kPa = skier.get_weaklayer_shearstress(x=xwl, z=z, unit='kPa') See the [open issues](https://github.com/2phi/weac/issues) for a list of proposed features and known issues. -### v3.0 +### v4.0 -- [ ] New mathematical foundation to improve the weak-layer representation +- [ ] Change to scenario & scenario_config: InfEnd/Cut/Segment/Weight + +### v3.2 + - [ ] Complex terrain through the addition of out-of-plane tilt - [ ] Up, down, and cross-slope cracks -### v2.7 -- [ ] Finite fracture mechanics implementation for layered snow covers +### v3.1 -### v2.6 -- [ ] Implement anistropic weak layer -- [ ] Add demo gif +- [ ] Improved CriteriaEvaluator Optimization (x2 time reduction) ## Release history +### v3.0 + +- Refactored the codebase for improved structure and maintainability +- Added property caching for improved efficiency +- Added input validation +- Adopted a new, modular, and object-oriented design + +### v2.6 + +- Introduced test suite +- Mitraged from `setup.cfg` to `pyproject.toml` +- Added parametrization for collaps heights + ### v2.5 + - Analyze slab touchdown in PST experiments by setting `touchdown=True` - Completely redesigned and significantly improved API documentation ### v2.4 -- Choose between slope-normal (`'-pst'`, `'pst-'`) or vertial (`'-vpst'`, `'vpst-'`) PST boundary conditions + +- Choose between slope-normal (`'-pst'`, `'pst-'`) or vertical (`'-vpst'`, `'vpst-'`) PST boundary conditions ### v2.3 + - Stress plots on deformed contours - PSTs now account for slab touchdown ### v2.2 + - Sign of inclination `phi` consistent with the coordinate system (positive counterclockwise) - Dimension arguments to field-quantity methods added - Improved aspect ratio of profile views and contour plots @@ -224,11 +330,13 @@ See the [open issues](https://github.com/2phi/weac/issues) for a list of propose - Now allows for distributed surface loads ### v2.1 + - Consistent use of coordinate system with downward pointing z-axis - Consitent top-to-bottom numbering of slab layers - Implementation of PSTs cut from either left or right side ### v2.0 + - Completely rewritten in 🐍 Python - Coupled bending-extension ODE solver implemented - Stress analysis of arbitrarily layered snow slabs @@ -248,24 +356,26 @@ See the [open issues](https://github.com/2phi/weac/issues) for a list of propose - Finite fracture mechanics implementation - Prediction of anticrack nucleation - ## How to contribute 1. Fork the project -2. Create your feature branch (`git checkout -b feature/amazingfeature`) -3. Commit your changes (`git commit -m 'Add some amazing feature'`) -4. Push to the branch (`git push origin feature/amazingfeature`) -5. Open a pull request +2. Initialize submodules + ```bash + git submodule update --init --recursive + ``` + +3. Create your feature branch (`git checkout -b feature/amazingfeature`) +4. Commit your changes (`git commit -m 'Add some amazing feature'`) +5. Push to the branch (`git push origin feature/amazingfeature`) +6. Open a pull request ## Workflows [![Publish Python 🐍 releases πŸ“¦ to PyPI ](https://github.com/2phi/weac/actions/workflows/release.yml/badge.svg)](https://github.com/2phi/weac/actions/workflows/release.yml)
[![Build and publish Sphinx πŸͺ¬ documentation ](https://github.com/2phi/weac/actions/workflows/docs.yml/badge.svg)](https://github.com/2phi/weac/actions/workflows/docs.yml) - - ## License diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..e8fc2b3 --- /dev/null +++ b/TODO.md @@ -0,0 +1,137 @@ +# TODOs + +## Major + +- [ ] Use Classes for Boundary Types +- [ ] Automatically figure out type of system +- [ ] Automatically set boundary conditions based on system + +## Minor + +- [ ] resolve fracture criterion also when lower than strength criterion +- [ ] Florian CriterionEvaluator: clarify and fix damping behavior (find_minimum_force / evaluate_coupled_criterion) + - Expected behavior + - find_minimum_force: compute the critical skier weight w* [kg] such that max(stress_envelope) == 1 within tolerance_stress. This solver should not apply damping; it must return the numerically precise root of residual(weight) = max(stress_envelope) - 1 using a bracketed method and finite tolerances. + - evaluate_coupled_criterion: iterate on skier_weight and crack_length to satisfy both stress and fracture toughness criteria (g_delta β‰ˆ 1). Apply a damping factor only to the weight update to avoid oscillations near the ERR envelope; damping must not alter the physical evaluations (sigma, tau, G_I, G_II). + - Algorithm + - Names/units: `skier_weight` [kg] β‰₯ 0; `g_delta` [-]; `dist_ERR_envelope` = |g_delta - 1| [-]; `tolerance_ERR` ∈ [1e-4, 5e-2]; `tolerance_stress` ∈ [1e-4, 5e-3]; `damping_ERR` ∈ [0, 5]. + - Clamp inputs: clamp `skier_weight` to [0, W_MAX]; clamp `damping_ERR` to [0, 5]; if any intermediate is non-finite (NaN/inf), abort with a clear failure message. + - Maintain a weight bracket [w_min, w_max] around the ERR envelope crossing: set w_min if g_delta < 1, w_max if g_delta β‰₯ 1; compute mid = 0.5 Β· (w_min + w_max). + - Dampened update step (weight only): + - Ξ» = 1 / (1 + damping_ERR) + - new_weight = skier_weight + Ξ» Β· (mid - skier_weight) + - Interpretation: damping_ERR=0 β†’ pure bisection step (Ξ»=1); damping_ERR=1 β†’ half-step (Ξ»=0.5); larger damping slows updates and reduces oscillations. + - After updating `new_weight`, recompute crack length via `find_crack_length_for_weight(system, new_weight)`. + - Stop when `dist_ERR_envelope ≀ tolerance_ERR` or `max_iterations` reached. With damping_ERR=0 the behavior should match undampened bisection; with damping_ERR>0 the path changes but the converged weight is the same within tolerance. + - Failure modes to handle + - Negative/zero weights: never propose negative weights; allow zero only when self-collapse is detected. + - Divergence/oscillation: damping reduces step size near convergence; ensure [w_min, w_max] shrinks monotonically. + - Coupled scaling: damping only scales the update step; do not alter the evaluation of stresses or ERRs. + - Idempotence: same inputs produce the same final result; damping may change iterations, not the target value (within tolerance). + - Non-finite numbers: detect and fail fast with an informative message. + - Entire domain cracked: keep the existing short-circuit to self-collapse. + - Parameters and expected ranges + - `damping_ERR`: float in [0, 5], default 0.0. Recommended 0–2 for stability without excessive slowdown. + - `tolerance_ERR`: float in [1e-4, 5e-2], default 2e-3. + - `tolerance_stress`: float in [1e-4, 5e-3], default 5e-3. + - `max_iterations`: int in [10, 200], default 25. + - `W_MAX`: safety cap for weight search, default 2000 kg. + - Formulae (document in docstrings) + - dist_ERR_envelope = |g_delta - 1| + - Ξ» = 1 / (1 + damping_ERR) + - new_weight = skier_weight + Ξ» Β· (mid - skier_weight) + - Units: weights in kg, stresses in kPa, ERR in J/m^2, lengths in mm. + - Unit tests to add (demonstrate intended outcomes) + 1) Independent criterion (pure stress governed; idempotent with damping) + - Setup: create a stable weak layer where fracture toughness is not limiting at the critical stress weight. Compute w0 via `find_minimum_force`. Run `evaluate_coupled_criterion` twice with `damping_ERR=0.0` and `damping_ERR=3.0` on fresh copies of the same system. + - Expect: + - `pure_stress_criteria == True` + - Returned `critical_skier_weight β‰ˆ w0` (within 1%) for both runs + - All `history.skier_weights` β‰₯ 0; no negative or NaN values + - Example: + + ```python + def test_damping_idempotent_under_pure_stress(): + config = Config() + criteria = CriteriaConfig() + evaluator = CriteriaEvaluator(criteria) + layers = [Layer(rho=170, h=100), Layer(rho=230, h=130)] + wl = WeakLayer(rho=180, h=10, G_Ic=5.0, G_IIc=8.0, kn=100, kt=100) # strong toughness + seg_len = 10000 + base_segments = [ + Segment(length=seg_len, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=seg_len, has_foundation=True, m=0), + ] + def make_system(): + return SystemModel( + model_input=ModelInput( + layers=layers, weak_layer=wl, segments=copy.deepcopy(base_segments), + scenario_config=ScenarioConfig(phi=30.0) + ), + config=config, + ) + w0 = evaluator.find_minimum_force(system=make_system()).critical_skier_weight + res0 = evaluator.evaluate_coupled_criterion(system=make_system(), damping_ERR=0.0) + res3 = evaluator.evaluate_coupled_criterion(system=make_system(), damping_ERR=3.0) + assert res0.pure_stress_criteria and res3.pure_stress_criteria + assert abs(res0.critical_skier_weight - w0) / w0 < 0.01 + assert abs(res3.critical_skier_weight - w0) / w0 < 0.01 + assert all(w >= 0 for w in res0.history.skier_weights) + assert all(w >= 0 for w in res3.history.skier_weights) + ``` + + 2) Strongly coupled criteria (ERR governed; damping reduces oscillations, same target) + - Setup: choose a very weak layer (small G_Ic/G_IIc) so ERR governs. Run `evaluate_coupled_criterion` with `damping_ERR=0` and with `damping_ERR=2` on fresh systems and the same tolerances. + - Expect: + - Both runs converge with `dist_ERR_envelope ≀ tolerance_ERR` + - The two `critical_skier_weight` values differ by ≀ 2% + - The dampened run shows fewer overshoot/flip events (e.g., fewer changes of the w_min/w_max assignment or monotone shrinking bracket) and never proposes negative weight + - Example: + + ```python + def test_damping_stabilizes_coupled_err(): + config = Config() + criteria = CriteriaConfig() + evaluator = CriteriaEvaluator(criteria) + layers = [Layer(rho=170, h=100), Layer(rho=230, h=130)] + wl = WeakLayer(rho=180, h=10, G_Ic=0.02, G_IIc=0.02, kn=100, kt=100) # weak toughness + seg_len = 10000 + segments = [ + Segment(length=seg_len, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=seg_len, has_foundation=True, m=0), + ] + def make_system(): + return SystemModel( + model_input=ModelInput( + layers=layers, weak_layer=wl, segments=copy.deepcopy(segments), + scenario_config=ScenarioConfig(phi=30.0) + ), + config=config, + ) + res_undamped = evaluator.evaluate_coupled_criterion( + system=make_system(), damping_ERR=0.0, tolerance_ERR=0.002 + ) + res_damped = evaluator.evaluate_coupled_criterion( + system=make_system(), damping_ERR=2.0, tolerance_ERR=0.002 + ) + assert res_undamped.converged and res_damped.converged + assert res_undamped.dist_ERR_envelope <= 0.002 + assert res_damped.dist_ERR_envelope <= 0.002 + w_u = res_undamped.critical_skier_weight + w_d = res_damped.critical_skier_weight + assert abs(w_u - w_d) / max(w_u, 1e-9) <= 0.02 + assert all(w >= 0 for w in res_damped.history.skier_weights) + ``` + +- [ ] Make rasterize_solution smarter (iterative convergence) +- [ ] SNOWPACK Parser +- [ ] SMP Parser +- [ ] Build Tests: Integration -> Pure + +## Patch + +- [ ] (Add Patch items as needed) diff --git a/data b/data new file mode 160000 index 0000000..fb0fc72 --- /dev/null +++ b/data @@ -0,0 +1 @@ +Subproject commit fb0fc7227ff7af98f658aa67e8a63780d4d4f0a2 diff --git a/demo/demo.ipynb b/demo/demo.ipynb index b0e2d57..c0bf356 100644 --- a/demo/demo.ipynb +++ b/demo/demo.ipynb @@ -5,25 +5,20 @@ "id": "4f849a30", "metadata": {}, "source": [ - "# How to use WEAC v2" + "## How to use Weac V3" ] }, { "cell_type": "markdown", - "id": "7d6c2b96", + "id": "695bafcb", "metadata": {}, "source": [ - "Note that instructions in this notebook refer to **release v2.6.4**. Please make sure you are running the latest version of weac using\n", - "```sh\n", + "Note that instructions in this notebook refer to **release v2.6.4.** Please make sure you are running the latest version of weac using\n", + "\n", + "```bash\n", "pip install -U weac\n", - "```" - ] - }, - { - "cell_type": "markdown", - "id": "25e39ae7", - "metadata": {}, - "source": [ + "```\n", + "\n", "### About the project\n", "---\n", "WEAC implements closed-form analytical models for the [mechanical analysis of dry-snow slabs on compliant weak layers](https://doi.org/10.5194/tc-14-115-2020), the [prediction of anticrack onset](https://doi.org/10.5194/tc-14-131-2020), and, in particular, allwos for stratified snow covers. The model covers propagation saw tests (a), and uncracked (b) or cracked (c) skier-loaded buried weak layers.\n", @@ -35,12 +30,12 @@ "- Rosendahl, P. L., & Weißgraeber, P. (2020). Modeling snow slab avalanches caused by weak-layer failure – Part 1: Slabs on compliant and collapsible weak layers. The Cryosphere, 14(1), 115–130. https://doi.org/10.5194/tc-14-115-2020\n", "- Rosendahl, P. L., & Weißgraeber, P. (2020). Modeling snow slab avalanches caused by weak-layer failure – Part 2: Coupled mixed-mode criterion for skier-triggered anticracks. The Cryosphere, 14(1), 131–145. https://doi.org/10.5194/tc-14-131-2020\n", "\n", - "Written in 🐍 [Python](https://www.python.org) and built with βš› [Atom](https://atom.io), πŸ™ [GitKraken](https://www.gitkraken.com), and πŸͺ [Jupyter](https://jupyter.org). Note that [release v1.0](https://github.com/2phi/weac/releases/tag/v1.0.0) was written and built in πŸŒ‹ [MATLAB](https://www.mathworks.com/products/matlab.html)." + "Written in 🐍 [Python](https://www.python.org) and built with βš› [Atom](https://atom.io), πŸ™ [GitKraken](https://www.gitkraken.com), and πŸͺ [Jupyter](https://jupyter.org). Note that [release v1.0](https://github.com/2phi/weac/releases/tag/v1.0.0) was written and built in πŸŒ‹ [MATLAB](https://www.mathworks.com/products/matlab.html).\n" ] }, { "cell_type": "markdown", - "id": "40fe0e44", + "id": "df77454e", "metadata": {}, "source": [ "### Installation\n", @@ -53,6 +48,10 @@ "```sh\n", "pip install -U 'weac[interactive]'\n", "```\n", + "As a developer install via:\n", + "```sh\n", + "pip install -U 'weac[dev]'\n", + "```\n", "You may also clone the repo, source `weac` locally, and install dependencies manually\n", "```sh\n", "git clone https://github.com/2phi/weac\n", @@ -62,12 +61,14 @@ "- [Numpy](https://numpy.org/) for matrix operations\n", "- [Scipy](https://www.scipy.org/) for solving optimization problems\n", "- [Pandas](https://pandas.pydata.org/) for data handling\n", - "- [Matplotlib](https://matplotlib.org/) for plotting" + "- [Matplotlib](https://matplotlib.org/) for plotting\n", + "- [Pydantic](https://docs.pydantic.dev/latest/) for input validation\n", + "- [SnowPylot](https://github.com/connellymk/snowpylot) for SnowPit CAAML parsing" ] }, { "cell_type": "markdown", - "id": "36d0a739", + "id": "05da4c09", "metadata": {}, "source": [ "### License\n", @@ -79,7 +80,7 @@ }, { "cell_type": "markdown", - "id": "c1f40652", + "id": "30e06ae1", "metadata": {}, "source": [ "### Contact\n", @@ -89,7 +90,7 @@ }, { "cell_type": "markdown", - "id": "4f4dddac", + "id": "96f92983", "metadata": {}, "source": [ "# Usage\n", @@ -98,7 +99,7 @@ }, { "cell_type": "markdown", - "id": "e12c544c", + "id": "b79cb512", "metadata": {}, "source": [ "### Preamble" @@ -106,20 +107,35 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 39, + "id": "3d1e64be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# Auto reload modules\n", + "%load_ext autoreload\n", + "%autoreload all" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "62e5b62a", "metadata": {}, "outputs": [], "source": [ "# Third party imports\n", "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Project imports\n", - "import weac\n", - "\n", - "# Plot setup\n", - "%matplotlib inline" + "import matplotlib.pyplot as plt" ] }, { @@ -166,26 +182,32 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "df1a9827", + "execution_count": 41, + "id": "9e83dd77", "metadata": {}, "outputs": [], "source": [ - "# Custom profile\n", - "myprofile = [\n", - " [170, 100], # (1) surface layer\n", - " [190, 40], # (2) 2nd layer\n", - " [230, 130], # :\n", - " [250, 20], # :\n", - " [210, 70], # (i) i-th layer\n", - " [380, 20], # :\n", - " [280, 100],\n", - "] # (N) last slab layer above weak layer" + "from weac.components import Layer\n", + "from weac.utils.misc import load_dummy_profile\n", + "\n", + "# Load a dummy profile\n", + "dummy_layers = load_dummy_profile(\"a\")\n", + "\n", + "# Create a custom profile of layers\n", + "custom_layers = [\n", + " Layer(rho=170, h=100), # (1) surface layer\n", + " Layer(rho=190, h=40), # (2)\n", + " Layer(rho=230, h=130), # :\n", + " Layer(rho=250, h=20),\n", + " Layer(rho=210, h=70),\n", + " Layer(rho=380, h=20), # :\n", + " Layer(rho=280, h=100), # (N) last slab layer above weak layer\n", + "]" ] }, { "cell_type": "markdown", - "id": "dc51fee5", + "id": "98ebcc48", "metadata": {}, "source": [ "### Create model instances\n", @@ -194,39 +216,64 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "893fbdd1", + "execution_count": 42, + "id": "ce16e446", "metadata": {}, "outputs": [], "source": [ - "# One skier on homogeneous default slab (240 kg/m^3, 200 mm)\n", - "skier = weac.Layered(system=\"skier\")\n", + "from weac.components import (\n", + " Layer,\n", + " Config,\n", + " ScenarioConfig,\n", + " ModelInput,\n", + " WeakLayer,\n", + " Segment,\n", + ")\n", "\n", - "# Propagation saw test cut from the right side with custom layering\n", - "pst_cut_right = weac.Layered(system=\"pst-\", layers=myprofile)\n", + "from weac.core.system_model import SystemModel\n", "\n", - "# Multiple skiers on slab with database profile B\n", - "skiers_on_B = weac.Layered(system=\"skiers\", layers=\"profile B\")" + "weaklayer = WeakLayer(rho=125, h=20)\n", + "scenario_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=30,\n", + ")\n", + "segments = [\n", + " Segment(length=5000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=80),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=5000, has_foundation=True, m=0),\n", + "]\n", + "\n", + "model_input = ModelInput(\n", + " scenario_config=scenario_config,\n", + " layers=custom_layers,\n", + " segments=segments,\n", + ")\n", + "system_config = Config(touchdown=True)\n", + "system = SystemModel(\n", + " model_input=model_input,\n", + " config=system_config,\n", + ")" ] }, { "cell_type": "markdown", - "id": "0da702a3", + "id": "2c54ae57", "metadata": {}, "source": [ - "### Inspect layering\n", + "### Inspect Layering\n", "---" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "bc7b5e19", + "execution_count": 43, + "id": "85adaab8", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -236,7 +283,13 @@ } ], "source": [ - "weac.plot.slab_profile(pst_cut_right)" + "from weac.analysis.plotter import Plotter\n", + "\n", + "plotter = Plotter()\n", + "fig = plotter.plot_slab_profile(\n", + " weak_layers=weaklayer,\n", + " slabs=system.slab,\n", + ")" ] }, { @@ -250,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 44, "id": "675d8183", "metadata": {}, "outputs": [], @@ -271,35 +324,56 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 45, "id": "fcb203f7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Input\n", - "totallength = 1e4 # Total length (mm)\n", - "cracklength = 0 # Crack length (mm)\n", - "inclination = 30 # Slope inclination (Β°)\n", - "skierweight = 80 # Skier weigth (kg)\n", - "\n", - "# Obtain lists of segment lengths, locations of foundations,\n", - "# and position and magnitude of skier loads from inputs. We\n", - "# can choose to analyze the situtation before a crack appears\n", - "# even if a cracklength > 0 is set by replacing the 'crack'\n", - "# key thorugh the 'nocrack' key.\n", - "seg_skier = skier.calc_segments(L=totallength, a=cracklength, m=skierweight)[\"crack\"]\n", - "\n", - "# Assemble system of linear equations and solve the\n", - "# boundary-value problem for free constants.\n", - "C_skier = skier.assemble_and_solve(phi=inclination, **seg_skier)\n", - "\n", - "# Prepare the output by rasterizing the solution vector at all\n", - "# horizontal positions xsl (slab). The result is returned in the\n", - "# form of the ndarray z. Also provides xwl (weak layer) that only\n", - "# contains x-coordinates that are supported by a foundation.\n", - "xsl_skier, z_skier, xwl_skier = skier.rasterize_solution(\n", - " C=C_skier, phi=inclination, **seg_skier\n", - ")" + "from weac.analysis.analyzer import Analyzer\n", + "\n", + "# Default slab profile\n", + "default_slab_layers = [\n", + " Layer(rho=240, h=200),\n", + "]\n", + "skier_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=30,\n", + ")\n", + "skier_segments = [\n", + " Segment(length=5000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=80),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=5000, has_foundation=True, m=0),\n", + "]\n", + "skier_input = ModelInput(\n", + " scenario_config=skier_config,\n", + " layers=default_slab_layers,\n", + " segments=skier_segments,\n", + ")\n", + "# One skier on homogeneous default slab (240 kg/m^3, 200 mm)\n", + "skier_model = SystemModel(\n", + " model_input=skier_input,\n", + ")\n", + "\n", + "skier_plotter = Plotter()\n", + "fig = skier_plotter.plot_slab_profile(\n", + " weak_layers=skier_model.weak_layer,\n", + " slabs=skier_model.slab,\n", + ")\n", + "\n", + "skier_analyzer = Analyzer(skier_model)\n", + "xsl_skier, z_skier, xwl_skier = skier_analyzer.rasterize_solution(mode=\"cracked\")" ] }, { @@ -312,15 +386,15 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 46, "id": "2a5bc64c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA10AAAGHCAYAAABLQTg/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAskpJREFUeJzsnXeYG9W5/78z0kraXtzXXjewTXDBgGk2xsaGODQDCQ6hJJhAwEACBEgI4SaBX27ooQeS3HuBBEggEFKoARwMGGMDwTYdF1zXld319l2VOb8/pJmdkUbSjDSjsvv9PI+e1cxp75yZlc5X7znvkYQQAoQQQgghhBBCXEHOtwGEEEIIIYQQ0p+h6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQogjCCGwY8cOV+oOhULYu3evK3UTQojbUHQRQghxnHvuuQcHHHAAxo4dm1H5jo4OzJ07F4FAAI888ohrZfTceeedmD59OmbPno2jjjrKdnm3WbZsmel13XXXXTjttNNybk88nZ2dOO2007BhwwbX2jjnnHOwYsUK1+onhBC3oOgihBDiOFdccQV+8pOfZFy+oqICy5Ytw/Dhw10to7J582ZcffXV+Pvf/44333wTZ5xxhu063CaZ6Bo+fDjGjx+fe4Pi+OEPf4hjjjkGxxxzjCv1l5SU4KGHHsJ3vvMdtLS0uNIGIYS4hTffBhBCyEBh1apVWL58Odrb2/H222/jpz/9KebMmYN3330Xjz/+OA4++GC89dZbuO666zBu3DgASJlGnGPLli0AoHnmrr766jxaY4+zzjoLZ511Vl5t+PTTT/Hkk09i586drrYzatQozJ07F7/+9a/x3//93662RQghTkJPFyGE5ICuri78/e9/x9VXX40bbrgB3/ve93DCCSdgy5YtWLRoEa677jqcd955OP/883H++ecDAHp7e5OmOcGf/vQnHHbYYTj22GNx1FFH4brrrtPSwuEwfvKTn2Dq1KmYM2cODjvsMNx9991a+lNPPYVZs2bh2GOPxeGHH46rrroKvb29KdsLh8O49tprMX36dMyZMwdf/epX8dFHH2npHR0dOPvsszFu3DgsWLAA//u//5v2GqyUSdfu008/jSuuuAIAMHfuXMydO9fQB1OmTNH6ae3atVqZ6dOnQ5IkvPDCCzjllFNQX1+P0047zZD23HPP4ZRTTsG4cePwq1/9Cq2trbjgggtwyCGHYMGCBQaPTao+vfPOO/HII49gzZo1mo3d3d3405/+pLUVf+/S2f3cc89h4cKFmDBhAn7wgx8Y+izVs2HGM888gyOPPBJlZWUJdpg9Q5n2EQDMmzcPTz/9dEp7CCGk4BCEEEJcZ+3atQKAWL9+vRBCiLa2NgFAPPHEE2Lq1KlavnA4LPx+v9i1a5d4+eWXk6bpefHFFxPai0Qi4uWXX05qT2Njo/B4PGLjxo1CCCH27Nkj6urqtPTrrrtOHHLIIaKjo0MIIcSbb74pamtrtfRvfOMb4rnnnhNCCBEMBsWCBQvEjTfeaGjj4YcfFmPGjDHUecwxx4ienh4hhBB/+tOfxODBg0VbW5sQQoiLL75YHHbYYaKrq0sIIcQdd9whAoGAePjhh5Neh5Uy6doVQojXXntNxH8lXnfddeLggw8W7e3tQgghfve734khQ4aIffv2GcrccMMNQggh1q9fL771rW8Z0n79618LIYT4/PPPhSRJ4rLLLhOdnZ0iEomImTNnamWt9OkvfvELMWfOnIQ+iLfdqt233nqrEEKI3bt3C7/fL/79738LIdI/G2acdNJJYsmSJQn9l+oZyqSPhBBi5cqVAoBoampKaRMhhBQS9HQRQkgOmDp1Kt566y3st99+AICtW7dqf+vq6rR8Ho8HlZWV+Pjjj7F58+akaXra29tx5513asfhcBhXXnklhgwZktSe3bt3IxKJYPPmzQCAIUOG4IUXXgAAdHd346677sKll16K8vJyAMDRRx+Nyy+/XCt/11134cQTTwQQXWtz+umn48UXX0zanlrnD37wA/j9fgDRaXE9PT34y1/+go6ODjz88MO45JJLUFpaCgC47LLLEA6Hk9ZppUy6dtPZe9lll6GiogIAcMEFF0BRFPzP//yPIe/ixYsBAPvvvz/+/Oc/G9K++c1vAgAmTpyIwYMHY/jw4SgrK4Msy5g5cyZWr16t5bXbp9narU5JHDp0KA488ECsWbMGQOpnIxm7d+82PKtWniEVO30EADU1NVqbhBBSLHBNFyGE5ABJkjBz5kzt+JZbbsGVV16JcDiMQCBgyBsIBLBv3z58+eWXSdP0LFq0CH//+99x880345prrsGVV16JSy+9FJMnT05qz/Tp0/Htb38bxx13HObOnYtvfetbOOeccwAAGzZsQE9PD/bff39DmRtuuEF739bWhrPPPhtbtmyBz+fDrl27Uk4vVOu8+eabcf/992vnhw0bhpaWFmzcuBHBYNAQECIQCGDo0KFJ67RSJl276ezV94HH48HYsWPx4YcfGvKOGjUqaT0jRozQ3peVlRmOy8vL0draqh3b7dNs7a6vr9feV1ZWoq2tDUDqZyMZra2t8Hr7hhRWniEVO30ERAUpAAbTIIQUFfR0EUJIjnnooYcwfPhw3HnnnaiuroYQwpDe0dGBwYMHp0yL57TTTsOkSZNw2GGH4Qc/+EFKwQVEReAf//hHfPjhhzj00ENx/fXXY/r06QmCzozOzk7MmzcPQ4YMwfLly7Fs2TL85Cc/SbDVjDvuuAPLli3TXhs2bMA111yT0k67mJWx264dPB6P5bT4Y7XPsunTTNHbIkmS1lYmz0ZNTQ1CoVDWdpgdx/eB2o7es0YIIYUORRchhOSQF154AZFIBLfffjt6e3sRCASwZ88eLb23txft7e0YM2YMDjjggKRp8XR1deH555/HlVdeiUcffTStHY2NjXj77bcxefJk3H777fj444+xY8cOLF26FPvvvz8CgQC++OILQ5k77rgDXV1d+Oyzz7Bnzx4sWrQIshz9GgkGgynbU+v8/PPPDefvv/9+vPHGG9hvv/1QUlJiaLO3tzflFDIrZdK1m85e/Z5T6pS7qVOnprzWTLDSp+p5AOjp6TEVOU7YnerZSMbw4cPR3NycYEeyZygb1HaGDRuWVT2EEJJLKLoIISRHvPHGG9ixYwdOOeUU7Nq1Cy+99BImTJiAPXv2YPv27QCA119/HYcddhjGjBmDY445Jmmanvb2dnz/+9/Hz3/+cyxevBgnnHACfvzjH6f0kqxfvx4/+tGPtIG7oigQQmDChAkoLS3FD3/4Qzz44IPaAPmll17C3/72N5SVlWHs2LEoLS3VBuGRSAT/+Mc/Ul67Wuf999+vTQtbv3497rnnHkyePBkVFRX47ne/iwcffBDd3d0AosIo1TVYKZOu3XT2PvDAA+js7AQAPPzww5BlGd/73vdSXmsmWOnTIUOGaNdw1VVX4eWXX3bF7lTPRjJmzZplEHrpnqFs2LBhAyZPnoza2tqs6iGEkJySn/gdhBAysNi4caOorKwUAAyv1tZW8corr4glS5aIRx55RJx//vla1DghRMo0lcsuu0w0NjYazq1cuVLccsstSe3ZuXOnWLx4sTj00EPFnDlzxIwZM8RDDz2kpYdCIfHjH/9YTJ48WRxzzDHilFNOEVu3btXSn3nmGTFx4kRx+OGHi9NOO02cf/75wu/3i3nz5gkhhLj77rvFpEmThN/vF3PmzBFdXV0iFAqJn/zkJ2LSpEnimGOOEccdd5x49913tTrb29vFWWedJcaOHSuOO+44ceedd4oxY8aISZMmifvuu8/0OqyUSdfuU089JQ466CABQMyZM0fcfffdWrlrr71WTJ48WcyYMUPMmTNHrF69WggRjRipL/PUU09p9cWnNTU1ieOPP174/X4xadIk8fjjj4tf//rXYsyYMaK6ulqceeaZlvp09+7d4rDDDhOzZs0SJ554oujp6RGPP/64oa3169fbsrupqUksXrxYVFdXizFjxojbbrst7bNhxrp160RlZaUWMTHdM5RpHwkhxHe+8x3xi1/8IqU9hBBSaEhCuDhhnBBCCCEDgiuuuAJDhw7F9ddf71obX3zxBU444QS89957qKysdK0dQghxGk4vJIQQQkjW3Hrrrfjkk09Srv3KhmAwiEsvvRRPPPEEBRchpOigp4sQQgghjtHU1IRBgwY5Xm84HEZXVxeqqqocr5sQQtyGoosQQgghhBBCXITTCwkhhBBCCCHERSi6CCGEEEIIIcRFvPk2oBBQFAU7duxAZWUlJEnKtzmEEEIIIYSQPCGEQHt7O+rr6w0b02cDRReAHTt2oKGhId9mEEIIIYQQQgqEbdu2YdSoUY7URdEFaKFnt23bxqhIhBBCCCGEDGDa2trQ0NDg6PYUFF2ANqWwqqqKoosQQgghhBDi6LIjBtIghBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAX6Veia+vWrTjttNOwZMkSnHzyyfjoo4/ybRIhhBBCCCFkgOPNtwFOcskll+A73/kOzjzzTKxcuRLnnHMO1q5dm2+zCCGEEEIIIQOYfuPpampqwosvvoiTTjoJAHDkkUeisbERa9asya9hhBBCCCGEkAFNv/F0bdmyBWVlZaioqNDODRs2DJs2bcL06dMNeXt7e9Hb26sdt7W1AQD+9a9/oaysDAAwbdo0NDQ0YNu2bfjggw8M5QcNGoQjjzwSiqLgxRdfTLBl/vz5CAQCeP/997Fz505D2qRJk7D//vtj9+7deO+99wxpFRUVmDNnjmZLOBw2pB999NGorq7GRx99hC1bthjSxo0bhwMPPBAtLS1YsWKFIc3n8+H4448HALz22mvo6uoypB9++OEYMmQI1q9fj3Xr1hnSRo4cienTp6OzsxPLli1LuFZV5K5YsQItLS2GtOnTp2PkyJHYsmVLwlTPIUOG4PDDD0c4HMa//vWvhHqPP/54+Hw+vPfee9i9e7ch7Stf+QrGjx+PnTt34v333zekVVdX4+ijjwYAvPjii1AUxZB+zDHHoLKyEh988AG2bdtmSNtvv/1wwAEHoKmpCStXrjSkBQIBzJ8/HwCwdOlS9PT0GNKPPPJIDBo0CJ999hk2btxoSGtoaMC0adPQ3t6ON954w5AmyzJOOOEEAMDy5cvR2tpqSD/kkEMwYsQIfPHFF/j0008NacOGDcOMGTMQDAbxyiuvIJ4FCxbA6/XinXfewd69ew1pU6ZMwZgxY0x/mKitrcXMmTMBAM8//3xCvXPnzkV5eTnWrFmDxsZGQ9rEiRMxYcIE7N27F++8844hraysDMceeywA4JVXXkEwGDSkz5w5E7W1tfjkk0+wadMmQ9qYMWMwZcoUtLa2Yvny5YY0r9eLBQsWAABef/11dHR0GNJnzJiBYcOGYcOGDfj8888NaSNGjMAhhxyCnp4eLF26NOFaTzjhBMiyjJUrV6KpqcmQxs+IKPyMiMLPiD4G0mfE1772NUiShLfffhtffvklhBDaa/LkyRg5ciS2bt2a8HzX1dXhsMMOg6Iopvdmzpw5CAQCWLNmTcLzPWHCBIwfPx579uzB6tWrDWnl5eXa87106dKEz4gjjzwS1dXV+OSTTxKe7zFjxuCAAw7Avn37sGrVKkOaz+fDvHnzAABvvPEGuru7tTRJknDooYdiyJAh2LBhQ8LzXV9fj4MOOgidnZ148803DeUAaM/3ypUrsW/fPkPZgw46SOvDjz/+2FBu8ODBOPzwwxGJRLTPCDUNiH5G+P1+7TNCn8bPiCj8jIhi9hkR/z3oBJIQQjheax54//33ccwxxxg+TCdPnoz//u//xumnn27Ie8MNN+DGG29MqOPww4+A1xvVoSW+Eng9XoQjYYSCIcM/qyzL8Pt9EAB6umP/NH3JCAQCkCUJwWAQ4UgkmhwrX1JSghKvF5GIgt5gn/CTJAmyJMEfCACxegWEId3v90OWZYSCIYQjxg/SkpISlJSUQFEU9Pb0GtIkSUJpWWm03p4eCKWvXgEgEPDD4/EgFAohFAoZyno9XvgDfiiKQE9PN+IpKyuDJEno6elJ+GDy+Xzwer0IhyMIhYz/GLIsIxAIQAiB7m7jB0+03lJIkoTenl5EEuqNXms4HEZvbxC6WwNZllFaGr3Wzs4uAMJw70pLSyHLMnp7exEOhw1pJSUl8Pl8iEQi2oehmh7tw6gg7+7qQt+/jRSrNwBZ9iAUCiIY7OtDSZJQ4vXC5/dDURTDF5WaXl5eHq23pxtK7HlRCQRK4fV6Y/Ua+9Dj8aC0tAxCCHR1dWrnvR4PgOiXryzL6O7uRiSuXr/fD5/Ph1AoZPgBoq/eaD91dnZClmXIshx9RmUZVVVV8Hq96O3tRSQSMaSVlZWhrKwMkUgEXV1dWllZllFSUoLa2lrIsqx9KajlZFlGXV0d/H4/urq60Nvba6i3srIStbW1EEKgra0NHo8HXq8XHo8HJSUlGD16NLxeL5qamqAoCrxer/YaPnw4qqqq0NnZiY6ODng8Hng8Hq3vhw4dinA4nPDlCQBjx46FJEnYtWtXwr0bPHgwKisr0d7eji+//NKQVlpaiuHDh0MIgc2bNyfU29DQAK/Xiz179qCzs9OQVltbi5qaGnR1dSUMtnw+H0aOHAkg+kNT/P9cfX09/H4/mpqatB+TVKqrq1FXV4eenp4EoefxeDB69GgAwPbt2xM+B4YPH47S0lLs27cvQThVVFRgyJAhCIVC2L59e8K1jhs3DgCwc+fOhEHGkCFDUFFRgba2tgRRq/ahoigJAhIARo8eDY/Hg927dyd8OdbV1aG6uhqdnZ3Ys2ePIc3v96O+vh4AsHnzZsR/BY4cORI+nw9ffvkl2tvbDWk1NTWora017UOv14uGhgYAwLZt2xIGuyNGjEAgEEBLS0vCwLKyshKDBw9GMBhMGIBIkoSxY8cCAHbs2JHw/zp06FCUl5ejtbUVzc3NhrSysjIMGzYMkUgEW7duRTxjxoyBLMumz/egQYNQVVWFjo6OhMFWIBDAiBEjAEAb2AghEAwG0dPTg5qaGoTDYezatQv79u1DKBRCMBj9DPP5fPD5fOjo6MCePXu0z6BQKARFURAIBBAMBrF3714Eg0GEQiFEIhGEw2H4/f7Y510Xupt2IBJREI5EEIko2ndoMBxGd0/0sykcUaAoCiJKND0cjiAYCiEUjkAIBUIAioimCSGgKAKRSAQCiP5vCUCJPR+KokARCoQiIBDN20+GTySGfjygf586TUDSDQAlWYI6LhBCJJRTjxPS1Hpjz6Kh9Vg5SQIgAGFIiuaUZbXeqE3ROmPjF1nuK6s+s7qxjRyrXz/WUuv1xL6HFUWJlpWM9XpkOfa/oyTUq45F+sbBfXZ7Pd5YmxEIxdgXHo8HkixDCAVKRDEUlCUJHm+03kg4Yhh7S5IU+26XoUQihv9PbazhidobiRivVQLgLYmO/yOxsoqiYOvWbWhtbUVVVRWcoN+IrqamJgwZMgRtbW2at2vIkCF4+eWXcfDBBxvymnm6GhoacPIpp6CkpCSh7nRdlCq9GMsWql3py6ZMTl0+X9eEwr1P6oeO+hLa++jARBFKkvS+VySiaPnM0vvyRdLa6zSqYPN6vfB4vfB6vPD5SuDz++H3+VHi88Hv98Hn88Pv90WPfX5UlJfB7/drwlV9b3bs9/sRCARQWlqqCVKz936/P+FLnhA3CIfDaG9vR3t7O9ra2lL+7erqQnd3N7q6utCxfQO6e4Po7g2iqyeI7t7e2Pu+v5n+D/tKvPCVlMDvK4GvxAt/SQl8vhL4S0rg9fb9wOL1eOCR5b5z8e89Hni9ujyxH1i8Xq/hvUf7MUiCJKk/KkV/tIOknpcgSzIkWdYGpbIsQ5Jj5yVJy6cfuEbzJNapH3ADMI5AAZiu9kjymSBsf1YkWUmSqhqpr0z8fY0exwb5MEvrK68va1qPToSY1qMdp0pL0kZMwFgpl1BPXOdkVE9c++nrgfW8Vtq3abu1tDT3PYs27NUDk7S+e6a3L+FzyWIbPT09eOC3v6PoSsaJJ56I8847TwukcdFFFyVM+zGjra0N1dXVaNy5y7GOLSb6zQNAihozoacKskgkgkg4jFAohHDsV+9wONx3LhxGOBJGJBzpO9bOhREKhY1ltHIRXZ6+X+ODwSCCsR9neoO9CAZD0eNgL4K90ePe3l4Eg73o7Q0iFApGj3uDCIaCsTzB9BcdQ5IkBEpLUVpa2vc3UIrS0jLtXF11JcrKylBZWYmKigpUVlYaXvHn1GOzH5JI8aJ6elpaWtDc3Izm5mbtvf5c07q1aG7vQEtbJ9o6u9HR3Y22zm5096Z+LssCflSWBVBRVory0gBKfT6UBnwoC/hR6vehLBDQ3pcG/CgL+FFWGjAcq/l8vpKomIqJKl+JNyqsvF74AwH4Srwo8UZ/8YbcN8iXYr+Qa8jJjyU5zdL0+LI6MWF4D0DEHcenJxNBxvbS1GlWr41zpvWlIlX+VNeTopwlG9LdlzRtZE02dTtkl+17ZQc3607aZoH/MOhwn7S1tWFo/ShHRVe/WdMFAA8++CAuv/xyvPbaa9i2bRsee+yxfJtECLGIpPul2E0UG78ypPpNyqye+F8fg8Egurt70N3Tje6ubnR3d6Gnuyf6t6cbXZ1RT0J3T9Sb0NPTg+6uLnR1d6Onuxvdur+NO3ejq6sTnZ2d6OzoQEdHOzo7OhKmAsbj8/tRXlGB8vIKlJVXoCz2ftSwwaipqUl4qdMb9S+/32+904htenp6sGfPHu21e/du7f2uj9/D7uZ92LuvDXtbWtHU2o5gKGxaT1V5KWqrKlBXWYGaynLUVZVj3IhhqK4sQ1VZKSrKSlFVXorKslJUxv7qz1eUBuD1ehKFSgzJ7Hzc/6tpnoQy8SIqM8Flux23B6qZCg2r55wkQ8FlCZc/wwkpVvqVpytT6OkiZGDgpuACzP+XUrWpb0MxnE8sr+Y1ruICenuD6OyIThfr6OjQXp2xV3tHOzo72tEVE2udHR3oaG9De3sb2lpb0d7WivbY3/g1Yio+fwAVVVUor6xGeWUVyquqMGHkMNTV1WHQoEEYNGgQBg8erL1XX1VVVQN62qS6rqmxsdHw2vbBO9ixtwmNe77E7qZ9aOtMXLBdU1mOoXU1GFpThSG11RhSW42htVUYVFOF2opS1FZWoK5KFVcVqKkojwqmTEkhZqyIraT5UrURL9hsCq6UXq50goterozKFYWXK9v6C93TlQ8vF1DYni4X+oSeLkIIyQA7YgtIvx7OrXYzwefzwVc3CNW1dQCiwq9PqMXsiMlB7VhE3ysQ2rmIoqCrswP79rWirbUVra370Na6D22tbehoi4qy1tZ9aG9rRUdbGz7ZtA1t73+Atn0t6GhtQbA3MSCO7PGivKoa5dW1KKuqRaCyGkcdMCZBnA0ePBiDBw/GkCFDtGArxUBHRwe2bNmCTZs2YfPmzdi8eTM2ffQfbG3chcbde7G7qcUgZH0lJRg5dBDqh9Rh5JBBmD5pPIYPqo2Kq9oqDKmrwdDaagyproBPNy1UKBGz5oFk561gwWOUVEQ57N0CKLjSnnMSN71chUB/FlykqKHoIogFtSGkX+K04LLj5cqWTEWbLFkvK0lRASZJEsorKhEoq8TQESMREQKKEFCDPClCICIEQpHY+Vj9oYgCRQh0dXVjX3MT2vc1Y19LM9r2taC1pQUdrc3oaG1B+74WdOxrwUvL30FX2z50te1Db2e7iT0yfBXV8FXUoKSiBt7yanz9yAMwZMgQ7aUKNPW9z+fLrKPSoCgKtm3bhnXr1mH9+vVRUfXJGmze1ojN23fgy+Z9Wl5fSQnGjByGMSNHYNoB++NrxxyJUUMHoX7YYIwcUof6QbUYVFMFSVO+iYLJIK70kcRiIiJBfNmZameRlAIqE+8WkFvBFU+2gssKmf5IYKMtR71cblIkP5gQkg8ouggh/ZJceJmKDVVgqciQNC+YVTyyBChAJFaReuwvLcWQ+pEYNLweEQGEYpEuQ7EbEYwoCIajLwAIhhX09AZjwqwF7fua0dHSjK7WZnTsa0ZXWwt62lrQ074Pjz37KoId+xDqaIWIJK5hk31l8ASqIAeqIPsr8K3jDkop0ioqKgyhm/fu3Yt169Zp4uqzD9dg/cYvsGHTZvTGAk94vV6MGTkCY0bVY9pXJuGU4+Zi3KgRGDtyBMaOHIYRQ+og6yNmKUqfsIr9FZFI3w2QPQnCS5I9fcJKlg3CS02P1p2Fh8uE9NMCMxRbQO4Fl9NCNIMpVZa9XKbtFa6XyzHvDb1AxUchTy0sIii6CCH9jkwFVy69XMW+nNYjQfN2qceK4Tgq6GRJ0vY68sgSPLKESCxjSUkJquoGo6xmEGpGKjphFkFvWEFEEegORhAOR7cfCIciCHZ2Iti+D72tzehtb0GwoxWhjn3RV1crIl2tePzZ1xHpboPS2wERTpz2CElGSUUdJowagsYdjWhtje5pJkkSRjeMwoRxY3DMUUfggnPOxMTxYzBh3BiMHjEEJR6dEBICEAokoQDqCzAKKRNhZSamjKbFCS8gqfgCMhdgmQgty2UBc/GTa8HVT6YV0stlgwKYWugqxWBjrimiPqHoIgA4xZD0D7Lxbjktggrd0xbv9VLxyAAU/Y7j0SmGsiRp3q1kyDGhpQowWZYQifQJrogiEv4mth8VZl59PlmCpEjweGSUlJbD4y9DSfUwBIIRKBGBcDCiibJIWEEk2A0lFEQk2I1QdzvCHU0Id7Ug1NEEpacDSncz6vY7AHOmVGDkiBGYuN84TBg/DuPHNiDg80FSwuaiSjGPGhjtULlPeCEqEIQqlmLiS/J4ot4uVXiZiTLECS8gqfhS8zpKtmILSOvdAvqn4HKDQgiekZEdAxj2FUkGRRchpOjJVuBYEVxuiqhkkQuzJZmwyhSPFP15Ri8TZEkCZECJiStZlqAoQhNpeg+YXmip4sojSwjHxJVHqEJLhkeO844BkGR1g9lo/bIc3XxU9kYHOUIREIqAEhuAS7IHcokfnrJawBuAFKhFqLsD6N6HITPPwV0/PzoqhpSwTlgl90IlJU5w2cKq8AJSiq+sSCMeMhZbJnUniC2zcvkWXFYwsamgg2e4jVUBWuzXSUgWUHQRQooWJ4RQtoKrwB1appgF2tBPA0xH/LoutXy8J0w/xRAAIhAJUwxVrxYAeJRomqGd2N+omIuO2WQhQchSVIQpUtRxhJgokyXIXh+EEoFQIpBlD0SJD0o4CNnri6b5K6GE7QsXIcnRMaMqeqToKi4pleBSRVUyb1cKkgfQ0A1cMxFgFgbItj1oTkwnNDmXF8Hl5jqufAXPGAhermKxs9jgei7H4BNKNPhvRYoBRfS9ssWtdVWFPrUwnky/Uz1S8mP1vZxEROn/mtatE2NAVFCp9UlSVFx5PHL0WO4TXFLMAybJnqinyxuNbKj+9ZT4IMkehEOR7NyAyTpNJwLSCwY5oYxpU7FrSVqH3VembZm2b7KZskk7lqYT5lpwmZGPaYUDRSwU8nUWsm0qxWBjrimyPikuawkhAxanhJaKVcHV37xc8cgpfm7xSBJkSYqu8wI0j1VCHbrzZu8NYixOhKkv/XH0vWxIV71dUkxkAUahJckxW71y7LxHe3m8PkgeD2RviSbEwiFnIwDGDDI/r4oDddqjlSl2ptXbFEQW0PdT1mILMBVbdtdvRe3KgeByaB1XwQfPcNvLVQgBNAqEovEKkrzA6YWEkILFLY+RE4IrF+1bQV23lWp6oD40vJV1XmowDbP61HVdkCVtHVe0jJSwrkvNn2qKoT5wBmCcYqgF1FDza9MJY9MN0ecB83glCEWCJKIizOP1QijRaYbxwkLyeDT7HMPmui7TaYZJ1nclNmUUHHYiGDoi2iyILcCl9VtmdWSyRqsQBFcSHB24F8rUMNdD4VPskMKHoosQUjDkYlqeU4InWS35nlpoJxJptoE2ZDWwhjAeJ6wXSxHFUCVZQA01zEiqgBoer4xIWIl6u2KiTIn0eXFkrw9SOAi5JCrCPEoEkWB3tA/ihFLK9VmWO6ZPPGlRDOPWdsV1kFF4AZbEl2azC5skm+Kk2DI555bgciRSoQlZ7cdlN68b9dDLFYWCLTmFItr7CXzSiAH+e5FcoV+b5fTUwWTYEVz5Fk/5INn0wUzr8UippxjGTy80w3SKoRSdYtg33bBvvRcAyF4ZskeGx+uNTm9TpxjqvF1KKOjItQIZeCbMphnGD15zJaTSoU4jdNq7VSiCyyrZiItCnFZIHMfVqYUUhv0C3kVCiKuYiatcCxohhKOCy0kvl8PBvzVS6BjT9FTjM6vruvTiyRBAI1ZGliTtvdnaLq8qriSj0PLqRFrfdELZsJZLliXIHikquGLHQDSAhubtkj2QS3yQvSVQwg6JLguDek1QmK1dSie88iW+UrWdJFCG6dotJ9ZvmZVzSnD112mF6cill4tTC4kbFOF9Lz6LCSF5J5mQyre4MsPudMJCsLlQ0IskPdEAG7FQ7nHpSUVZiiiG6ntbATXSeLu0IBuxNVzx3i6roivl4DP+WvV504klfZTDVMJLzZsL8ZXKqwVYF1tqXWnOSbJsLWBGfxNcuZhWSC+XNYpw4E6KF67pIgnYWRNCnIeDfudwIyR8tjVmYlM212Fl3ZY+0IaKRwYiFt1wHgnQxdSITSWM1qm+12+UrHqy1LVdALT3KQNqqGvB5GhFsixBKFGB5fHI0c2RTTZLFl4fRCRiWNsVycbTZWGPrXgS1nYBxrVfamANtX4gsQ29+LCx5ispVoRcClGUqdgCMvRuRQumPkaBCK5kODWtMBv6k5eLuAeFu+NQdBGSByis3CVTkZLNfXFm37Ds67BCtgE0kiFLEiAjbRRDRZhvkhwfWEMfUMMj9+XzyNHNkYWQIMkCiOg8WyabJWveLiXq7RJKJLqmSw2akS54hi4yoZBk02AbhvPpIhlaEV7RDoz+NRN4ZoIkmRDLxEvmhNhKcr5fCa5kuLmOK0Vd0bQBNFguEFHH9VzEChRdhOQAiqzckI1HyMo9KubbaObNAhIFWLLQ81FBJRBR9FMIE0PHa3l1UQxVD5c+iiEAg/DSTx/UohgqyaYcGsPHezwyIlBsebtMhUMq1IGPmZhKJrLiIhVq3q74tFTCC0gtvuLbywa7QitVu5mKLbOyFgWMY4LLDtl6vpxqU0tLc330cvVR6PaR5BTpvStOqwkpEgplXdNAIJ+Cy417nI/nxmy8lmxdV2Ie8/Px79V8+oAa8cJKnWIYjzcuX6rNkq2s7XKFNIOBpMIjbo2XuTdJNl1XlTH6+pLUmdQWIHmgjGIXXDlcx1VI0wqLjv52PaTfQ08XMYXrujKHIiu3ZLtuK5f3K95WtyIXWiW2NCr6Pst1XX112ptiGL9nV4K3K26KoVPeLo8Ta6IAg6vQdIphqg2P49PiPWMxsZPg+QKcE14mpPUCOj2VMFmdFkSNdTGUA8GVjCKZVjigvFwOklPhTIoaii5CHIJiK7c4ESTD6j3LtZerGMhmiiEU4UhADcNmyWnWdskeGYAXQomu6crZhsImJJ1maHaMNOLLKZsyFVpJ0iyLrWR1F6Pgyuc6LjfL9keKpT/yZedAWheYQyi6CHGAgTrwzgdORSR0QnD1F6ys69KmGMbWdcWjiqw47dXn+VKEJtTMAmoAMIgvq94uj1dGJKxY8nYpEWgh42WvD7GELHpOh35dl/o+hbcrrfACkoovIHsBZnlNm02xBbjv3QKKRHDlkoHm5cp3f5P8UcT33pblu3fvxjnnnIOvf/3r6OzsxAUXXICmpia3bCOk4OGardxhd4PjVDh1zwr13qvDr1QbJCcboyVb12UHdaNkK3t2AUhY06W+t7JZspo/3dou2StD9sjweL2QS5Ks6bITBt6B6X0GcWIxGIVWNrbWKtNXStLu15V83RYFV/rzOZ9W6ETwDGIK+47YwdbTcs0112DevHkoLy9HeXk5Lr/8clx77bVu2UbyDJ3LqSnUAXd/w0mxBdi7b07eYjf2DIsnmcjJ5kdwT4pvCTXIhrpRsml5yRhEI1VAjb42pYS/qTZL9nhlTWB5PLK2b5csS5A9UlRwSX2BN2SvD3KJD/CUZN4xenQdLPqUn/GvFa9QqsAUbk+HtCq0nBBbxSi4kpFvweVmWT39yctFoUTyhK0nr6GhARdccAEqKioAAAcddBBqa2tdMYyQQoaCy11UoeW0UHFScGX7DMT7VHKxR5ds8lOKXiuZpSfml5IKMX0Uw3gBqPduqUJLloyiykxkWfV26SMZ9okrWWtbPZY08eWBkqHoyvjXbavT8TIQPrbtiH+ly2uCLbGl1pVYSeIg2OSckGTzCIW5ElyFGqkwF9MKSX7geq5+h601XV9++SUAQIrdkPb2dmzYsMF5qwgpYCi43MMtb5Dde8ZbnLiuSxVIERv3yCNLMXWZPqBGBMYNk/XCy24kw+hyKgmyEvWCAQoUpe84utbLF63Lbsek2vg4lqZFMYxf25WyWt0aLyDpuq6EdDdIU7ctoZWqvnx5t4DiEVwuTiu0TCF5ubKlGGwkySny+2dLdB1//PGYPHkyenp6sGDBAqxevRoPPvigW7YRUnBQcDmP29PuCmEPrVxMLcwWfTCN+MAaqULHx0cxVEVWJgE1om3FRSdUhOVIhkKWAMhQlAhkET2WRCy/V4JQJHggayHkw4qATzXQqYAa6UgRQl4VM6biC0guwJywKQ22hVaqerON8ldkgitjXBZcjgbPyBUFNOiml5DYxZboWrRoEaZNm4ZXX30VAHDfffdh4sSJrhhGCgPu19UHBZez5EKIZHLPBtJtjhdXVokKKPMohon5AChGD5mb3i4oIurNUhSDtysSVuDxyggHI1oI+ZBdnRXvsZLlvuAbyTrTzNuVau8umHi9tPbiREwmIsymh8x1sZXkvD0RVNiCK+fruCzguGCgACEkLbZE15YtW7B3715cdtllAIAVK1ZQdJEBAQWXM+TK45Pp/bJSrBCfhUzFk0qyTZKdmGKoEl3rZawbSPR26TdLTuft8nmjg/uuYMTg7VKUmGdLSIBXhiJEdNphXAj5sBs3M36KoUlatAPSC6+onSmUoQtTDDMSWSqp7HHDuwVktX4raVup2rNJXtZx5XpaYa4YSAE0uJ6rX2Lrri5ZsgRvvvmmdrxixQr813/9l+NGEVJIFOIgu5hwKyhGMgpNcJlddzoHi5PPnBq/QttmK8O4pHaiGMYH1NBHJowPFy/LkiGSYbKgGsnCyntkCX5vNKKhzxuNXAjE1nTFKvZ45LggGtGgGpFc/XPrB1D69xan9dkOWGGTrNtIFYwjabALc4+TremEuRZc/WQdF71c2cOphXmgH/S5rSs44IADcN1112nH11xzDdrb2x03ihBS3ORaaAHZ7ZnWH3V1JtJKP55LN7ZLFcUwaX6T8PFWIxnG79vli3ms4kPI+7yyaQh5WYpOM5Q9sb+SFF13ZnUtl0k0vcQ8kiGvtTUz1r1VenGUiUCKL5+1mMtUbNkJluHCdMKk7altWrUjWf5U9acjG8FlAct2FZqXi5B+gK3/qt7e3oRzPT09jhmTDYsXL8bw4cO115IlS/JtUr9hIDub6eWyTj6Elko298lqUTefhXzG2TDdDFn3X58Q+l0nlOJJ5u1KqD+Ntwsw92gZjm2GkJdjXjBZPeeVEcrlP3gybxeQ8TTBZCLKcXEVj8Niy5XphIA9wWXDI5cuzRXBlYvyKnaelVx5Hwqlb3JBMdlKbGFrTdfgwYNx6qmnYtasWQCAt956C9OnT3fDrozYtWtXvk0g/QgKrvTkOypftvfIbcGV7/6xg35dVzLMohiq5+LXfxnr7guoER8+Xv1ZJ1kkQxV1jZdXd85KCHk1qAYg4PFEIxdGQ8tbX5uWsD7LsDZLF0xDj9naLn25hKAcaULE55t0wtApT5ATYgvIPmBGqvMp0lwTXIU4rXCA0m/7keu5XMeW6Lrxxhvx0EMP4aWXXgIAnHbaaVi8eLEbdmXET3/6UwSDQQghcO2112Lo0KGm+Xp7ew1eu7a2tlyZSEjRUyhCIleCy2lyFJg8Y1KFjtejeqSSCS39Hl2pwsdr55JEMlTXXekFlRbJ0EIIeTWoBiAjAgUebU6kkjb6YkaYdJpl4QUUlvjKVGilSXNVcLm9fitFWr8QXPRykUKkn9xDW6JLkiRccMEFuOCCC7Rzq1atwhFHHOG4YXZZuHAhZs6cieHDh+OZZ57B/PnzsXr1ani9iZd4880348Ybb8yDlaRYoJfLSKEILcCZe2OnimJ7FlJ5nFQ9oI9QmEmdydrQ79kV32/x3i41kqEdb5d67NULr5i3S41kCAC9YUVb8xUOKxBCgiQLyHHRDDOJwqjHNEKhHjNRFX9eHUwUiviyMtWxEMUWMDAFl5MUouAipB8hCRujKSEEnn76aaxbtw6RSPSL4IUXXsDKlStdMzBTqqqqsGzZMhxyyCEJaWaeroaGBjTu3IWqqqpcmllUFNnYMyuKbaDtBoUktADn7kmuBFey/jMbosdnjW9XX1eyIb6+DlUQ6atR61TzxYsuIczzaO91DUSU6LEqWhTRt2eXel4R0SmB0WNdmu6cIoTm7QopsXKK0NZaRYRAMKwgokT/AkAwrGjnwrHzxnwR9OrKBMMKImEFQghEwgrCIQVCEYhEFPzPhYfjwLLYumShAIoSFVFCiXaCTghp59W8sfea6IqfYqj2V3wdhjxpjuNxWoDZWUuWVhwUntjKrG37Qiyr6WbZBs6glys3dcRwfWphPsVsIU8vzEO/tLW1YWj9KLS2tjqmDWx5uq644gooioL3338fCxYswNatW1FaWuqIIdmybt06w55hPp8P3d3dpnn9fj/8fn+uTCNFxkAXXIUmtoDiE1x2KKTuNlvXlW6KYby3SO/tQtwUw2TeLn05vbcLME4rNNsw2eeVEQwrlqYZqtEMI1AgKxJC8fMe3UDn1Uq5Nkw9BpKLr1QiyUyQZbuPVxZCC8hwD6x8ebdSpeVDcDlUvqgFlxMUk635pJAFVz/C1tNYUlKC+++/H0cccQR+8Ytf4P/+7/9w+OGHu2WbLc4991zt/dq1ayHLMqZNm5ZHiwgpHvIZeTAV2YSB1yOQW8Flx8uVaV1WyPRr1DSioe6kR06MamgnfLyhXlUsSX3H+nDyZhEMk0UsBKIbJvu8smHvLq9XjkYw9MiGaIahVBsPZ4sh/n5f5yQMglNF0rMzYFQjCupfdtG3m06cpJhmlzIiYSrvlt21W/1ZcBXqOq5cQsFEgH71HNjydKlTCvft24fu7m6Ulpbiww8/dMUwu0yePBlnn302hg0bhvXr1+Nvf/sbKisr820WKTIGmper0ESWipP3oTCvMDm5egbj13WZebSsrP0yC6hh19ulBtXQyslAJOaF0gsvALH1W0bvFgB4FEl33jyaIRQBj1drPLtAGvHRCZNFMTTB1OMFJF//pRV0UCTaHchk6tVKVzaTX9jtiq1UNji9Ps0KORBcrlFMA2CHbe3XUwtJTrAlulpaWvDEE09g/vz5GDt2LEpLSzFz5ky3bLPFww8/nG8TCCkaBoLYAjITXG55uQqFVNMFgb4phlaiGMYH1DALKa/PGy+8lLjpfWpQjYjoC7ChD6qhThm0Ms1QDayhD6oRBBAJK1oY+d6Ibo2WFcGULDBG0vz6TjSWNQ3CkW56YS4HZRbbKgSxldKOjO0rbsFV9NMKKUBIP8SS6DrvvPNw//334w9/+IN2br/99kNzczO+9rWvuWYcKSyiQ6b+y0DwchWqIHCj7/MhuFLW7V7VlrCyD5dpubh1V31rrfoElhVvV8SkcVWI6b1dWn0yDCHkISdGMlSFVnw0Q5V0YeTNbHKcNMILMAmwkU58uYVTA3qnxRbgrHcrVVo2Hr105ChSYdFPKyxA+u3eXADXc+UQS0/RoEGDUFlZicsvv1w7d9RRR+Gkk07CY4895ppxhBBnKMT1WoBza7b02F2/pbcl1zh5S/Tfm/HrrTKpw2qa1bVdHlmKrdPqKxd/DoBhPZccS4+eN67nUuvU1m2p7z2yLl1Oub4rFHfTU4Z/N2Q0XqQ2IEs2iE2yviuhvFk7mazvSkd8vRbqT7lWK75O03Sba7ZUMl27lWlaElJeuxWcEFxOruOyS7F5ufqzSBpI9LP7aMnTtW7dOjz00EP47LPP8Mc//tGQ9vjjj+O8885zxThCckV/9XIVotAC3OvvTKt1LDpigfZ3MpKt2TKbYtiXlpm3K10f6zdMTjfNMNp2nwdLPdbSdOu7AOP6Lv3+Xcn2M7OM3emGKcol9XrFl8sRlgfvbnlvMplKmM6efEwnTNcukB/BVajTCgcq7OMBgSXRdd111+GPf/wjtm/fjtdee82Q1tjY6IphhJDMKdTBv5viNt+CK2Ub7jeRFLNpwenWdcWTLqCGlbVdsgRbQTUA4zRDqLEYZbWNxE2TgfTru9S8EVlCKKLA4oQP6yQLqBHf6UmmEOoHzpY9bw5ga8Du5jS5AhJbadtMh5WyhS64ck0Bern69dRCklMsia5Zs2Zh1qxZ+Otf/4pvfOMbhrSnn37aFcNIYdLf13X1Bwaa4MqmWkejJBZov9tF1Qap9uzKxNsVv5+XIV0nvNQ2VQ9XNJMxmqF+fZfq7TJb3+WDjCD6hJbfKxsCa9jZpss08IWNdADmajfF+q34wZ4TIiyjAaRlr1eBia106fn0bgGOCS5b2BVcFBz9G67nyim2ohcuWbIEe/bswSWXXKKdO+OMMxw3ipBc0l+mFhbqoL8QvVtA7gRXsmGyWRG3n0UzIZXOi6UJLRverqiQEgZvl0cNmhHn7TKrJ36aIQAoUmwzZSEMYeT1Xi1VfCHc17AaWMPn9SAYjmh7e/m8MsJmni67wsZsimGq8PHqIMeG+NJMK8R1NdkO2jIVW0Bhercs1B/N45zgci1wRq4FVwF6uXJCMdqcC/phv9i6oqlTpxoEFwDs3bvXUYMIIfYpRMHlRpAMlUyDZaj0F6GdDZmOlbWttOI2S9bem1ScGGwjdVANORZEI1pfLI9u02S1jmSBNdSohfGBNdSNk736qYmZiCz9Xx2GwW+6AW6yG+B00Awr2AyqoQXFyNazlSJARlrvViaBMtT0FPRbwWWXfjjgzQROLSROYutpOvPMM/Hiiy8iFApp5375y186bhQhxBqFGJXQTbEFZD+91fFoiQXW/07QJ6zijpF6sKgXV1EhZUzzSBLkuCqsCC99NEN9dMN44aX3dsULL3VKoSq8/F7Z1vRCV0glXOwKIUvtmdRpVSQ4KbTcEFtqeoZls45OmK59wHr/uSG4CnkdFzBwvVz5hFMLc46t6YWql0uK3SghBCRJwr333uu8ZYTkgGL2eBTaYN/tvnSi+lzfbztTC51GP91PvxYzkymG8VhZ2xUxOa+m6acZWokgGL++K37/rr5IhX3En9NHNFQDa4SU2PRCKxsjp0I3xdCwtivVNEND+SRTDs3ayQVOD8bSDPizmkboQHrBeLes1gWXBVcxTissVgbytQ9AbN3tk08+GYqiIBKJIBKJQFEU/OQnP3HLNlKg8LeR/EPBZR9XNmAusPvg5Fg5W29X1Kslmaap2J1maGX/rmQeL59XhkeSDB4vJduHwsqAyVZobge8SZnglCdLTxqvFuCQZ6vQvVsABVcucMFuTi3MI/207215uv75z38mnItf45WM119/HWvXrsXevXtRW1uLCRMmYMGCBfD5fHZMIGRAU2iD/Fx4jgptOqFKunth13diZqfb99tu6HizsmberlRBNcz27pJj3q90YeRTBdYw83ZFbdINeDVPV/Svo9MLk3m7AOseL0N9JgP1bJ6HXAg5CwN8SwPZQvdsWbUDcHQ6IdAPBVc/HVwTYoYt0fXGG28knLvnnnvw17/+NWmZlStX4rzzzkNFRQVGjx6NyspKfPrpp3jmmWdwySWX4Pbbb8dZZ51l33JCsqTYphYWkuAqBrEFFOY9LqDbaCDVFMP4zZLVvGaiLZNphhFtXy5YFl4lWoWphVfCOZ3w0k9ttBWO3SxiYRyOCK+EdgtwnoHFgX3WUwit5LFQhyOCKw/eLaAfCi6nKFYvVz77vBA/SwYAtkTX2WefjYkTJ0IIgVAohE8//RSTJk1Kmn/jxo144IEH8Prrr2P48OEJ6Z2dnfjVr36FqqoqnHTSSfatJ2SAQMFlH1eDeTjs5coFydZ1pfJ2WfWExW+OrD+XbO+uvjTz9V1WhJesXUh64RVRRN/52LFdTPfi0guwODFmKryA7MVXvnFKaAHFJbYstlV0gitfFLPQIyQDbImuW2+9Feecc4523N3djVtuuSVp/srKSjzyyCOQk3wAlJeX46abbsKOHTvsmEHIgKJQBFexiC0gv4KrkDATQynzZ+HtymSaYV8aNOGl378rrfCSZYSiag1WphrGn0+2YXNWpBNeQPGJLxuD+JwJLYt5ciq2gPyu3wIyE1zFPK2Qwq3/0Y/vqa0r0wsuACgtLcW2bduS5h86dGhSwQUAn3/+OQCgvr7ejhmkAKBjOjcUygCfgstG+ynSCuR22iLTWShme3clCyPfV8YYWMPsfHxwjRJZTtzDS+oLopEquAYAc+Fj5UbpBwaZriFKE2giL+gDYFiwTw1GYTkohhWvlQN5HAmSYdUewF44+IEuuAqcfj+1kOQNW56u7373u9p7RVGwc+dO+P1+S2UVRcFrr72GnTt3Qol9yT322GN4+eWX7ZhAiCPke2BuhUIQXBRbRty6J7l6Hq1MMTTzdvV5s6x7u4CY8FL6PFBm67viA2t44jxe2lRE3Xkzj5ciCdM1XoZphTHU8wlTDO1ulJwMkzVfph4vFf1gOZferwwFn+VBqZP53BIqDrSZ9+mEQHEJLnq58gvXc+UNW6Jr27ZtOPfccwEAsixj+PDhOPbYYy2VXbhwIVpbW7Hffvtp+3w1NjbaNJeQgQEFlz0KRXAVwmSxbCISZtJOOuEFmK/vclx4xYJryEIgFEFfe3Limi6PLEWjFzr54MQLrSTCC0gTtCPZ4NmuGHPIg2Z78J8PQYYCF1t26gQFVz5hmHjiJrZE13333YcDDjggo4b27duH5cuXG869+OKLGdVFSH9mIAguJ6svFsGVr9uaal1XNt4uQz021ne5LbyijUY1ihYSPjaO0osvdb8uwF7kQoPHKl0UwyTplsRXPDmahpjRoLM/CC0b7RaM2AKKS3A5STFfQzHb7jb9vG9sXd327dvxt7/9DQBw++234xvf+AbWrFljqeycOXOwceNGw7kNGzbYaZ4Q4jKKKB7BlQtbgcIQwU7ixMSS+A2T06Gu49JvjqytvzJZ46XWb7Z5sp0NlPXHPo+csK7LccwGDCnW8FheD+UC8W3bskG/Psvq+iurUwgtBsdw3LPlxlRCt71bxSa4CnxATS8XcRtbT9jvf/97TJ06Fe+88w5+97vf4bzzzsPNN99sqexhhx2Ggw8+GCNHjsT48eMxbtw4/OxnP8vIaEKyoZDXc+VzgJ8LsVVM0wntkI2XK9m15ONZ0I8nZRN5ZkiPE15qfkknkPTohZc+sIY+TZ+eTHhpeWwKLwDweWT4vLImuhyZXhg/UEs2cLMhJrIRY8nqyLjOeIFlRzw5mNcVcWpXbLmwdgvI0XRCoP8ILoqjzOF6rrxia3rhhAkTsP/+++Oaa67BlVdeiYULFyZMGUzGddddh7///e8YP348JEmCEAI33HBDJjaTAkG/KJ9kT38XXE6RS8HVX7xcVqcYWsFszZidwBrqVEMgGrK9b9qg+VTDPiOjx+nCyQMAlOg0RllIUCQBWQgoChBSEtd5uUKyaYf6waLNKY05IdN27Io4i7h23bbsdWcqIZDD6YQAhUoaCv5/bCAwAPrGlujauHEjnn76afzpT3/C2rVroSgKtm/fbqns1KlTMW/ePMM5eroIiULBZY1CFFyFuJYrXTCNVD+YpFvbpc9jtibMrvBSSSa8osIMBuEVPW8UXqotEQHzdV4yUIK+dV4ej4SILPrWVWW6rgswF1lW1ntpFeY4BEu2gxu3gmvA5cFvgYgtYIAJLnq5CAFgU3RdfvnluPXWW/HLX/4SQ4YMwY9+9CNMnjzZUtnRo0fj/PPPx8yZM7Uw8wwZT0h+cXUTYQfryvV0QqcEV9ryBeJIS+XtSrVhcrKydoSXteAaACB0wit6rAov2ROrP12ADRkJGyk7RjLhBaQXVakGklYFWSF4hTIsUzBCC7A//YrerdzZUAjXU8xwamHekUSOfmIfOXIkvvrVrxrOvfPOO/j4449z0XxK2traUF1djcadu1BVVZVvc4qKAhkzWqZQBrl68uHloncrOU4KrnRVpbq2ZHZYFXpmxeOnGMZn0dujz5pMdBnyiOTl1HPx7aviSj2v7uOlCKGlxaer7UQUEc0njPnU89H80XOKYjyOxM5FBPDd8bGBiObx0ndC8t5OGnkwlUjKtUfLDtkMaHPl6bGK20IrgzYyvl4KLvfqizFgphYWuujKd//E0dbWhqH1o9Da2uqYNrDl6cqGn/70p7jssssM55599tlcNU9IQULBlZpCFVwDATvTDIHEjZP15ex4vNR1XpBjQilhKqJxnVe03USvV3S9VqLXK36tV8pNi1OQtFyqaYX5nFIY336O68jJwLYAxRaQY+8WUBiD1yIRXKRAGCD3N2dXud9+++Gmm27Sju+66y7MmTMnV80TQkDBlQo7gitfXi47WBlPxmdJFUXdLJphfDtmoeStRDX0yLpw8BYiG6rRDdUQ8GoUQ31oefV8iRx9eT2yaYRDyGnWXqUg6WDabtQ+u9EB7dTldL0WyVk4fLu2qVEI7a7ZyqAPM772YhdcTuPiNTFMPMklOXva7r77boPImjFjBn74wx/mqnniEgXurC5ocu1VcXv9VrHtv6XHacFVqMQLnnTEZ7crvFKFk08XUt4TyxMVUMZr0IeVV8VX3/m+fCWxvbnU83rxpR67uhYqm2iAdl5O2eqQwHJ9IJvJtdsVWvp2bJKV2MpmOmGhCIhCsaOQyHefFPrUwgGCrafg1FNPRXNzc0YNHXTQQZg1a5Z2PHv2bNTW1mZUFyHFTn8TXE6RjzV3bgiuYpqlmM7blY3w0p/XCy8re3nFe71Uj1hfG0avV4nH6N2KF18lHtlUfGU7GEo7uHZSHGWDQ6It5wILyNzeHHq1gDyJLSD/z5aeIppWSC8XyTW21nSFw2Hccccd2LNnD6ZPn47TTjsNo0aNslR2+/btCIVCKCkpAQAEg0E0Njbat5iQDCnEIBq5gIIrOfkSXLm6VrPQ8WZ7dsWHkI+PSBhfj501XvrzqvCKX+cF9AXLUIWVWVj5aMXJ1noBWoTDaCPaVSVb7+WR4kRXhmrZ8rows0Fetmu7+uOgNJt2M/1FPx9r1bIRWkBhiS2gqAQXKSAG0H22JbqefPJJVFRUAACWLl2K+fPno7q6Gu+8807asqeffjrGjh2Lgw46CADwwQcf4N57783AZEKKm1x6uSi4ksOgGanJRngBfft4AX0BNrTzugAbfXkTg2xECycZRCcRXx4pFgVRluCBhIgiUgbbELLXkWnS6uDbdlCOPA84CuLX/nyIrCzbzbrfKLjySk6f+3z3DacWFgy2RFdzczMeeugh/P3vf8eaNWvw1a9+FaeffrqlsmeccQamTZuGV155BUB0jdfEiRNtGxwKhXDXXXfhxhtvxKpVqzBlyhQAwL59+7BkyRJUVVVhx44d+NGPfsRAHYS4hJPrt/KBXcGVSy+X02IwU29XNF9mwis+rxWvl1ofAEfFV1RgIWmkQ4Pyc4CMxZeLFISw0pMvkZVl23kXWkD+B/BmuGFTIV4nIVliS3QdffTRCAaDuP3223HmmWfC5/OlzL9q1SpUVVXhK1/5CgBg4sSJCUJr3759eOONN7Bw4UJLNvz+97/H7Nmz0dXVZTh//fXX4+CDD8a1116LxsZGHHbYYfjiiy8QCARsXCEh7tIfvFwUXMnqtW9LPsmH8ALMvV5A6imHQGbiq+8a+8SXBxJk3V5eudr7xw0RVnBiyoxsbcyjyFKh2EpBEQquAeXlIgWFLdG1detWvPPOO3j22Wdx+eWX48ADD8Rpp52G0aNHm+Y/9NBDsWjRIsyYMQPHH388Ro8ejfLycvT09GDXrl1Yvnw5/vrXv+Lxxx+3bEP8Xl8qjz32GN566y0A0Y2Y6+vr8dJLL+G0005LyNvb24ve3l7tuK2tzXL7JBGzgRpJhIKrj/4muCzXVwT/KJkKL8B8E+V4R1K810tN0+qQRN+5LMVXtD1Jtw+Y3vslxdZ2ISeKuSgEUjY4dX1OTIUqBKEFOCO2gMIduBeqXaR4GGDPkK2rXb58OQ4//HB8//vfx8EHH4z7778fkydPTprf6/XiqaeegtfrxeLFi1FfX4+amhoMGzYMJ554IjZs2ICnnnoKw4YNy+oimpub0dbWhuHDh2vnhg0bhk2bNpnmv/nmm1FdXa29GhoasmqfkEKCgsscNwVXoXu5ko1jk4WQNztrFtXQamTD+PxqqHfTNEiQIRkCzyULMa/f36tEluGJ/Y1GLDRGPEzMF82TdHBdQNMDCwonw9brb3ImId2T2ZQBjkVkVCMROuXdKtRBqVt29ScvVyHA9VwFhS1P1+WXX46ysjKsW7cOJ510Em677TYsWLAgdQNeL6699lpce+21CIVC+PLLL1FTU4PS0tKsDM+G6667DldddZV23NbWRuHVz8m3hyFXXi4KLnMKQXBZuXY3nxOztV2A+TRDwJrHy6zeVF4vNT9gDLQBpJ92qK87mt8Y7TB6Mk6YSVLMs9WXP376YcEOavOJ41HoHBz4OWibowNwp7xaQOE/kxRc1ij0+0hyji3R5ff78ctf/hLHHHMMPB6P7cZKSkowYsQI2+XSUVdXh8rKSuzatQuDBw8GAOzevRtjx441ze/3++H3+x23g5B8QsFlTiEIrkLHrvACEqcbApmLr/h6DXt+CZ3QkvrqSiXAolELjdeWTICJgfpLsCtrcRzuS4dtdHzQPZCElkqRCi5CCgFbouuvf/0r6uvrtSAWZWVlrhiVCeeeey6ef/55TJkyBY2NjWhsbMQJJ5yQb7MIKerQ5MUsuDLpd7cEV749rSrJvF1AauEFuC++1HJWvF+AdQEG9IkwvQCLXkOSzugPUwtdGxy7IFJdsNUVr4aTIkulWMSGm3bmoA8G3LRCoPCnFg7Ae2LriiORCObMmYOKigpUVlZi7ty52LZtm1u2mbJ8+XJ8//vfBwDcdNNNeOqppwAAv/rVr/Cf//wHF110ES666CI8/vjjjFxIBgxuDOopuJzB6vXnSpyn+h5OtsYLMF/nFS1jfb2X+kplm9naL9lk6Y++Pv15jyxp67cMIeRj67tKPNG1XOr6roRuLxbBlWxtVbbrgMzWWWW75iqdzVkSvx7L8WmDTq3RUnHw2nNCkQuuvNBfr4tkhSRsfNOfddZZ+PrXv47Zs2cDAN544w387W9/w5///GfXDMwFbW1tqK6uRuPOXaiqqsq3OUVJgfyQn5R8ehrcHkxTcBnJheByw8tlxW4n5UC65sy8XlrZlOXstZfMA5aufHw7Cem6evVp8dc1sS6AkradsYwFJriKyVsFFL/Hwg1PlkqxDsL7geDKi5erEO43PV1Z0dbWhqH1o9Da2uqYNrA1vXD06NFYtGiRdvzNb34Tq1atSllm8eLFOOKIIzBnzhwceOCB2vnXXnsNY8eOxbhx42yaTAoRho03pxinFlJwpWvDRt0FfPtTTTUEkk83BJJPOYyW63tvNvUQMJ9+CKQWYImeMyPx99EDqa8ddSok+qYWqmmKEPkVW8WwtspQd5ELKz1uiiyg4AeVKSlm2/NNIfRdoQuuAYot0bV9+3aEQiGUlJQAAILBIHbs2JGyTFVVFSoqKnDXXXdhzZo1GD16NI455hjMnj0bL7zwQtJ9twhxikIe+GaL09dGwZWuDRt128ibL3FuRXgByb1e+q/1TAUYoAumYTL10MpaMADwmF1LXLRFD3SCK9djkkKOCKjV2U89D26LKz2FMODOllxcQ3991og1Buh9sSW6Tj/9dIwdOxYHHXQQAOCDDz7Avffem7KMmv7tb38bjzzyCObPn4/ly5fj3nvvNeyrRUh/o9imFVJwpWvDdhNFQTrhBRjXelkRYEDywBt64jdJjic+eIahbIqNmPV4TIJ7uC64nBxQFHhEwHjyOsjNpbhS6U+Dx1xdS38WXP3peSCOY0t0nXHGGZg6dSpeffVVAMDdd9+NiRMnWi7f0tKChoYGnHXWWTjrrLPwz3/+0561hJCChoIrVn8ReLn0mEUdTIYVAQakF2HRuszLphNjgDGUvGkdcS26PtvGicGWE0a6OOjLu9cgH6JKT76v3036meAipBCxJboAYNKkSZg0aZJ2/Pvf/x4XXXSRpbLTpk3D8ccfj1NOOQVTpkzBmjVrsHDhQrsmEFLwDEQvFwVXrP78a6iMsSO+gMRoh3ZEmB4rXrF40t1Hj65FV/8ds40UmI92TRhwHqpUDCRh0E/FVt5/IMgnhb6eawDfG0uia968eabnhRDYsGGDZdE1f/58TJw4EQ8//DD+/ve/48ILL7RuKSEEAAWXSn8QXIXg5TIjWdCLdKQKOZ+pIEvelo3MboxBMh04ZDIgciisek4pNCEVzwAe+AHI7fUPFME10J8pkhZLoquyshJXXXVVwnkhRNo1XfE0NDTg5z//ua0yhBB3oOBK1YbN+vuJ4IrHTCNkYnoqQWYXRYicx8EwYHdwZffasxi8FW1IdSfh4Dc5ue6bgSK4CLGAJdF1//33o6GhwTRtv/32c9QgUrwwbHwUNwfTTgocCq5Ubdisf4A9+NnoJyf+PWRJKvgZNACsd1QGA0XHNwAuVDiIdgYGlXCXQrnWovhgHLhYekpUwbV7926cc845+MY3voHOzk5ccMEFKCsrc9VAQkhhQsEVqz+DfigWL5cbSJIzr2yRYfELMOECLJSyaqQkWx6sCUk2vGwhy6lfbqJeY6Yvkjn57Mc8tEkvVxEwwO+Rrau/5pprMG/ePJSVlaG8vByXX345rr32WrdsIyRrci0MBoqXi4IrVj8FV16Qbbw8kmT6kmIvx0lXp8WBcEYiy01RRdFUHOS77/PUdl4FF59zYhFb0QsbGhpwwQUX4L333gMAHHTQQaitrXXFMEJIH4UkuPJBIQou4ix2hi1WxFKyQBvxRZ1ca5ZScFkYmNkaODoppkhxUyj3ME920MMVg1MLCx5bouvLL78E0PeF197ejg0bNjhvFSGkYCkG72EuBBe9XNaxOyRKJ6pSRS40K2rWvuNeriwEl6VBY6YiiwPS/keh3dNCsyeXDORrJ7axJbqOP/54TJ48GT09PViwYAFWr16NBx980Hajp5xyCp599lnb5QgpZNwaUBeSl4uCK9YGBVcCTgsrwLq3KpkNVsSbI9orWSUpBmSuCC0OAPsnhXxf82wbvVxFBO+VPdG1aNEiTJs2Da+++ioA4L777sPEiRNtN6p6zAghuYOCy6wN203kTXDZvTa3yORrsxA8V/o24nNKQrE2eLMzaMhUcFkVWhzA9D+K6Z4WgK15F1z5bl8PpxYWBbZEFwBUVFRg8ODBAIDy8vKMGnVl8TIh/ZBCCUVOwRVrY4B5uDIdUmQqspz0YGl5k52P1SHF7o9l4RWPmS1J6slabBXSII/Ypz/cvwK5hrwLLkIywJboeuKJJ3DJJZdoe3NdcsklePDBB3HmmWe6YhwpPgbqXl2FPrAubOuMFKLgylR0FvpzoSebIUwxiSz9eQkARN/Tk7Hw0mNXcKUTW/keXOa7fVIYFNBzUBCCqxBsIEWHLdH1wAMP4PPPP8fQoUMBRPftWrRoEUUXIS7glHepmKYVUnDllkIRWnanC2YlsuLbEVlM3LQ4a8N0kJhKbLk9oOOAkVihAJ+TghBchUYxzB7jfQNgU3QdcMABmuACgGHDhmHq1KmOG0WIExTK1LxihoLLZgNaO852nFPrubL92usPQksfIl6SAESSNmkfk4GFLcHl9MCEAx2SCQX63BSM4CoUO0jRYUl0bd26FQAwduxYPPLII5g1axYAYMWKFSgtLXXPOkKKADc8GoXi5coVFFzuMVCEVqpAGarQUptS13FBUQzTC6NpDkwxjGFZcDnRXrELtmw8jiR7ClxIFIzgIiQLLImuKVOmYPDgwaaDiZaWFtxxxx2OG0YIyS+58nJRcKUm06FoIYstq0IL6BNQmXq0DEJLQBvca9MKhYieszuoi7+GuPKuC65cl3MbJ+yicLNOoT4HJhSU4CokWwBOLSwyLImuH//4x/iv//ov07Sbb77ZUYMIIc6QzfC/kKdmDiTBlQn9QWy54tUSSuL6LaHzdGUivJJgSXBlFCnRmZD1/ZZMr7m/i7UifhYKSnARkiWWRFcywQUA1113nWPGEEKcETyFMfxPj12hMtAEl53r7a9iy1GvFqATWcJciCGDKYbp8mYruJzeQywFbg1yswpY4jb9Qaz1M3FSkGKrEG0iRYXtfboIIX0UinfDSQp1WuFAElx2rzUfgqtgxRaQXGyZeb2UsDFPlgOrhMFiNoIrVd4M7MznQDaTtgtaqAEchLsEBZdFimFqITFA0UUcZ6Du1eUE+fZyUXDZbae4BVc+vFtuiy3zKYRx6fophW6SqeDKUmwV5KA1A6xeR8GLM2KZ/vLskhi8nwYougghOaU/CK5CmE4I5F5wueHdSrVmy3WxJZRoBMNs0A0qUg4Ys5kimKasIwNVpwdHORRC6a6foqzwKWixVci2kaLC9pPU29uL7du3Y+vWrdi6dSvOP/98y2U/+ugj7b0QAuvWrbPbPCEFg+N7MQ0QL5cdBorgUlA4gkuWnBdc+jolJAouSZIgSVJCPmMdEiQpaockRGzdlpIouIQCKJG+NVtKGJIS7guaob4iYUAxX9MFpBmoW5nWk2rzY9M6k0Q2TDLgE5KsvSzXn+rlNOnac7PtOPR9Ff8i+Yf3IQM4tbAosfWk33jjjRg0aBBmzZqFOXPmYM6cOfjb3/5muXxFRQWuv/56bNu2DbfccgtGjx5t22BCiPMU4rTCgSC4MhFb2WInXHtfmbh8MH55qKIpXZ16sRU/ndBMlEXPS5rgApAgtiSD1ypObMULrTixJSnhWBmXpxymG1QmE1wmWBILeRA2WZFHUUYxlj+Koq8L3b5Chn2XgK3phc888wx27NiBqqoq7dy9995rufzYsWNx+umn4/HHH8ell16KQCBgp3lCLFOIXhu3KfRLdjPoSLEJrmyH9Zl+lTkluKzUaXXtVtZTCZNFI9QLKfVY0U0zVMWbQxgGj3ovl90phynElq16rOL0L+Zu/J+nuj6Xpg6m6m9OV8yOghdaKoVqJ71cRYst0TV58mSD4AKAo446ylaDM2bMwOuvv47q6mpb5Qjpz+RTJOaibTfXcQ00wZUp+RZcma7dsh2R0IbYkuLz2iUrsWNNcCUdoNqKgpjDQZrVtpz6n0rWDy4Ko2T3hGIsNUUjtghxCUui6//9v/8HIDo9cO7cuZg1axb8fj8A4IUXXsDKlSttNTpmzBibZvYRCoVw11134cYbb8SqVaswZcoUAMANN9yA3/zmN/B4PACAQw89FM8//3zG7RCSikILFV9Y1hih4Iq17UgtmVEogstqZEJHvFu6IBkpBVd8vdkODK16ufQ4KbaK5VfwVHY68T9n1k8uiyKKsUSKVmgVq92koLEkup599lmcfPLJGDlyJEaOHAmgbyCS68Hn73//e8yePRtdXV0Jae+++y7Gjh2bU3sIyZb+7uWyQ38UXMU43MpWcFmZTpiYz2yDYxe9W3FBOITsNZa3MeiyPbCUUgsz0/pSTi/MUGgVasRCs+spUiEGDLypikUrtFQK2f6i+VGlgPswj1gSXbfccgvmz5+fcF5RFBx33HGOG5WKyy67LGnaHXfcgUAggN7eXlx55ZXYb7/9cmgZIfkh06FIoU0rLCTB1R+8Wyp2vVy5EFxZTydM5q3SNjy2KLgiuo2RJQe8XHqseKri8tgSW1YHX7kc/KRrK6upnDkSYjkWQf1FkBW90FLpL9dBChJLoksVXHfddRd++MMfauf/+Mc/4s0338SsWbPcsc4Gs2fPRkNDAyZOnIj33nsPs2fPxqeffmq6dqy3txe9vb3acVtbWy5NHRBwg2RSKFMw8yG4CmWoVMyCK9PphJa9W4qxTngc2LYyXZj4FAM6y4Irndgq5EGj0+uv3BBieRZhhqYLdP+xfiOwCMkxtv5zNm3aZDhevHixtrYr38yfPx8TJ04EEA3WMXjwYCxdutQ0780334zq6mrt1dDQkEtTSZHjaFCFLKsqZC+XHdzycuVacOUiBLwTw52iE1xCGAWXmYfLruASAlAiWmh5g5BTrzljMWDhLunyJAxizUKlq5uUJaurGELDJ8PJMPHaZm4p+isb2wqIVPuPufnqtxT6tXFqYdFj6ae9cePGQZIkNDc347nnntPORyIRTJ061TXj7LBu3TpNdAGAz+dDd3e3ad7rrrsOV111lXbc1tZG4UWIgxTCtMJ8CK5CIpWXy6m6shVclgJmOLR+K7onl4nHTFGnGLr8A2KSaYWmgiuhrJlK7ucDG6fWX8X3XT/yhBEH6e//T6QgsCS6li1bBiEEbrjhBtx4443a+UAggGHDhrlmnB3OP/98LFu2DCUlJdi9ezc2btyIo48+2jSv3+8vGA8dIZlSqF6ugSa4im3IZdfLZSVKYfy5nAguK+u3lLDpdEIpdl7bUDlWj611XbF8mmhKNbUwU8E1EMVWKpwQPPo+7QdrwogDFMP/VLF4uUhKLIkuNcT7I4884qYtlli+fDmeeOIJAMBNN92E008/HYsWLcLcuXPxrW99C2PGjMGGDRvwhz/8IavQ9IS4TaFN8StkKLjsYcfLlW5aoRlWwsI7IrhSBcxQ4td2mU8/NAguJWJMVyIQSkx4OfU7XKYDuBwJLjemh+Ut4EO2gsdpLxhAEVZsFIPgIv0GSdgYcWzbtg2XXHIJXnvtNQDAvHnz8MADDxT91Ly2tjZUV1ejceeuhM2fSebkU1O4KWgci2yXh/VcxejlKkTBlc9hlJUhgh3vlD5rpuu43FnDZUFw2Vm/pRdkkVCsKgUIB6P1VgyC8JYY1+7Er2HRzkvJPV2pAmIk83KlE1wZDgwLYf1N3gRZtu26EQiIAqzwKID/EUsUi6erWPrTAm1tbRhaPwqtra2OaQNbvXPBBRdgwYIFWLVqFVatWoXjjz8e3/3udx0xhBCnKAbBlS2FYYURt6YVWq5zAAiubLAyrdCYZn0dl7X2C0BwKeE+wRUOAeEgRCgEEQq5NyBOtw+Xg4KrEAMe5C0QQ7bBL5wMxmFmU4HcnwFNsdyDYhFcJC22YuSOGDECP/jBD7TjKVOmYNWqVY4bRUh/Jx9TCwtlOqNb67js0J8Fl9Wphdms47IbOMOW4FJtcENwxdZviXAoOrUwFNLOSULp+zFD2FjbpSdVGSsh4fX9blNsWcKtQaZNwRpvr+veMH17hbAOTKs3S7tI5hSL4CL9CltPXVVVFdrb27Xj9vZ2jBgxAgDw29/+1lnLCCGmFIh2MuCGB9CtaYWZ2KqgOASXm2QaOEMvuDQyCZqRqeBSwprgEoqSILhE7JXVoDdZEI10Xi5DXvuCK6XnyMkw7Okwa6tQPXSF6AGLt4uCwF2KqX+LyctVTP2aJ2x5ut566y00NDRg8uTJAIBPPvkEBx54II499lisX78eS5YsccVIQkh2FMqUy3yv48pUcBU78YIpEy+Xlh5XZ7p1XPr2JJ1Y0ogTX44LrriAGSIUjOZRBVc4ZGhbAGk8VhkMguLXf8W3YVNwpRRahUSGYd9z5gkrVA8YQC+YGxTa/wcZcNgSXWPHjsVdd92VcF4IYXqeDGwkFKZXJlMKJYBGsZLvdVwDQXA5uTeXHqvruNJGKtSLJUAnrEwiDybDacGlRLRzdsnYK5Oh4MpGbAmXng3J7v9VBtH99Ndd8ALMjTnRFGDZU4yCq5i8XMQStkTXPffckzRS4X777eeIQYSQ5BRaxMJ8Tiuk4LKG2bRAQ7ruvVXRlszLZczTd1KKX6ulJ15wGdJMvFywILjUNIuCS0Ri+UyQhJKZuIqLWGhaR7aCK0UZt0SW1XYsizGbgiKnAqzQvF9ARqJ1wFOMgov0S2w9iT6fD+eccw6+8Y1voLOzExdccAGampoAoOjDxhNC3MPpaYVuCq7+vn7L7lg8k/DwdiMVJpxX/yaZVmg1aIa2B5fOm5UguELBvjzZkE0wi5TiyWSdU5J1P0KStJcdhDB/ZYPeFsv22FzT5PoasEJd/2Vog+vAUsJ+yQ3sZ0vY6qVrrrkG8+bNQ1lZGcrLy3H55Zfj2muvdcs2QoiOYvVyubGOyyqZCK6BRDovVzovmVbW7Fxc4AwDcZEK+87ZW8eVLkqhKqYMQTNMBJd2LpdYGIjbFVtJ60kiqtKJq3Tl7Px72RZhNsREToJwZCts3BZfAAWYnmLvB04t7JfYeiIbGhpwwQUXoKKiAgBw0EEHoba21hXDCOmPDNT1XE5itQ8HmuCyIpoy/R5P5+UytplmWqFDgTM0wRVfT5Kw8EK/ditecMX260og06lbyaYW2vBymQquhDzJBYxTHqt0ZCrE3BZgrlEM4gsw9lkxi49MGGjXS4oGW2u6vvzySwB9X7jt7e3YsGGD81YRUmAUyqbIhUK+vFwUXM7htpcr6bRCIHHtlZm4sSy4RF+auvGxOpUwEjEILhEOamu49B4uoRNjkqzzKlsZvCULF58KLbpIZoIrldCyg2KhgJyBQIivNl0VIolQN8XiGjDX134VcuRD0/YGQDCO/iK2is3L1V/6PQfYEl3HH388Jk+ejJ6eHixYsACrV6/Ggw8+6JZthJAYhTS10GkBSsFV2Nj1clmaVphs0Kf3cultiAucYRBcapTCWBmhKFHPVSQCqOHg4wVXOJgguIQSSRudMRMSvFxpBlRJw8ojc7FlRVxlWtaKKLMjwjISYGlEhNqnBRl4A3A38qFpe/0sGAcH/aRIsCW6Fi1ahKlTp2Lp0qUAgPvuuw8TJ050xTBC+hsDbWqhk1/jbvVdkQ81UmJ1amEmXq5UwTMAC9MKAVvTChMCZwB96WaRCnWCS4RDfZ4uVXApuvwxgabt1+UU6QaCptMF7QmuZGP0bESWXczaSifE9EUcEWAUX9lRrCKsP4qtYvNyEVvYEl0AcMABB+CAAw7Qjn//+9/joosuctQoQkh25NvLla/gGW5s1NwfsTpUSeblSpo/zstleVphunVc+vqshoYHooEzlKgA65tqqPQJL3Utl6LzihUCaQRXIYitVOjtcFqAUXzlgAw3tc4J/VFoFTO8H7awJLrmzZuXNG39+vUUXYS4SGEMo5wnn9MKC2T44BhubYpshiUvl5VohanIIHBGytDwsXQtaIbJmi8RySJ6YQoPleFcirVcyYI/pBNchSK0khFvXyoRpmZ1THwBltZ9Fbz4AvInwFTyKcQGysCeXq5+jyXRVVlZiauuugovvvgi/H4/Zs2aBQBYsWIFpxeSgmKgTeEzo1i8XJbqouByBP13udUAGll5uZBkIGvVy6XLnxBoQx84Q7+OyyRwRtK9uFSPWGzqoer1chqrUfSSTSvUCy6zR7zQBZcZVrxgVrxfTk49LHjxBeTf+2VGquc7o+AiA0RckQGLJdH1wAMPYOTIkXjyySfxwAMPaOe/+tWv4oorrnDNOEIKAScCR1AMGnFy3EDBlYjVyIOZ1puRl8tsuqFWLsm0wngvV/w6ryTruFJGKgyHDIJLCYUhIoq9NV0ZrNdKF7EwPi2V4MpGbGVa0o1HSr2OnHq/8i2+sq27EMWXGRRQ9qCXa0Bg6b9i5MiRAICPP/4YPT092vnu7m6sXbvWHctIv4AfI9lRKF+rherlouBylmy8XKbBM8ww8XIl1KfLY2Vaoek6rmSBM1QvGKIeMhFRoIT0Gyo7/KSkGXya7eHlpOASca9Mia8n2/r0KEJor6TtW9gDzNK+X/ne68upfbNytd8XIcmgsLaNrUAap59+OkaPHo0ZM2YAAP7zn//g5z//uSuGEULsk0+PmpPBM5y+joEsuOxELbRUn+59gocinZcrg2iFfXWZTCtU12ylWseVJHCGEg5BCYZNPV2SULIedJuWTwiQYb7hse6SDVgVXLn8GIhvK1sZkM775YjnqxACbjgx5RAoHs8XSQ7F84DBlui68sorMW/ePCxbtgySJOHWW2/F1KlT3bKNkH5BsU8tdHJfrnxMKxzIgiueTGREqn25ounWQsSnxGK0Qq3e+GmFei+V3ssVv47LEDhD0QSXEol5yww2KfZ/yU2WPwPvi/7xtiK2rPw3ZPNZZHXKqr6JbIaSTokvp6IdFvR6L4Dii5AiwHbI+GnTpmHatGlu2EII0WH3q7MYvFyW6nJwWiEFl3WSTS3UY8vLBVj3cqn1x+dLN60wopsqaLYfV4p1XEooHKsmemwaMj6F8HLDE6Z6aOwIrlSpTn4mJKsrlRhzQoClC7yRTnwV1XqvNDZYq4fiq6goVi8XpxZmBHuNEJKUXHu5KLjsEz9N0IpHwu7UwlReLsOxXS9X/LRC7VzcJsi689G3urVZqucq3quVZh2XiCiIBEOaAFPCIfOH1O4gOFn4+KResOh5s7VImQguRfS9coHV9pxYB5bNmq+iWO9l0QZr9XDNFyGFhm1PFyEDCSdFR39loIibYsfOUM4sgIatiIWANS+XDqvBM9JOKzQLD6+bVmhYx6VEpxgqEQWRngxCxsvOD76tfOQkE1vp687u8yydWI+3IZlYV7NlIgmynXbo5Hqvgvd6AfR8FTIUxQMOii5CXCTTX5sLYWohvVzFj9XvdLNQ8PFp6eq2MwA1DZ4BpA6eYbYJMpAYrTBdePhYuUgoGkgDgOb5SmWvHe+Gcd8tkylxcREL7UwrjD+b6v/G6R+NzOpLJcRU2wpVfBXFlEOn6qb4Ik7BqYUZQ9FFCMkYK8MBCq7CwurUQiv5LO3LlWmIeLVuk2mFhoAYZtEKLUwrVD1dkZjnK9zTa6lfEo13fgCSjeDKtXde316yZ0Zvp5kAy2btlxXxlfV6r/7i9QKinUHhlX/o5RqQUHQRQhIo1mmV+RBc6bqq2L5bbQfQgANeLr240okyrd4kwTPsRCtMNq1Qi2AY83pp9XqyFFNJ1nOl83JZEVyZiC0nvOHp1gvaEWBOe79Sia9+4/VKY4P1uuj1yivF9qVAHIOii5ACoxCmFlpq10KeXHq5cim47IxVrIS2tkqmMiBVuUynFpoOUjP1csXSDcEzkni5EoNn6KYVmni5Uk0rVIJRwRUJhREJhRNsKxRSCa5k/xtufC5YXbMFpBdgboqvfuv1smiD9boovohNOLUwK9h7hJC8UWyCK12EtHRl3UY/gM1G5CXzUpiFibc9wEzm5QKSerlSBs9Q86jruOI2QU41rdCQ1hM0DGZtX5fpZsjJVKt1L5ddwWUncqFI8rKKPnJhurVlqcRhyrI27OmrUyT3GFqIcpgSixEOXUWSnR38MtJh7mA/D2jo6SIkCdlOsSvWTZGdEjn96cdTp64l1S/tuSDdOq10UwujdSQpbMHLZRqxMJaeyssFIG3wDP0r2SbIZtMKI6EwlFAIStCBr0NT4WUytdAidgSXk8IlWf50j27atVsxm+16vgrO61UI0w1VO5ysn54vd6HgGvDQ00Vchx8z7lGswg4oDi9XNp6tVHUWCplMLQRShIlPhxUvl50Q8UDa4BmGTZBNphWKSFSYaYE0srxBVoVVOi9XMsEV7zVK5inKxHOVDjsesVQeLPUa7HrqMrmeAeH1crxOer6ICZxamDX0dBFSQOR7PF5IXq5CEFwDESt7c2npVoSXXS+XWkbFQoj4VMEz1OmD6rqu+GmFSiiMSDDJei6hGAcaQgEkT/prToXJwCXVpr/xgitZmpbHohnpfvSwssl2fBVmRTL1fqXzfOXS61UU67wAZ71eACMdOglFLEGRia6mpiZcc801qKiogCRJ2Lx5M+68807sv//+2LdvH5YsWYKqqirs2LEDP/rRjzBnzpx8m0xySDF7fQYahX6v3B5nODXN0EpYd6u/TVoZZGc0tdCQL85Dlmwtl97LBRiElFUvV3zwDBFRoER0YktRoIT61niFe4K29+NKikkdZvUme87MTqcTXKke2Uz+35KVSRk8I/Y3WZaUQkoIW9MOM5lymC7CIacbmtXJKYdZQ8FFYhSV6Nq2bRtKS0tx3333AQDuu+8+XHjhhVi2bBmuv/56HHzwwbj22mvR2NiIww47DF988QUCgUCerSYDkVyICqfboJerf48rkgk016cWKjohptXRd2y6lksra/RyAbDk5VLCIdPgGcIQIr5PiCnBiFq59etKR4qBVqppa2bTClMJrmSPrFufQek8V4DRplTerwQhlWbNl9teL0dCy/dnrxfQvz8kSXI4tdARiqoXp0+fjt/85jfa8fjx49HY2AgAeOyxx3DSSScBAEaOHIn6+nq89NJLebGTkEwYKF9l6QaDA0VwudmelR9WrXi2+vKmmFqYLoCGnngvV7Iph1l4udTgGdoUQlVsxUQYgOhaLp0IU2LpiISsd4oV4gcq+qAaSdZyqZj9n8SvdzIraSd6YbZYilyI1MIw2Z5jdtZ7ZbrWKxlFv87Loh2Z1cv1XrZgXxEdReXpAoy/gD377LO47LLL0NzcjLa2NgwfPlxLGzZsGDZt2mRaR29vL3p7e7XjtrY2Q/rKlSuxb1+L4dy0adNQXz8SW7duxSeffGxIGzx4MGbMOAzhcBivvvpKQnvz5s2Hz+fD++//B3v27DGkTZp0AMaNG4ddO3dizdo1hrSqqmrMnDkTAPDyv/4FJW6AMmvW0aisrMRHH36I7Y3bDWnjxo3HpEmT0NTUhHfffceQFvAHMPfYYwEAy157DT29PYb0ww47HIMGDcLnn3+OTZu+MKSNGjkKU6ZORXt7O956a7khTZZkfHXBAgDAihUr0NbWqqUJANMPmo7hI0Zg06ZN+Pzzzwxlhw4dikMOORTBYBD//vdSxHPcccfD6/XivffexZdffmlIO/DAyRg9ejR27GjEhx98YEirqanFEUceCQD410svJtR79OxjUF5ejg8+WIudO3b02SuA/fffH/vtvz++3LsX//nPfwzlyspKMfuY6PTV1/69FMGgcbB22OFHoKa2Fp999im2bt5iSGsY3YCvHDgZba2tWPn224Y+8no9mHfc8QCAt5a/ic6OTkPZ6YccjKFDh+GLjRuxfv16Q9qwYcMwbfrB6OnpwZuvL0u41vnHfxWyLOO9d99BS3OzIe3AyVNQP3IkGrdvxycff2RIq62rw4zDDoeiKHj1lZcT6j16zlwEAgF8sGYNdu/aZUjbb8IEjBu/H/bu2Y21q1cbBkZl5eU4atZsAMCypa8iEomuq1EHW4cdeRSqqqrx2aefoHHbVq2cAqBh9FhMPOAAtO5rwXvvrDK06SvxYfax8wAAK958A93dXXF9eCgGDR6CTRs34IuNG6InY4YNG1GPyVOnoauzEyvfejPhWud99WsAgP+8sxKt+/YZ+3DqNAwfUY/t27Zi3aefGNLqBg/G9ENmIBwO441/v9qXEPs4mz13Hnw+Hz5Y/T727jV+RkyYOAmjx47D7l278MkHawxpVdXVOPzI6GfEsldfhhITKurH5JEzZ6GqshIff/QRdu5oNJQdP34cJkychOamJrz37ruGsVRpIIBjdZ8Rwd5eQLc31+GHzcDgulp8/vk6fPHFxtgoNSq8GupHYOrkr6C9vQNvrlgBSYloEQtkScIJ82YDQsHyd/6DttbWmPgCIBQceuAEjBhShy+2NeKT9ZsBJQSEI4BQMLSmEodMHItgbxCvrloDKGGDIDtuynh4hYJ312/F3ub2aOCMmFdr4uBq1JeXYUdTKz7a+WU0WmE46gWrlD2YVlsNJSLw3L/fAnyl0fsiyYAkYc7MI1BeUYU1H32CHbt2a+cFZEyYsB8m7L8/9n75Jd59f21sQCoDkFBaXoa5c+YCAF79978RDIW1Gy4kCUcccSRqa2vx2aefYvOWzdHzsXszatRoHDh5MlpbW/H2ihXaPROi7zNCwPgZoZY96OC+z4iNG5z9jBg5alTaz4ilr7yc4Hk6Zm70M2LtmtXYs2u3IW3/CRMwfr/98OXe3Vj9/mpDWkVFOY6efQwAYOmrryAc7lt7J0nAUUfNRHV1NT75+GNsjX1GqG2PHTMWB3zlK2hpacGqVSsN9fpKfJg3fz4UIfDG66+jp7vbkH7ojBkYMmQINm7ckPA5W19fj4MOOghdHR144403AEQ/sxRFgRACX/3qVyGEwNtvr8C+uM+IKVOmoH7ECGzbvh2fffaZweM1aNAgzDj0UITDYSz992uGcpIEHDt3bnQcsXo19u7daxgLTZw4EePGjsXOXbvxQdx3YFVlBWYedSQkScLLr7yqfUZE65Uwa+ZRqKysxIcffYTGRvU7MFr3+HFjMWnSRDQ1NeOdd98z6Ad/IIB5c+dAAvDvZa+jt8c4jjji8MMxaFAdPl+3Dl98YRyLjRo1ElOnTEF7ezuWv7XCkCbLMhZ8NfYd+PbbaGs1js+mTz8II4YPxxebNuPzzz83pA0dOhSHHnIwgsFgQh8CwPHHzYfX68W77/3HZBzxFYwZPRqNO3bggw8+NKTV1NbgqCOOAAC8+NK/Euo9ZvbRKC8vx9oPPsQO3TgCkoQJ+++P/fffD3v3fon34sYRpWWlmHtM9Pl+9d+vIRQMGtKPPOII1NbW4NPPPsPmuHHE6NENmHzggWhtbcWKt43Pt9frxfHHzQcAvLF8ecI44pBDDsawoUOxceMXWBf3fA8fPgwHT5+Onp4evLbsdcO1AMCCr0Y/I1a98w6a4z4jpkyZgoZRo7Bt+3Z89JHxM6Kurg5HHB79jPjXy4njiGNjnxGr16zBrrhxxMQJE7Dffvth9+49eH/1+4a08vIKHDP7aADAK6++aviMAICZRx2F6upqfPzxJ9pnhMrYMWPxla8cgJaWFqxcZRxHlPh8OHzGjAQ7s0US2cbFzhPPP/88nnzySfzhD39AS0sLBg0ahL1792Lw4MEAgJNOOgnHHXccfvjDHyaUveGGG3DjjTcmnD/iyCPh9XoR7A0mCJySkhJ4PB5EwmGE4m6qLMvw+XyAEOjRiTkVv98PSZIQCgYRidsc1Ov1wuv1IhKJIBQyDtxlSYLP7wcA9Pb0JPyS5/f5IMkyQqEQIpGIsV6PF94SLxRFQTDuH1mSJPjVent7E35R9Pl8kGUZ4VAY4YjxWj0eD0pKSiAUBb3x9SL6QQwAwd7ehF8SS0pK4PV6EQ6HE/4x1D4UQhgEsXatsT4MBoOGLw2grw/DYZM+VO8NgJ64LwV9vaZ9GKtXUSIJosrYhz0Jv4yqfRgKhaCov8xDgiRJ8Ho9KIlda7A3GP3yjH2ZyZKM0tLSaL3BoGG6jQTA5/drfRgKhWLno4W9JV74/QEIoaCnp0f7Uo7+lVBWXgZZktHb24NIJBJrN5on4PejpMSHcDiE3mAQUsxWWZZQUuJDWXkZJElGV2cnJFmGLEuQZQ9kWUZlVRW8Xi96eroRDkcgyzJkSYIkyygtK0NZaRnCkQi6u7ui9koyZFmG11uCmtoayLKM1tbW2DhXhizJkGQJtXWDEAgE0NvTjd7eIDxeDzweD2SPF5VVlaipqUUkoqCtrRUeTzTN4/XCV+LDyFGjIHs8aNr7JQQUeDzeWLoHI4bXo7yyEu3tbbFBf999Kysvx6DBQxAKhbArTqQAQMOYsQCAPbt2oTfux4q6QYNRXlGB9vY27Iv7MvIHSjF02DAoimIQkLHHAiNHNcDj8WDvnj0JIrGmthZVVdXo6uxE85d7jfX6Axg+YgQAoHHblr7nJZY+vL4eAZ8PTU1fJnzx1tZUo6a2Fr09Pdi7O/YlJ0mQpeiz3zBqFABg+/btUCKRvg2RhYIRw4YiEAigpaUl+gNVTDRJQkFlRRkG19Ui2NuDxsYdMe+XAET0mRs3qh4QCnbs2IFgb48myCQljKF1NSj3e7GvtQ3NLfuie2+FQxCKgjJfCYZWlyESCmNL486oVyqWhkgIDVWlkCCwc+8+dHb1QITCiITDiPSGUOP3oQxAR3cv9rS0I9IbjE497A3BqwjUStHfHyu+922grBqQo8EyhOzBqPoRKPGXYk9TCzq6uqKBNCQJQpJRW1eLmppadHd3Y9feLwHIUS+GJKPEV4JRoxoAAFu2N0KJRABJ1jwlw4YNh8/v1340BPoexYqKStQNGoSenh7s2rkTgG5Knixj1OjRAICdO3agp9f4OTxk6FCUlZWhdd++hEF/WXkZhgwZinA4jMbtxh/qAGD0mDGQJAm7d+9CT7fx+R40aBAqKivR0d6OpqYmQ1qgNIBhw4ZDCIEtmzcjFAoh2NuLcCiI3mAv6uoGIRwOYfeuXWhtbUUoGEIw2ItgMAiv1wuP14P2tnY0NzUhFOyNfkdEIhBCIBAIIBIOo6WlRTsfDkfvbYkv+l3U1dWF3t5YuXAEkUg4ukYMQDAUQk93NyJKbMuAmDjyeDxQFCX62a+l9fnMhBCIRCKIRCLRMkDUOxoTWIruPcmOpFOfzTzsFvMm5JKkvjxCRKel6oMGaelCN800MV3EiVYAkGRJazF+PCXLcjRfLIpmvJ0eT9QjqT57ks5y9btWKHGe35gtsiRFn8u4NiVJgkdW61USOsMjeyBJEhQhIBQl4TplWQYkIBJJvFaPxwMJUU+xcQN0xL77ZShCgVBMbPJGP2cj6vhP167X44Eky9Efy7Rxj9qH0bEGhEBE6RunqeMUjzf6eR0Ohw39B0THRZIkIRJbx6u/Vo8sw+P1QChCG+v2pUf7d+MXX6C1tRVVVVVwgqIUXc8//zz+8Y9/4MEHH4THE+3sqqoqrFixAlOmTAEAzJgxA9dffz1OP/30hPJmnq6GhgYsWrQIJSUlubkIWJtG1Z8YaNcL9F2zfrpMRu919aXLH44oSfMgWZ3qVC4hoKYosQ96dYChDTTU90J/ziSfMB5HIsnKGvPlkpKSEpT4fPD5fCgpif71+XwoiR2X+Erg8/lj6SXwxcRp/HGJrwR+n1+rK1BaikAggECgFP7SAEpLy7RjfVqgNIBAaakm/tMRP2FIX8ZsY2Q5SV41v6R7r+aJDyOvTi3Uiy7LUwsVBZIS7luvBcSOo/kk9UcdJRItr4T7pgsaNjiO9AmwSCSapm6GHA5BhIJAOAQlHIISDMciEoaiUwdj0QkjPcHonlyx8+GeIMLdIURCCsLdUTsO+n9XQ6oZ2ie6PN6o50r29k0Jkz0x8SQDsm6T2pjYUkVXn9dLN50sJrrMphaq78zWcSWbUpjJNEJ9vcFgEG1trWhrbUVbWxva2lrR0daOrq4udHV1orOjE13dXejq7NTOdXXG0jo7Tc+b/WhmBY/HA7/fD5/PD7/fB0/sR68Sb/THOm+JV/shLPojaPS9z1cSyxeXrpWP/lV/mFEHwdEBrawdy7pjWR3U6s+ZlDMrqx3rB/lJ+t/SeTt5bZzPdR25bM9K2YQ8GZRxol3XytisM6+2OlBH/P1zot2enh789re/dVR0Fd30wqeeegrLly/H7373O0iShCuuuAL33HMPzj33XDz//POYMmUKGhsb0djYiBNOOMG0Dr/fr3kp9Nx3//2OdSwhJDPUX5gVRdG8ovpXRPdrdzgcRkT/Xs2nO5csLRQKRV/BIILBIIKhEHp7e7Xj3tjfUDCI3t7eWJ4gWtrbY7/ShxAKBRHs7dXV04venl709HQneF1TIUkS/IFAgjArLStDeXkFysvLURb7W15RjvLyCpSVl6OiokI7X1FRjoqKylieCpRXlKOyvAI+n89UcJnZoL1PSLNzB2PYCBOvj1gYLWtzX65wyHQtl34jZACGEPHq+i6hW+sFxejttkvKtToZrrFJJ7hCoRCam5vQ3BR7NTdr71tb96G1tRXtbVFRpX/f1tpq6v1XkWUZZeXlKCsrQ1lZ9G95RQXKyspQVVGOwXW1KCsvR3nsfHlZGcrKyrQfEQJ+P3x+PwKBQPQ71+eDP/Y+EAhEf5xQ02IefEIIKRTa2trw29/+1tE6i8rT9cEHH+CQQw7RphACQGtrK7q7u9HS0oKLL74YNTU1aGxsxNVXX4158+ZZqretrQ3V1dXYtXs3RRchxBEikQi6u7vR3d2Nnu5udPf0pH8fO1bfd3V3R6cVtrWjs6MDXZ2d6Ozo0LwMnZ0dab2DJSUlKC+vQFVVFSqrq1BVVY3q6mpUVUXfV1VVoaZGPVeN6urocVVVNaqrqlBTU4OystKo10zECal4T5cS7juvKAliSsuTAy9XpCcYDQXfHYyeC4UR6emNbYRs9HJFQlH7Dr7xcshDR/et27Lq6TLzcgFGT5duaqEQyb1cQgg0NzVh1+5d2LlzF3bv2oU9e3Zjz549aG5qQlNTE1qam9HU1ITm5qboFNk4PB4PamqjUx8rq6pQXV2NuppqVFVH72l1TQ2qq6qix9V9z0NNTQ0qKipQUVFh2ftKCCH9kba2NgwfNmzgerqmTZuWsBZIpba2Fn/5y19ybBEhhJjj8Xi0AaxbCCHQ09ODjpgQ6+joQEd7Ozpi7/XnWtvaNA9HU8s+bN2yJTq1TPOAtCVtp6SkRBuY19ZUo66uDnV1dRhUW4u6ulrU1VRjUG0N6mprMKiuNvq3phpVZQHNa5Y0TDxg7uVSydDLJZRYxELdRsjREPJhKMFIdEpsMBI7F61fhOPWqar7dsVvkmwFk/wdHR3Ytm07tm3bhq3btmL3rl3YpXvt3rULu3fvTvCSVlVXY/DgIRg8eDDqBg3C5MkHYvCgQRg0aBAGDR6MQYMGRY9j76urq6NrIAghhBQMRSW6CCGE9CFJEkpLS1FaWoohQ4ZkVZeiKGhvb0dbayv2tUbX+bTGRNq+2Jqf1n370LJvH5qbmtDY2IiPPvoIzc3NaGpuSQjYA0QDctTVVEdFWOxVW12JQbXVGFRdjUE11RhUU4G6qgoMqqpAXXUlBlUE4PN4+rxc6fblAgzCSolEtOmCSmwaoboRspo3GiJeRF+KgIhEX6p3LpOQ3oqiYMfuXdi6vRHb1Ne2bbq/29HS0qLllyQJQ4YMwfDhwzF02DAceOCBmDdvHoYPH47hw4ZF/44YgWHDhqGsrMy2PYQQQgoLii5CCCGQZVmbatZgs6wQAp2dndFpb83N2rqipuZmtLS0aGuNmpqb8en6L9CyL+pta2ltM13wXF4aQF1VJeqqK1BXWR4VZJVlqC0vRV15AHWVZagr86Ou1IfaUh+qAyWoLikB4tZyWfVyaZ6u3u4EW/T09vZic+NOfLFlGzZu3oYvtmzBF5u34ovNW7B5y1bDGqnq6mo0jBqFhoYGHHHUUThj1CiMih03NDRgRH19TgM3EUIIyS8UXYQQQrJCkiRtKmVDLJy5FSKRCPbt26cJM71ga25p6RNvmz/H+m070NzWgea2TnT2JEbIkySgpjSAmrIAakr9qPH7UBPwocpXgiqvBzX+ElTKMiokGZUeLyoUGeWQURqGFt5YhEMIh8PYtGMHPt+0Bes2bcVnG7dgw6Yt+GLLNmzfuUsTiT6fD+PGjMa4sWNw7Lz5GD9+PMaNH4+xY8di1KhRXB9MCCHEAEUXIYSQvODxeKLrkgYNAvbf33K53t7eaECJmDBrinnSWlTPWksLdr39Gna2deKTrh7s6+5FS08vgpHEoCMSgEqPF5UeD8q/9wU27W5CKBbtsKw0gAnjx2Li+HE47Og5GD9+fPQ1bhzqR47kuilCCCGWoegihBBSVPj9ftTX16O+vt5Wua6urqg4i4m1lubmqEctJuBCoRDG77cfJk6ciIkTJlBYEUIIcQyKLkIIIQOCstheUqNGjcq3KYQQQgYY/AmPEEIIIYQQQlyEoosQQgghhBBCXISiixBCCCGEEEJchKKLEEIIIYQQQlyEoosQQgghhBBCXISiixBCCCGEEEJchKKLEEIIIYQQQlyEoosQQgghhBBCXISiixBCCCGEEEJchKKLEEIIIYQQQlyEoosQQgghhBBCXISiixBCCCGEEEJcxJtvAwoBIQQA4O2330Z5eXmerSGEEEIIIYTki87OTgB9GsEJKLoANDU1AQBOP+20/BpCCCGEEEIIKQiamppQXV3tSF0UXQDq6uoAAFu3bnWsY4k92tra0NDQgG3btqGqqirf5gxIeA/yD+9B/uE9yD+8B/mF/Z9/eA/yT2trK0aPHq1pBCeg6AIgy9GlbdXV1Xy480xVVRXvQZ7hPcg/vAf5h/cg//Ae5Bf2f/7hPcg/qkZwpC7HaiKEEEIIIYQQkgBFFyGEEEIIIYS4CEUXAL/fj1/84hfw+/35NmXAwnuQf3gP8g/vQf7hPcg/vAf5hf2ff3gP8o8b90ASTsZCJIQQQgghhBBigJ4uQgghhBBCCHERii5CCCGEEEIIcRGKLkIIIYQQQghxEYouQgghhBBCCHGRASm63njjDUydOhXXXHNNQtrdd9+NRYsW4dxzz8VPf/pTQ9qTTz6JU089FRdeeCG+973vIRQK5crkfsv8+fMxfPhw7VVdXY3rr78eALBs2TJUV1cb0nt7e/Nscf8jXT+n+p8gznD//ffj7LPPxjXXXINTTjkFjz76qJa2efNmVFRUGO7Phg0b8mht/2Xr1q047bTTsGTJEpx88sn46KOP8m1Sv6apqQnnn38+fvCDH+Dyyy/HwoULtWf7hhtuwJAhQ7Rn/qSTTsqztf2TxYsXGz5blixZoqXt27cP3/rWt3DRRRfh5JNPxuuvv55HS/svZp/xPp8P69evT3l/SHaEQiHcdtttKC8vN3zWp3rug8EgLrzwQlx44YU49dRT8dRTT9lrVAww1q5dK+68805xzjnniKuvvtqQ9s4774jJkyeLcDgshBBiwYIF4plnnhFCCNHY2ChGjBgh2tvbhRBCXHzxxeLOO+/MrfH9kO9///uG43POOUd8/PHHQgghXnvtNfHwww/nwaqBRap+TvU/QZxj/vz5oqurSwghxN69e0VpaanYuHGjEEKITZs2iV/84hd5tG7gcOKJJ4onnnhCCCHE22+/LaZNm5Zni/o3q1evFpdccol2fO+994o5c+YIIYT4xS9+ITZt2pQfwwYQ5513XtK0Sy+9VNxyyy1CCCG2b98uRowYIbq7u3Nk2cBh69at4tZbb9WOW1paxLHHHiuESH1/SHbcf//9YsWKFQKA+PDDD7XzqZ772267TSxZskQIIUR7e7uor68XO3futNzmgPN0TZs2DT/84Q/h9XoT0h599FF87Wtfg8fjAQCcfPLJ+MMf/gAAeOKJJzBz5kxUVFQkpJHMue+++7T3u3fvRnNzMw488EDt3D/+8Q9cffXVuPTSS7F06dJ8mDggSNbPqf4niHO8/PLLKC0tBQAMHjwY5eXl2Llzp5b+5ptv4uqrr8Zll12Gv/zlL/kys1/T1NSEF198UfOoHHnkkWhsbMSaNWvya1g/Zvr06fjNb36jHY8fPx6NjY3a8R133IFrrrkGP/jBD7Bx48Z8mDgg+OlPf4prrrkGV199Nfbs2aOdf+yxx7T/h5EjR6K+vh4vvfRSvszstzQ0NODHP/6xdvzQQw/h/PPP146T3R+SHZdddhmOOuqohPOpnvtHH31US6uoqMBRRx2FJ554wnKbicpjALN582Ycc8wx2vGwYcOwadMmLW348OGmacQZfve73+Giiy7SjkePHo2LL74YX/va19DS0oJDDjkEf/rTn0z/SUjmpOrnVP8TxDlkue/3r5UrV6KhoUF7zqurq3HhhRfirLPOQk9PD4455hgoioJvfetb+TK3X7JlyxaUlZVpP6wBfc/79OnT82dYP0eSJO39s88+i8suuwwAMHv2bDQ0NGDixIl47733MHv2bHz66aeorq7Ol6n9koULF2LmzJkYPnw4nnnmGcyfPx+rV69GW1sb2traOO7JMYqi4Omnn8Zrr70GIPn9MXMckOxpbm5O+dxnqwX63V2bP39+0l/Eli9fjlGjRuXYooGN1fsRCoXw0ksvaeu5gOivnuPHjwcA1NbW4pRTTsGf//xnii6bpLsH7Gf3sfp/0NzcjJ/97Gd4+umnNSFWW1uLs846CwAQCATwrW99C3/6058ouki/4vnnn0dXVxeuuOIKANH/GZUZM2Zg8ODBWLp0Kb7+9a/ny8R+ib4/v/71r2Px4sX44IMPMHbs2PwZNYB58cUXMX/+fPj9fgDJ788hhxySLxNJFvQ70ZXNFLSxY8di165d2vHu3bu1D56xY8dixYoVpmkkOVbvx1//+leceuqp2jQ2AFi/fj0mTJigHft8PrS2tjpuY38n3T1I1c+p/ieIdaz8H3z55Zf43ve+hwceeEATwUA0uMPQoUMRCAQARO9Pd3e3a7YOVMaMGYOuri50dHRo3q49e/bwec8Bzz//PP7xj3/g4Ycf1jxf69atw8SJE7U8fO7dIVk/19XVobKyErt27cLgwYMB8PM/Fzz44IP43e9+px3z/yC3pHvuzcZEs2bNslz/gFvTlYpzzz0XL730EiKRCADgueeew3e+8x0AwJlnnokVK1ago6MjIY1kz//+7//iwgsvNJz71a9+hU8++QRA1OW+bNkyHHfccfkwr1+Tqp9T/U8Q59ixYwcuvPBC3HPPPZgwYQJWrFiBJ598EkB0fv+///1vLe+///1v/h+4wKBBg/C1r30Nzz//PIDoNM8RI0bg4IMPzrNl/ZunnnoKL7/8Mn73u9/B4/Fonq7zzz9fixC8e/dubNy4EUcffXQ+Te2XnHvuudr7tWvXQpZlTJs2TUtT/x8aGxvR2NiIE044IS92DgTWrVuH8vJyjBw5UjuX6v4Qd0j13OvTOjo68Pbbb9uadSIJIYTzJhcu4XAYV155JZYuXYpAIIB58+bh17/+tZZ+5513YsWKFQgEAhg5ciRuvfVWLe1Pf/oTnnjiCQwZMgRA9BcJn8+X82vob6xevRr3338//u///s9w/oknnsAf/vAHfOUrX0FjYyOmTZtmmH5InCFdP6f6nyDOcNhhh2HdunVaMI1gMIg777wTixcvxtKlS3H77bfjK1/5Cpqbm1FbW4vbbruNnz0usGXLFlx++eUYMWIEtm3bhptvvpkDHBdRp0mpvygDQGtrK7q7u3H99dfjs88+w5gxY7BhwwZceOGFWLhwYR6t7Z+cf/756O3txbBhw7B+/Xpcd9112i/3LS0tuPjii1FTU4PGxkZcffXVmDdvXp4t7r9cfvnlOOOMMwzrqFPdH5Idy5cvxxNPPIHf/OY3OOuss3D66adj0aJFKZ/73t5eXHLJJZAkCXv37sXZZ59N0UUIIYQQQgghhQKnFxJCCCGEEEKIi1B0EUIIIYQQQoiLUHQRQgghhBBCiItQdBFCCCGEEEKIi1B0EUIIIYQQQoiLUHQRQgghhBBCiItQdBFCCCGEEEKIi1B0EUIIIYQQQoiLUHQRQggheSAUCmHlypWO1LV7925s2LDBkboIIYQ4D0UXIYQMEB544AHU19dj2bJlafPOnTvXUj43bciWOXPmYO3atdpx/DXFp+eSUCiERYsWobKy0pH6Bg8ejBtvvBFvv/22I/URQghxFoouQggZIFx66aWYOHHigLHh0UcfxZQpUzJOd5Nf//rXOPTQQzF58mRH6vN4PLjttttw3nnnQVEUR+okhBDiHN58G0AIIST3hMNhnHbaaZg0aRJ6eno0TwkAPPbYY1i/fj3uuecePP300/jZz36G119/HS+//DIGDx6Mbdu24Y477sCIESNw//3346abbsI555yDL774AsuWLcPvfvc7PPLII6Z1p+K3v/0tfvnLX+LEE0+E3+/HRx99hFNOOQVXX301AODpp5/GM888g1GjRmHr1q249dZbMWbMGHR1deGiiy7C8OHD0dnZibKyMhx55JH4+c9/jmuvvRaLFy9OuKbZs2fjhhtu0NJT1a9e41lnnYUtW7bgo48+wjXXXIMLL7ww4/7/wx/+gIcffthwTt/+2rVrceWVV2Ljxo1a21u3bsUHH3yAW265Be+++y5ef/11VFdX45///Ce8Xi9GjBiBiooKvP766zj22GMzto0QQogLCEIIIQOGOXPmiNdee02EQiHxl7/8RTt/4oknipUrVybkE0KITz/9VHzlK18RkUhECCHE//zP/4izzjpLy3veeeeJM844QwghxFtvvSXeffddy3Wb2fezn/1MCCFEd3e3qK+vF6tWrRKfffaZGDFihOju7hZCCPHkk0+K2bNnCyGE+Otf/ypOOOEErY6bbrpJs+vhhx9O2q4+PVX9at5zzjlH64/6+npT+//yl7+IP/zhD+JnP/uZePTRR8XFF1+ckKe3t1cAEI2Njdq5+PbfeOMN8ctf/lJr+zvf+Y4QQohXX31VVFRUiM8//1wIIcSsWbPEyy+/rNVz6qmnirvuusvUtmz45z//6XidhBAykKCnixBCBiAejwfbt2/Hd7/7XVRVVWHTpk1Yt24djjjiiIS8r776Krq7u3HppZcCANrb29HV1WXIc9xxxwEAZs6cCSEE3nzzTUt1mzFr1iwAQCAQwJFHHomlS5eisrIS06ZNQyAQAADMnj0bZ555Jjo6OjBjxgxcddVVOPXUU3HmmWfihz/8oe3+eOWVV5LWX1FRoZ0DgAkTJmDnzp0JdXz00UeYM2cOfD4fTjvtNFx99dWor69PyPfll18CAMrLy1O2r7YHRPsVAMaPH4+KigptiuZ+++1nsKWyshJ79+61ff3pmDJlCq644grcfvvt8Pl8jtdPCCH9HYouQggZgDzxxBN46KGHsGbNGng8HixevBiRSCRp/v333x+//e1vteOOjg5Dut/vz7jubBk9ejTWr1+Pf/3rX/if//kf3HzzzVi9erXj7ajX6PF4IIRISFfXhz377LM4/vjjUV1djXnz5iXkq6mpAQD09PSgurraVtuSJBn6WpIkwxqurq4u1NbWJq3nn//8J2666SZLbeoRQuC9995DWVkZbr75ZtvlCSFkoEPRRQghA5CmpiZUV1fD4/EAALZu3WpIDwQCiEQi+OCDD3DYYYfhhhtuQGtrK6qrq7F27VrcfffdCWuSrNadjrfffhsLFixAT08PVq5ciWuvvRbV1dW46aab0NPTg0AggDfffBOzZ89GRUUFnnvuOZSWluLkk0/GySefjEGDBiWIwvhr6unpMaQdf/zxSeu3ytq1a1FRUYFXXnkFX//61xGJRPD6668nCK+ysjLU19dj165dGDZsmGn7b7zxBt59911tPZtVdu3ahQkTJiRNX7hwIRYuXGirTgB48803sW3bNpx99tm2yxJCCKHoIoSQAcNvf/tbLZjE3XffjX/+858444wzMHbsWLS0tOCxxx7DUUcdhUmTJuGb3/wm7r77bgghcOedd+LBBx/Ed77zHey///5oaWnBbbfdBiDqOVm1ahW2b9+Ouro6LFy4EN/+9reT1v3aa69pNowfPx6jR49OsLOrqwsXX3wxPv/8c1x11VU4/PDDAQD33nsvFi9ejPr6ejQ2NuLRRx8FAAwZMgQ33HADXnjhBezbtw8/+clP8Morr2h2TZ8+HdOnTzdc0+zZsxPSk9Wvv8ZZs2bhscceAwD87Gc/wy9/+UvN7pdeegmlpaUYO3Ys/vOf/2Dr1q0444wzTO/FN7/5Tbz11ls46KCDAACTJk3S2h85ciSam5tx1113JbT93//932hubsY999yDCRMmaGlHHHEERo8ejU2bNmHBggUOPTF9BAIBCi5CCMkCSZjNkSCEEELywNy5c3HDDTdg7ty5+TbFVZqbm3HGGWfg6aefRl1dnSN1XnfddZgyZQrOOeccR+ojhBDiHNynixBCSEHwwAMPYN26dbjzzjttT0ksNurq6vD444/jjTfecKS+xsZGzJw5k4KLEEIKFHq6CCGEEEIIIcRF6OkihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBeh6CKEEEIIIYQQF6HoIoQQQgghhBAXoegihBBCCCGEEBfx5tsAEkUIgQ8++AAHH38O0LUXsw89IN8mEUIIIYQQkhM+e2MlquDFXc8+ieOOOw6BQCDfJjmKJIQQ+TZioBKJRPDWW29h7unfg2hvBCK9kCpGQK5uAKSYHpajzkhJSnRKaudM8kjaOSkxv4osJ6ZJJuVkOSF/fDntb8o6Tcqb1B1fzng9CVVotqppxmuOvVebgUkFsrG8WZ1mDctS/BuLthhsN74x2KB2g5aWvLw+TVbzy8bj+PeA8ZZ6Ymmy9lefz5hmqCOuPaCvn7W6THzq8e3p88kmaQmPr+G64srJydP0SDC51rg+1T8zclwVZs+MVh4m12Xy/PW1l2hn3yOW+HzElzf0BxLzJ9qufzaNNkuGfEg4F28fNBtM7EPyCrRbarDdWKeZLWY2mP2rav878faa1GmWhtjXowQlaRoMX6Gx/FqakpCWsg59fq1es3ZUm03StDribEmwJ86kuHLGOs2uJ66cPk0RsVMmaXF1CJNyqersq8akzthfw7DGzIa+xpPm6bM9Rf/pbFDb1Mrp7E1IM9QhYlUlticS+jHxGUjIoztnVlffcWJ+Ed8funzx5fW2m12fll+7vuTPv6FbtOsx/k1mQ1/bZtdlrFMxG+4qZjao12xsw8wGU/vM2ot/dHRp2u0ySdeqNPn8iGvO0IxZufjuM9iQok4Rq8Pk6U2wU59Pe5xM2klmgwCwC73Yim70QkE9Arjpsf/BSSedhJqaGhMLiguKrhzT3d2NV199Fad+5wqI9h0AAKmyHlLVKEjlwyDJHkglZVp+SfYY/uqJT5M8fXlkk3LxdRgEUnxd+nKe9Dakas/SNXiSlzO2YzJw1kRT4oBbS0shGuLz6OuIFz56ZJNy8e2YpZnWYSZc4uq3aoMn9j7+b/z7+GNvynKyafmk+aXkdSVrLxvbrZTzmPWfaqeJwDQThZ64KozizliXoVyK5y8+v8dQp5onRXkTcW1qewrR2vfbRHKxZir44vLrb5Elwai1n3jNcb+XJORLyB93rM8fn8dYPtG+eNEkpRQbiYNyyUw0pKpDMWknvn6T8inbMbM9ftBv13YlYnIJJmmx9yISSWw3rg5hKKcYz5mkaeUiie1p7Zq1Z8V2XR67tmviJGL8a5ZmvA4lVnWi7fF1mYk2xaw9k/zxbeuPlQTbk1+Xue3J2xMRYchjKK+Kk4hIUS4xTY8q5szaUc85akPcPTCWU9tTkqZp5XT/e5HYe32W+HMRk6G6WVrfueRp8W2Y5TezxUx02bXdig1diEBAoAUhbEMPtqEbrQhhGPz42QN34dRTT0V9fb2JNYUP13TlgJaWFjz++OOQqxtQVlGFhd84C/CUwNMwC55JC+EZeTjkynpTUUIIIYQQQshAQYKEOvhwEKpwMoZhIYajHgHccOmVGDVyJIZIftxyyy34/PPP822qLbimyyUaGxvxj3/8A9//8f+D6NwDBKohV46CPGQy4K82/cWWEEIIIYQQ0kclvDgQlTgQlehBBNvRg99cdyOuv+46VMCLBpTioVWvYsaMGZDN1jMUCBRdDvLpp59iytwzobQ3At0tQNlgyFUjIdcfBslXnm/zCCGEEEIIKVoC8GB/lGN/lCMEBTvQg23owdFHHIkSyBiFAO5/+W+YO3cuSkpK8m2uAYquLFAUBe+++y6OOnkxRFsjEOqCVDEMcu1+kEbXQ/L2r6grhBBCCCGEFAIlkDEGZRiDMkQgsBu92IZunPrVryEMgVEoxe1P/xELFixARUVFvs2l6LJLMBjEsmXL8LVvXRoNhKGEIVXWQx42LRoIw1NYqpoQQgghhJD+jAcS6hFAPQI4HDVoQghb0Y3vnvEtdCCMegRw4//9BqeccgqGDBmSFxsLd+JjAdHR0YGnnnoKcs0Y+EsrsOCk0wBJgjzycHgOOA2eUUdCrhpFwUUIIYQQQkgekSBhMHw4BNU4FcNxMoZhCHy49oJLMGzoUAyT/LjrrruwadOmnNpF0ZWEPXv24P/+7/8gV9ajsqoa3/z2hUBJOTxj58Az8RR4RhwKuWK46d5ThBBCCCGEkPxTjRJMQRVOwFB8HSMwFmW4/arrsN/48aiTfDhIqsLatWvh9i5anF6o44svvsCEmd+A0r4d6GoCSusgV46EPHw6JH9Vvs0jhBBCCCGEZEgZPJiECkxCBYJQsD22F9iM6QcjABkNKMVvX38es2bNgsfj7FZOFF0xpNJaoGcfUDYEcvUYSKNmQiopzbdZhBBCCCGEEIfxQcZ4lGE8yhCGwC70YCu6ceycOSiBjDkYhH+JPY61R9EVQyofChEJAT0tEF4/IHuBynpIHl++TSOEEEIIIYS4gAKBJgSxE73YhV7IkDAMftz9yeuOtkPRFUP58nMIIfDBBx/g4OPPgdL0ObDjXUhlQyBVjYRUORJSSVm+zSSEEEIIIYRkQRgCO2NTC7ejBwDQgACefO4fmD9/PgIB57d9oujSIUkSDjroICh7PgIAbNq0Cfsf9XUorduAnauB0lrIlaOiIoxrvAghhBBCCCkKeqGgEd3Yhh7sQI+2huuVN5Zh5syZjq/hioeiKwXjxo1DZNdqANFohs899xwuvOJnUPZ+BJSUQ6oaBblyJFBaB0mS8mwtIYQQQgghRKULEWxDN7aiG7vRixqUoAGleHbtSkydOjWn43fGO7fI0KFD8d3vfhdKeyPa21rx1OMPAaEuRLa8jsi6ZxHZ8R6Ujl0QQsm3qYQQQgghhAxIWhHCh2jDC9iNZ7ATm9GFa++6BRu/+ALNIoi1ohXTpk3LucOEnq4MqKiowBlnnAHljDMQDAbx+uuvY8GZl0BpfAdQwpAq66NrwCqGc8NkQgghhBBCXEJA4EsEsS22RqsDYdQjgNsf+h1OPvlkDBkyJN8mAqDoyhqfz4fjjz8eSvMGKIqC9957D0eetBjKng+BxpWQyofHAnHUQ/I6vyiPEEIIIYSQgUQEArvRi23oxjZ0IwKBkSjFQ08/gQULFqCioiLfJiZA0eUgsizj8MMPh7L3EwDAZ599hslzzoTSshHY8R5QNhhy5cioCPMV3sNACCGEEEJIIRKCgh2xvbQa0QMvJDSgFP985V+YM2cOSkoKe3YZRZeLHHDAAYjsXgsAaGxsxD/+8Q98/8f/D8rutUCgGlLlSMhVIwF/DQNxEEIIIYQQoqMbEWyPTRvciR5UwIvRKMXyVSsxY8YMyHLxhKcoHkuLnJEjR+LSSy+F0rELzc1NeOx/7wd6WxHZ9G9E1j+PyK7VEJ17GIiDEEIIIYQMWNoRxidox7+wB3/FTmxAJ35wyw34+NNP0SpC+FC04fDDDy8qwQUAkhBC5NuIgUx3dzeWLl2Khd++HKJ9BwBAqqwH5KgTUvOAmXjCJKhpckIetZzBg5ZQR2J+mLQnmdSfaEPy9iQkL5+qnMEGmORLuAw1T2JVfbaYoLWXWGV8+RTNmtpnvK7kTZvZrnUtEu1LtKEvUda6z6Q/Eto3KxfXbpK64puWDfnjyiUWS7DT2HbytL7y9spJJlaY3PqE/Kn7T59mzG+sM3k/xD9Hskkna18rZmkpngtDP8TnsXhdyfJEzxkv1jRPCie+mXVm/ZfSBilFnhR19WUx+f9P+Fo0+Zo0++qMnZO0/Lo8pt+0Iq4us/wmaUnzJNZluPZU1xVflyGv2Tnz9vTntOGFMLPP7Dguf4pywjRNSTClr67EHzT7Llkx5rVog76h+Gs1Npe8/4QSV87QnnndhvJamtm5VP2XeGBWLlXbmn2xaxBmz6HWtSnKG9qLtymZ0cny6/LE3VZzG5K3Y/5op3oO1XbT226WpBjSjXWYfXyYpcWZYLgnCU+vienq9RhtsWmD2n8m5eJvgWJi3x4E0YoQhsGPnz1wF0499VTU19ebtF58UHQVEJFIBK+99hpuuukmzJw5E14vZ3/qCYfDWL58OY4++mj2jQ72S3LYN+awX5LDvjGH/ZIc9o057Bdz2C/JCYfD+OSTT/Dggw9i2LBh+TbHcSi6Coy2tjZUV1ejtbUVVVVV+TanoGDfmMN+SQ77xhz2S3LYN+awX5LDvjGH/WIO+yU5/b1vimsyJCGEEEIIIYQUGRRdhBBCCCGEEOIiFF2EEEIIIYQQ4iIUXQWG3+/HL37xC/j9/nybUnCwb8xhvySHfWMO+yU57Btz2C/JYd+Yw34xh/2SnP7eNwykQQghhBBCCCEuQk8XIYQQQgghhLgIRRchhBBCCCGEuAhFFyGEEEIIIYS4CEVXATB//nwMHz5ce1VXV+P66683zfvBBx/g5JNPxpIlS3D66adj+/btObY2dyxbtgzV1dWGvunt7TXN293djWuvvRZXX301lixZggULFuTY2vywadMmVFVV4ZFHHjFNb2pqwvnnn48f/OAHuPzyy7Fw4UJs2LAht0bmkPvvvx9nn302rrnmGpxyyil49NFHk+Z98cUXccIJJ+Cqq67CwoUL8fTTT+fQ0vzwxhtvYOrUqbjmmmss5b/jjjsgSZLLVuWHrVu34rTTTsOSJUtw8skn46OPPjLN9+STT+LUU0/FhRdeiO9973sIhUI5tjS3hEIh3HbbbSgvL0/aJ/q8hxxyCBYvXpwb4/KE1c9RRVFw9dVX46yzzsIVV1yBU089Fdu2bcuDxbkn1WfF0qVLsWjRIvzoRz/CWWedhR//+MdQFCXHFuaexYsXG8YvS5YsSZp39erVuPTSS3HVVVfh1FNPxQMPPJBDS3PL5s2bUVFRYegbn8+H9evXJ+S9++67sWjRIpx77rn46U9/mgdrHUaQvPP973/fcHzOOeeIjz/+2DTv5MmTxcqVK4UQQvz5z38WCxcudN2+fPHaa6+Jhx9+2FLeK6+8UvznP//Rjt966y2XrCocIpGI+MY3viGmTJmStJ9Wr14tLrnkEu343nvvFXPmzMmNgXlg/vz5oqurSwghxN69e0VpaanYuHGjad6hQ4eKpUuXCiGE2LBhg/D5fFrZ/sjatWvFnXfeKc455xxx9dVXp83/4YcfihNPPFH016+JE088UTzxxBNCCCHefvttMW3atIQ8jY2NYsSIEaK9vV0IIcTFF18s7rzzzpzamWvuv/9+sWLFCgFAfPjhhynz/td//ZeYO3euOO+883JjXJ6w+jn6wgsviNGjRwtFUYQQ0f759re/nSsz80a6z4orrrhCrFq1Sjs+9NBDLX+3FzNW/y+6urrESSedJEKhkBBCiM7OTrFmzRoXLcsvW7duFbfeeqt23NLSIo499tiEfO+8846YPHmyCIfDQgghFixYIJ555pmc2ekG9HQVAPfdd5/2fvfu3WhubsaBBx6YkO/999/H7t27ccQRRwAATj75ZDz33HNobm7Oma255h//+AeuvvpqXHrppVi6dKlpnu7ubjz33HN4//33cd111+Gyyy7D0KFDc2xp7vn1r3+Nb3/72xg0aFDSPNOnT8dvfvMb7Xj8+PFobGzMhXl54eWXX0ZpaSkAYPDgwSj//+3df0xV9RsH8LfCkFAh1MJuiuSSmT+aYkaaAnVjIgpIEBuyFNlU7CqKP9Plr2qSU1KbUWwNowiFbqH5g2a0Mgm9i1SSLUAaV5MQRJ2KFwXx+f7B1/PlclHBr+fcvL5fmxufc55z7nM/u/dzznPOPR979kRNTU2HsU8//TRqa2sBAOfOnYOTk5NDX319/vnnkZycDGdn53vGNjc345133kFKSooGmWnvwoULyM/Px5QpUwAAL730Eqqrq3HixAmruF27dmH8+PHo1asXgNYxNzMzU+t0NWUwGDBu3Lh7xh05cgSNjY0IDAzUICv76uw42r9/f1y/fh0NDQ0AWscVR9eZseLDDz/Eiy++qLSfeeYZhz4OtbVq1SosXboUS5YsQV1dXYcxOTk5GDBgAN59910sXrwYW7du7fAc0FEMHDgQy5cvV9oZGRmYNWuWTdyXX36JkJAQODk5AXCM8ffeR1/SVHp6OubMmdPhOrPZDC8vL6Xdq1cvuLq64vTp0+jTp49WKWrG29sbc+fORUhICC5dugQ/Pz9kZ2fbnBCYzWZUVlaie/fuSElJgclkQlBQEMrLy9GzZ087Za+ukydPorKyEsuWLcOWLVvuGtv2Jx979+6FwWBQOz276d79f9eRjh49ioEDB97xBDInJwexsbEoKCiAyWTC119/7bCfl65at24dkpKS4O7ubu9UVHH69Gm4ubkpxRQAeHl5oaqqCqNGjVKWmc1m9O/f3ybmUXft2jVs2LABubm52Lhxo73T0URnxtHRo0dj/fr1eO211+Dj44P6+npkZ2drmabmOjNWtB2XGxoa8PvvvyM1NVWL9OwqPDwc48ePR//+/fHtt99Cr9fj+PHjNhe+/vzzTxiNRpSVlaFfv3546623sGzZMmzdutU+iWvo1q1bMBqN+Omnn2zWmc1mBAQEKG1HGH9ZdGlAr9fjr7/+6nBdYWEhBgwYAKD1itH3339/x+e5HM29+mXw4MEYPHgwAMDT0xNhYWHYuXOnzUn01atXAQDR0dEAAH9/f/To0QOFhYUP7bNdd+ubX375BatWrUJWVlaX9rl//35YLBYsXLjwQaRoF539Ll28eBGrV6+G0Wi0OuDf1tjYiEmTJiEzMxMTJ05ERUUF4uLiEBgYaHUi/jDpbN/cS1FRESwWC1599VWYzeYHmCE5irfffhurV69W7io/Su42jubn5yMtLQ0mkwmPPfYY1q9fj/T0dKxZs8YOmaqvq2OFiMBgMOCjjz6Ct7e3+gna2euvv271d3x8PP744w/4+flZxV29ehUBAQHo168fACA2NhYxMTGPRNGVn58PvV7vsP8ZcnssujRwp5/FtffNN98gIiJCuZXano+Pj/JzKKD1ilFjYyMGDRr0QPLU2r365dSpUxgyZIjSdnFxweXLl23ibp9Mtu03FxcXXL9+/QFlqr279U1hYSEAYMWKFQCAiooKZGZmorS0FJs3b+5wm/3792PPnj3YsWPHQz0xQme+S/X19Zg9ezbS0tKUor290tJS1NXVYeLEiQAAX19fWCwWHDx40OpA+TDp7DhzL3v27MGlS5eQmJioXNBITExEcHAwoqKiHshr2NugQYNgsVjQ0NCgFNl1dXXw8fGxivPx8UFRUZHSrq2ttYl51FgsFpw8eRIZGRnIyMhAcXExrl69isTERKxZswY6nc7eKarmXuPovn37EBAQoBSjoaGh0Ov1Dlt0dWWsaGlpwfz58xEVFYWpU6faI13NVVRUwNfXV2m7uLigsbHRJm7AgAE4f/68VdzDfP7SFZ988gnS09M7XOfj42P1E12HGH/t/VAZ/Y9er5f6+nqrZWVlZcrD/rdu3ZJhw4ZZTaQxdepUzfPUysyZM5UJRVpaWmTMmDHKg+/V1dWye/duJXbChAly4MABZV3fvn2ltrZW+6TtIDAw0Oqh5PZ9k5ubK0lJScrD3UlJSVqnqJnq6mqJiIiQ06dPi0jrhCodfWbq6uqkR48eYjabRUTk8uXL4u7uLr/99pt9EtfQzJkzbSbSaP+Zua2qqsphJ9KYPHmy1UQaI0eOFBGRgoICqaioEBGRs2fP2kyksXnzZvskrDG0m0ijbb+0tXbtWoefSEPkzuNo237Ztm2b1YQAO3bskOHDh2ufrB20Hyva9ktTU5PEx8dLQUGBst6Rj0O3jR07Vvn7xIkT8sQTT8iVK1dExLp/ysvLZdCgQdLU1CQiIps2bZKYmBjtE9ZYeXm5zfvMy8uTf/75R0RETCaTzUQaRqNR8zwfJMc8mj6Ejh07JgkJCTbLN27caFVYHT9+XEJDQ2Xu3LkSHh4uZ86c0TJNTe3cuVNCQkIkOTlZYmJi5P3331fWZWdnW802ZjabJSYmRpKTkyUyMlIOHjxoj5Q1ZbFYxGAwiE6nE71eL5999pmIWPdNSUmJODk5iZeXl/LP1dXVnmmr6oUXXhB3d3flvXp6eioFafvPjNFolMmTJ8uiRYskNDRUtmzZYp+kNdLc3CwGg0GGDh0qo0aNksWLFyvr2veNSOvsoTNmzBAAYjAYpLS0VOuUVWU2myU8PFzmzp0roaGhUlJSIiKtsxpu2rRJifvqq68kLCxMEhISJCEhQW7cuGGvlDVx+PBhMRgMAkBiY2MlNzdXRGz7RUQkJSVFxo4dK0OHDpUVK1bYI11N3G0cbdsvTU1NMm/ePImLi5OkpCQJDg62mlXXUXU0VrTtl6VLl4qrq6tV/z0KhXp8fLzExsbKokWLZMqUKVJYWKisa/99ys7OlunTp8vChQslNjZW6urq7JGyphYsWCCHDh2yWjZy5EjlYpiISGpqqkRFRUlcXJwsX75c6xQfuG4iIva800ZEREREROTIOGU8ERERERGRilh0ERERERERqYhFFxERERERkYpYdBEREREREamIRRcREREREZGKWHQRERERERGpiEUXERERERGRilh0ERERERERqYhFFxEROYzm5mYcPXpUlX3X1taisrJSlX0TEZFjY9FFREQOobm5GW+88QZ69+6NtLQ06HQ6/PzzzzZxhw8fxiuvvIInn3wSiYmJmDVrFgICAlBUVHTX/ffr1w/r16/HkSNHVHoHRETkqLqJiNg7CSIiov/XBx98gObmZqxevRoAEBQUhHXr1iEoKMgm9vPPP8f27dtRXFwMADAajZg/fz5qamrQrVu3O75GTU0NAgMDUVZWhu7ded2SiIg6h0cMIiKym/r6eiQkJGDChAkYN24cIiMj7/snfJmZmQgODu7wNcaMGYNp06bhhx9+6HDb4cOHo7a2FhcvXsTNmzcxdepULFmyBAaDAWvXrlXinnrqKfTq1QuHDh26rxyJiOjRxKKLiIjs4ubNm5g9ezZSUlJw4MABeHh4IC8vD88++2yX99XU1ISysjJ4e3vbrDt69CgiIiKwe/fuDosyAMjPz8eIESPQt29fAMDMmTORmpqKjz/+GMXFxTCZTEqst7c3SkpKupxjV+3du1f11yAiIm042zsBIiJ6NOXk5CAkJAReXl4AWouw+1VfXw8A6Nmzp9XyvLw85OTkoLy83GabM2fOIDExETdu3ICzszP2798PAHBycsLZs2eRkJAAd3d3VFVVoaKiAv7+/gCA3r174/z58/eda2eNGDECCxcuxKZNm+Di4qL66xERkXpYdBERkV2YTCbMmDEDAFBaWornnnsOQGsxVFlZiR9//BENDQ1YsmSJVbujIuTxxx8HAFy/fh0eHh7Kck9PT0RHR2PBggX44osvrLbx9vbGp59+apPXrl27kJGRgRMnTsDJyQnx8fFoaWlR1lssFnh6enb6fX733XfYsGFDp+NvExEUFxfDzc0NKSkpXd6eiIj+PVh0ERGRXfj6+irFzPbt27FmzRoAgLOzM15++WUUFBTgvffeQ0NDg1W7o7s+bm5u0Ol0OHfunHLnDGidTMPf3x9+fn7Iy8tDZGTkPfO6cOECPDw84OTkBKC1CGzr3LlzGDJkSKffZ3h4OMLDwzsdf9vhw4fx999/Y/r06V3eloiI/l34TBcREdnFvHnzUFFRgezsbKxcuRI6nQ4A4OHhgeLiYowePRpXrlyxad9JTEwMfv31VwDAjh07cOrUKWzbtg21tbXQ6XSYM2cOUlNTUVhYiKysLJw5cwbz589HU1OT1X7efPNNuLm5ITo6GkuXLsWlS5eQlZWF8vJyXLt2DVVVVZg0aZJ6HfNfrq6uLLiIiBwEp4wnIqJ/leXLl2P48OFobGzEsGHDsG/fPqt2QEBAh9tdvHgR0dHRMBqN6NOnjyq5rVy5EiNGjEBcXJwq+yciIsfEoouIiBxGTU0NTCYTpk2b9sD3XV1djWPHjiEsLOyB75uIiBwbiy4iIiIiIiIV8ZkuIiIiIiIiFbHoIiIiIiIiUhGLLiIiIiIiIhWx6CIiIiIiIlIRiy4iIiIiIiIVsegiIiIiIiJSEYsuIiIiIiIiFbHoIiIiIiIiUhGLLiIiIiIiIhWx6CIiIiIiIlIRiy4iIiIiIiIV/QfjBqq5FUJl0AAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -328,16 +402,15 @@ } ], "source": [ - "weac.plot.deformed(\n", - " skier,\n", - " xsl=xsl_skier,\n", - " xwl=xwl_skier,\n", - " z=z_skier,\n", - " phi=inclination,\n", - " window=200,\n", + "fig = skier_plotter.plot_deformed(\n", + " xsl_skier,\n", + " xwl_skier,\n", + " z_skier,\n", + " skier_analyzer,\n", " scale=200,\n", + " window=200,\n", " aspect=2,\n", - " field=\"principal\",\n", + " field=\"Sxx\",\n", ")" ] }, @@ -351,13 +424,13 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 47, "id": "3dc23fa5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -367,7 +440,7 @@ } ], "source": [ - "weac.plot.displacements(skier, x=xsl_skier, z=z_skier, **seg_skier)" + "skier_plotter.plot_displacements(skier_analyzer, x=xsl_skier, z=z_skier)" ] }, { @@ -380,13 +453,13 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 48, "id": "01331785", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -396,7 +469,10 @@ } ], "source": [ - "weac.plot.stresses(skier, x=xwl_skier, z=z_skier, **seg_skier)" + "skier_plotter.plot_stresses(skier_analyzer, x=xwl_skier, z=z_skier)\n", + "\n", + "# For debuggin and timing\n", + "# skier_analyzer.print_call_stats()" ] }, { @@ -410,7 +486,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 49, "id": "aa8babfc", "metadata": {}, "outputs": [], @@ -428,32 +504,76 @@ }, { "cell_type": "code", - "execution_count": 41, - "id": "7c561ffd", + "execution_count": 50, + "id": "fb74516a", "metadata": {}, "outputs": [], "source": [ - "# Input\n", - "totallength = 2500 # Total length (mm)\n", - "cracklength = 300 # Crack length (mm)\n", - "inclination = -38 # Slope inclination (Β°)\n", - "\n", - "# Obtain lists of segment lengths, locations of foundations.\n", - "# We can choose to analyze the situtation before a crack\n", - "# appears even if a cracklength > 0 is set by replacing the\n", - "# 'crack' key thorugh the 'uncracked' key.\n", - "seg_pst = pst_cut_right.calc_segments(L=totallength, a=cracklength)[\"crack\"]\n", - "\n", - "# Assemble system of linear equations and solve the\n", - "# boundary-value problem for free constants.\n", - "C_pst = pst_cut_right.assemble_and_solve(phi=inclination, **seg_pst)\n", - "\n", - "# Prepare the output by rasterizing the solution vector at all\n", - "# horizontal positions xsl (slab). The result is returned in the\n", - "# form of the ndarray z. Also provides xwl (weak layer) that only\n", - "# contains x-coordinates that are supported by a foundation.\n", - "xsl_pst, z_pst, xwl_pst = pst_cut_right.rasterize_solution(\n", - " C=C_pst, phi=inclination, **seg_pst\n", + "# PST Profile\n", + "pst_layers = [\n", + " Layer(rho=170, h=100),\n", + " Layer(rho=190, h=40),\n", + " Layer(rho=230, h=130),\n", + " Layer(rho=250, h=20),\n", + " Layer(rho=210, h=70),\n", + " Layer(rho=380, h=20),\n", + " Layer(rho=280, h=100),\n", + "]\n", + "pst_config = ScenarioConfig(\n", + " system_type=\"pst-\",\n", + " phi=-38,\n", + " cut_length=300,\n", + ")\n", + "pst_segments = [\n", + " Segment(length=2200, has_foundation=True, m=0),\n", + " Segment(length=300, has_foundation=False, m=0),\n", + "]\n", + "pst_input = ModelInput(\n", + " scenario_config=pst_config,\n", + " layers=pst_layers,\n", + " segments=pst_segments,\n", + ")\n", + "pst_config = Config(\n", + " touchdown=False,\n", + ")\n", + "\n", + "pst_cut_right = SystemModel(\n", + " model_input=pst_input,\n", + " config=pst_config,\n", + ")\n", + "\n", + "if pst_cut_right.slab_touchdown is not None:\n", + " touchdown_distance = pst_cut_right.slab_touchdown.touchdown_distance\n", + " print(f\"Touchdown distance: {touchdown_distance} mm\")\n", + " touchdown_mode = pst_cut_right.slab_touchdown.touchdown_mode\n", + " print(f\"Touchdown mode: {touchdown_mode}\")\n", + "\n", + "pst_cut_right_analyzer = Analyzer(pst_cut_right)\n", + "xsl_pst, z_pst, xwl_pst = pst_cut_right_analyzer.rasterize_solution(mode=\"cracked\")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "10caa55e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pst_cut_right_plotter = Plotter()\n", + "fig = pst_cut_right_plotter.plot_slab_profile(\n", + " weak_layers=pst_cut_right.weak_layer,\n", + " slabs=pst_cut_right.slab,\n", ")" ] }, @@ -467,15 +587,15 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "98dbbb7d", + "execution_count": 52, + "id": "94e5f980", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAEWCAYAAABseTM4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACXY0lEQVR4nO2dd3gU1f7/37Mlu+kJJCShJSSE3iGItISOFEWxIKCI/lQUlIuFclGxIwIKXMQu6L0oYkG/YKWKNKVJUyBhExICKRBSd7P1/P5IdjKzdWZ3tiSc1/Pss7tz2mfOnJ157+c0hhBCQKFQKBQKhUIBAMgCbQCFQqFQKBRKMEHFEYVCoVAoFAoHKo4oFAqFQqFQOFBxRKFQKBQKhcKBiiMKhUKhUCgUDlQcUSgUCoVCoXCg4ohCoVAoFAqFAxVHFAqFQqFQKByoOKJQKBQKhULhQMURhUKhUCgUCgcqjigUCoVCoVA4UHFEoVAoFEkghKCwsNAneRsMBpSUlPgkbwrFFiqOKBSK5KxevRqdOnVCSkqKR+mrq6uRlZUFtVqNDRs2+DwdALz11lvo1asXMjIyMGjQIHEG+4E9e/Y4PKdVq1bh9ttv979BNlRXV+O2226DRqPxSf4Mw2D69OnYv3+/T/KnULhQcUShUCRn7ty5WLhwocfpIyIisGfPHiQmJvolXV5eHp5++ml89913OHz4MG699VZR6f2BM3HUokULj0WolMybNw9ZWVkYMmSIT/JXKpVYv349ZsyYgevXr/ukDArFiiLQBlAoNwp//PEH9u3bh6qqKhw8eBD//ve/kZmZicOHD2Pjxo3o3bs39u/fj0WLFqFdu3YA4DKMIh0XL14EAFZkLFiwIIDWiGPq1KmYOnVqQG34559/sHnzZly5csWn5bRq1QpZWVlYuXIlXn31VZ+WRbnBIRQKxefU1NSQhQsXst+/+uorEhoaSvLy8khycjIpKioihBBy4MABkpmZSQghpLa21mmYFGzcuJH069ePZGVlkZtuuoksWrSIDTMajWTBggWka9euZMiQIaRfv37k7bffZsM3b95Mbr75ZpKVlUUyMjLIvHnzSG1tLS//9evXk+TkZPa7wWAgzzzzDOnZsycZOnQoGTVqFDl16hQbXlVVRe69916SkpJCxowZQz755BOSnJxM1q9f7/I83KVzV+5XX31FevbsSQCQzMxMto65dWCtp7/++ssuzbZt28iECRNIUlISue2223hh//d//0cmTJhAUlJSyKuvvkrKy8vJgw8+SHr37k1Gjx5NysrKBNXpypUrSXJyMomOjmZt1Gq1ZOPGjWxZjq6drd22tm/dupVMnDiRtG/fnsyZM0dw+7DllVdeIaNHj+Ydc9WGPK0jq10dO3Z01SQoFK+h4ohC8QMnTpwgAEh2djYhhJDKykoCgGzatIl0796djWcymYhKpSJFRUXk119/dRrG5dFHHyUlJSW8Y8ePHyevvPKKU3sKCwuJXC4nFy5cIIQQUlRURGJjY9nwRYsWkd69e5OqqipCCCF79+7lhU+ePJl8//33hJA68TF27Fjy0ksv8cqwFUfz588nQ4cOZR/4//vf/0h8fDyprKwkhBDyyCOPkIyMDKLVagkhhKxYsYKo1Wq34shdOnflEkLI7t27ie1/xUWLFpFevXqxdfD++++T+Ph4Ul5ezkuzZMkSQgghOTk5ZOrUqbywlStXEkIIOXfuHGEYhsyePZvU1NQQs9lMBg4cSF588UXBdbpkyRKH4tjWdnd2c9MsW7aMEEJIcXExUalUZNeuXYQQ9+3DlvHjx5NZs2bZ1Z+rNuRJHRFCyKFDhwgAcu3aNaf2UCjeQsURheIHLBYL2b9/P7FYLIQQQk6fPk0AkDfffNPugRcXF0d27txJPvjgA6dhXEpKSsjUqVPJ9evXCSGE/P333+Shhx4iRqPRqT3Hjh0jAMju3bvZY/v27SOEEKLVaolarSYfffQRL81zzz3Hfs7NzSVms5n9/t5775EBAwbw4nPFUU1NDVGpVOSrr77ixYmIiCAfffQRqaysJEqlknzyySdsmE6nIwqFwqU4cpfOXblWbAWGtQ4+/PBD9pjJZCLNmzcnb775Ji9NXl6enV3WsIKCAvZYfHw8T7A+88wz5LbbbmO/u6tTIeJIiN3O7Ovduzd56623CCGu24cj+vXrR/7973+z34W0IU/qiBBCzp49SwCQv//+26k9FIq30DFHFIofYBgGAwcOZL+/8cYb+Ne//gWTyQS1Ws2Lq1arUV5ejqtXrzoN4xIfH48VK1Zgzpw5ePbZZ7F69Wq8++67UCic/7x79eqF++67D8OHD8eQIUMwbdo0TJ8+HQCQk5OD2tpatG/fnpfmlVdeYT/X1NRg2rRpuHjxIkJCQlBUVAS9Xu+0vJycHOj1eixduhRr165ljyckJOD69evQaDQwGo1ITU3lnWuLFi2c5gnAbTp35bqyt7a2Funp6ewxuVyOlJQUnD59mhe3devWTvNJSkpiP4eFhfG+h4eHo6Kigv0utk69tdvWvsjISFRWVgJw3T4cUVFRwWtvQtqQIxvc1RFQNzAbgN3vgEKREq9mq5nNZqnsoFBuGD755BMkJibirbfeQnR0NAghvPDq6mrExcW5DLMlKSkJjz76KDIzM/Hmm29CpVK5tIFhGHz22Wc4deoU+vfvj8WLF6N3796oqKiwK9OW6upqDB8+HPHx8di3bx/27NmDhQsXuk0HACtWrMCePXvYV05ODp555hk2LcMwbvPgIjSds3Ld5esI27LkcrnTuLZhtt+t5XhTp57abWsPwzC8+nTWPhwRExMDo9EoyA5XNjj6bpuXtZzY2FjBZVAoYhEtjgghePPNN5GcnIxOnToBAJ544gm88soron/IFMqNxo8//giz2Yzly5dDr9dDrVbzFrbT6/Woqqpif1/Owmy5fPky3n//ffz222949tln3XocCgsLcfDgQXTt2hXLly/HmTNncOnSJezYsQPp6elQq9XIycnhpVmxYgW0Wi3Onj2LkpIS3HXXXZDJ6m4hBoPBZXnWPM+dO8c7vnbtWuzduxft27eHUqnEhQsX2LDa2lq3i/65S+euXHf2Zmdns8fMZjPy8vLQrVs3lzZ5gpA6tR4H6s6RK0aktttV+3BEYmIiysrK7Oxw1oa8wVpOQkKCV/lQKK4QLY5ee+01bNq0CU8++SSr3F944QWUlpbi+eefl9xACqWpsHfvXly+fBkTJ05EUVERfv75Z6Snp6OkpASXLl0CAPz222/IyMhAcnIyhg4d6jSMS0lJCZ599lmsXbsWPXv2xMKFCzF79myHD08r2dnZWLBgAUwmE4CGf+fp6ekIDQ3FvHnzsG7dOtTU1AAAfv75Z2zZsgVhYWFITU1FaGgo+6A0m834/vvvXZ67Nc+1a9ey3VnZ2dlYvXo1unbtioiICDz44IN49913odPpAADvvPOO2z9c7tK5K9edvdw6+PjjjyGTyfDwww+7tMkThNRpfHw8ew5PPfUUfv31V5/Z7ap9OGLQoEE8IeSuDXlDTk4OunbtSj1HFN8idpDSwIEDSU1NDSGEkGHDhrHHLRYLGTp0qIdDnyiUps2FCxdIZGQkAcB7VVRUkO3bt5NZs2aRDRs2kJkzZ7IzhAghLsOsPProo6S0tJR37MSJE3azx7hcuXKFPPDAA+xU7YyMDN6gZqPRSObPn0+6dOlChg4dSiZOnEjy8/PZ8C1btpAOHTqQ/v37k0mTJpGZM2cSlUpFhg8fTgghZNWqVaRjx45EpVKRzMxMUlVVRYxGI1m4cCHp2LEjGTp0KBk5ciQ5fPgwmyd3Sv7IkSPJW2+9RZKTk0nHjh3Jf/7zH6fn4i6du3Jtp/KvWrWKrQPulPjMzExy/PhxQgghP/30Ey8Nd8C3bdi1a9fIqFGjiEqlIh07diQbN27kTc2/5557BNVpcXExycjIIIMGDSLjxo0jtbW1vKn8mZmZJDs726Xdzux74IEHSHR0NElOTiZvvvmm2/Zhy/nz50lkZCQ7M81dG/K0jggh5P7772dnCFIovoIhRFxf2ODBg7Fv3z4AwPDhw7Fr1y42rF+/fjhy5IgUmo1CoVAojYi5c+eiRYsWWLx4sc/K0Gg0uOWWW3D48GFERUX5rBwKRXS3mkwmc+jO/eijj7x2l1IoFAqlcbJs2TKcOnUKO3fu9En+BoMBs2bNwhdffEGFEcXniPYcHTp0CGPHjkXbtm1x5coVdOvWDdnZ2dBqtdi+fTv69u3rK1spFAqFEuSUlpYiPj5e8nyNRiO0Wi2io6Mlz5tCsUW0OALqBoCuXbsWZ86cAQB0794dc+bMcTjFmEKhUCgUCqUx4ZE4olAoFAqFQmmqiB5z9Oeff+Kpp57C559/zh774osv8PHHH0tqGIVCoVAoFEogEL19yKuvvoqkpCRkZGSwx/r3748XXngBhYWFeOGFFyQ10Fds2bIFr732GkJDQyGTybBu3TqX655YsVgsuHz5MiIjI0Wv5kuhUCgUCiUwEEJQVVWFli1b8hZVdRZZFAMHDnR43LqDcmPgjz/+IBEREeTs2bOEEEI+/fRT0qpVK94u3c4oKCiwW6uGvuiLvuiLvuiLvhrHi7vZsTNEe46cbRMgk8ncbiEQLCxbtgzjxo1Dx44dAQDTp0/H/Pnz8emnn2LOnDku00ZGRgIACgoK6HRSCoVCoVAaCZWVlWjTpg37HHeFaHEUHx+PZcuW4cknn0RoaCiAun1+1qxZ02hmq+3cuRPPPfcc+10mk6Fv377YsWOHW3Fk7UqLioqi4ohCoVAolEaGkCExosXRmjVrMGbMGLz00ktISkoCAFy5cgUtW7bEzz//LN5KP3Pt2jVUVFQgMTGRdzwxMRGHDx+2i6/X63mbeFZWVtrFqa2ttdvoU6lUIiwsDBaLBVVVVexxs9kMuVzOrtVRXV0Ns9nMSxsWFgalUgmDwcDuF2VFoVAgPDwchBCHtkRGRkImk6GmpobdF8mKWq2GSqVi1wvhIpfLERERAQAOd96OiIiAXC6HTqez8xCqVCqo1WqYTCZ2HyUrDMOwIrKystJur6zw8HAoFAqHdRgSEoLQ0FCYzWZUV1fb2SSkDvV6PWpra3lh1jq0vTZWoqKiwDCMwzoMDQ1FSEiIR3VovTZardZu3zNXdSiTydh/OlLWIffaVFVVwWKx8MJd1aGz9m1FSB16074d1aGr9u2uDqVo347q0NW1cVeH9B5RB71H1HEj3iMCiWhx1L59e/zzzz/YuHEjzpw5A0IIunfvjqlTpwb8ZIRgbawqlYp3XKVSOdwteunSpXjppZec5ldbW4vt27fbHW/VqhX69OkDnU7H2/371ltvBVD3I7B63hQKBUJCQthXQkICYmNjYTKZoNVqoVKp2LBmzZqhY8eOUCqVOH/+PC8sJCQEw4YNQ1RUFM6ePYvKykr2uFwuR9euXZGamorS0lIcPXqUZ290dDSGDh0KANi3b5/djyArKwuRkZE4f/488vPzeWHt27dH586dUVFRgQMHDvDC1Go1Ro0aBQD4448/7H5AAwcORPPmzZGbm2u3g3fbtm3Rs2dPaLVaux3UZTIZxo8fDwA4duyY3Y2mb9++aNmyJQoLC9n1uKwkJCSgf//+MJlMDndmv+WWW6BQKHDq1CmUlpbywrp3746UlBQUFxfj+PHjvLDY2FgMHjwYABzmO3z4cISHh+Ps2bMoLCzkhXXo0AEdO3bE9evXcejQIV5YeHg4hg8fDgA4ePCg3YNn8ODBiI2NxYULF6DRaHhhKSkp6N69O6qrq+1sUigUuOWWWwAAR48etbuBZWRkIDExEfn5+Th79iwvLCkpCf369YPBYHB4ruPHjwfDMDhx4gSuXbvGC+vZsyfatm2LoqIinDhxghfWvHlzDBw4EIQQh/mOGjUKarUaf//9N65cucIL69SpE9LT03Ht2jW7PzqRkZHIysoCAOzfv9/uZjx06FBER0cjJycHeXl5vLDU1FR07doVVVVV7NZJVkJCQjBmzBgAwOHDh+0eWgMGDEB8fDwuXryI8+fP88Kc3SOsTJw4EQDw119/sRvOWunduzdat26Ny5cv49SpU7yw+Ph4DBgwAGaz2WG+Y8aMQUhICM6cOYPi4mJeGL1H1EHvEXUE+h4RSCRd5+jMmTOCZnwFkmvXriEuLg7//e9/MX36dPb4Qw89hMOHD+PkyZO8+I48R23atEFFRQWioqKg0+lw8uRJJCcns2IHcK6aY2JiANSJLl1tLSorKqDT6VBbW8u+jEYjDAYDarRaaGtqeGFWhW57A3GHUqmESqVixZRCoUCISgUVR1iFhYUhRKWCQi7niS6VSoXw8HCo1WrIZDKemLOGWf+ZEEKgVCqhUCjYeNHR0ey/C7lczoYplUpERUWx/1rMZjOUSiXr8qT/Cutoqv8KqeeIeo4A6jniQu8RDfVUVlaGxMRESZ0ulZWViI6OZp/frvBYHOn1epSUlPAuwpQpU+z+FQQjMTExeO655/DMM8+wx8aPHw+lUonvvvvOZVoxleuI3r16oX///li1Zo3otFwsFgv0ej10Oh10Oh3vc21tbcPx2lro6r8b6oWe3mCAXq+Hsf5dbzDAoNfDwPnOhjn4bjAYGuLa/NCkQCaTsQKLK7TsjimVUMjlkHNeMpmMfZfJ5VAqFA7DvD0mk8nAMIzDFwCnYZ7EExrXCjc+993TMF/mfaPYKza9tc27e1nbIYXSlKioqMDevXtZj65UiHl+i+5WKywsxP3334/ffvvNTp02FoYPH44jR46w3wkhOHbsmEe7SZvNZmi1WoSFhUEul7uNr9XpECrBBr0ymQyhoaE8b1UgIITAZDI1CCm9HiajESazGUajEUajESaTCUajEWaTCUaTif3Ovls/24SZrOnr87Ies8Yx1r9bLBZYzGZYLBaYHb0TAr3BALPZDOIsTv272WJxm581T0IIUP9ufVnrxN1LaLzG+huj+I86oSSHQl7/rlBAwXpo647LOeEhSiVCQpRQhaigUtV5gNWRMTzPsqPP7sLCwsJ4L+v9ye16MhRKECJaHD355JMYNmwY1q1bhwceeACbNm2CXq/HN99849CFG4wsXLgQI0eOxPnz59GhQwds3LgRcrkcM2bMEJ2XtZ9WqMLVarUIVas9MTsoYRgGSqUSSqWSdRdTfIMQAcUVXtx33ud617iQdA7jWMyC09cncJ+nmDBi4RyzOTduepvzJLDJm5cPN6whDsOJ49gmi/Mwh/XkOK7tMbO57o+CyWSCyWyu/2yuO240wmRqOGYym9jvZpORF98aZrb+8TAZYTAYYTAaodcbWC9yVVVB/ee6YwajEQY23HrMAIOB39UjBLVahbDQUISy72qEhYYiLFSNULUK4c1asIIqPDwckZGRdq+oqCi7Y7bjRikUKREtjkpKSthp8Gq1GsnJyQCARYsW4fbbb5fWOh/Rv39/fPrpp5g6dSr7z+aXX34RtPaBt+h0OoSFhYEhBIS6wykisO0+E5xOSu8TsbiPwytbXHxJ7RBy3m7ycWu/t+GeprU4D3Nps8swF/XFEbgGQ71YMhjrxJPBgNpaPWpr9dDqdNDV1kKrq4W2votfq9VCV/9dVx9Hq6vv+q+txbUrl1BQf6ymRouqmhpUVddAazOWyhalUoHI8HBERoQjMiKi7j08DJER4YhNaouYmBjExsayL0fflUqlyzIoNy6ixRHXRWodcBYWFgaz2Yxz585Japwvuf322wMi5rRarSTdahSKKyQVRIBHD/mACiOpimJkrs+Dkbm2x124K1yllcmcCiTC1N2jHdpdH+YwX6vwdtR2rHnCwnajiUWsaDObzaiu0aKquqZOMFVVoaq6GlXVDQKq2hrGxqlGRWUVLl46hIrKKlyvqMT1ikq7wdhWwsNCERsdheioKMRG172atWyLuLg4xMXFIT4+HvHx8eznuLg4xMTE0HFePkahUKB58+ZQKERLFOlsEJsgIiICzzzzDF588UX0798fo0aNwrhx47Bnzx7Ex8f7wsYmAyGkznMU4HFClKaJ5III8PjB7jNhFIwEUiABLkWS0+vgKl+Gce5FciWu3CBItHHylsvliI6KRHSUjUdfTNn13aI1Wh2uV1TgekUlyssrUc4RThWVlZzPVTh/5gQOlpXjatl1lJXbzyhTKBRoHhuNuGbNEN88FnHNYtGibRpPTCUmJiIpKQmJiYl0H04PCA8Px8CBAwNqgyBxVFZWBgBo1qwZXn/9dezbtw8GgwHPPfcc7rvvPrzxxhvo2rUrPvnkE58aG6wIHXBonepIPUcUKfCJGLLihbhpVMJIgHBx6z3yNe5sdONF8lggAa5Fkod14lIkWfMGXNhmL6ScwsjAMHV/6iPCw9CmZZIoW00mE8rKK1B67TqulV1Hadl1lF4rw7WycpSWNbyf37OT/Ww7LissNBRJLeKQ0CIOSS3ikdSuA5KSkljxZH2Pj48XNKnnRsA6ltLToQRSIGgqf//+/fHYY49h5syZKCkpQYsWLfxhW1DizVR+6xpLX3z+OSZNmkTHHFFE41NBBHjdZeVzESHKayCwrgTkKei8fDn+SEh6T8chucvbXT36us0Izd8TOyRur4QQVFZVo6j0KopLruJKSSmKSq+hqKQUV0pK649dRXHpVVwt4y/sqVAo0DIhHq2SEtGmZRLapHdGmzZt0Lp1a7Ru3Rpt2rRBQkLCDSGgGs1UfrlcjpkzZwKoW8to165dDuMtXrwYr732mkhzbxysC4KFeeA5EvtMpLqraeBzMWQl2EWRWJriEgi+8iC5y9uHXiSrbYAATxLgvvtSSDxnaXhGedidzDBsV2DHtHYuyzIYDCi5WlYnoEpKcbm4BIVXilFwuQiFV4px/NTXKLhShNrahrXk6gRUi3oBlYg26Z2RnJyMlJQUtGvXDikpKXTWsEQIEke1tbX4/fffkZycjNraWhQUFDhcf2X37t2SGxjsVFdX49ixY+jTp4/bRumJOPL0Hu/Ns4EKq8DhNzEESPKv2a+iyBdl+dN+L0WEt3g/uNw3Y5G49gFu2pQnQskTu5yJJgkJCQlB65aJaN2Ss8+nTbmEEJRdL8elK8X1ryJcunwFBZevoPBKMY6d+hr5hZd5XXnxzZshuU1rpLRtjbTO3Vnh1K5dO7Rt2xbqJrSUjC8RJI6effZZjB49ml0SPiUlxS6OtX/wRsNsNqOiosLpbAguVnEkdOHGQP35FVruDXi5fUJjE0RAADxFvuhOa4x44T0CfCyQrOkB34skbllCynMkdoLB2+lGhDEMg+bNm6N58+bo2a0LL8xaTxaLBUUlpcjLv4Tc/ALk5V/CxUuXkJdfiCOfb0TB5Su851PLxASktG2D9p26oH379rxXbGys9OfYSBEkjqZOnYo777wTV65cwZQpU7Bp0ya7OIQQ3HvvvZIb2JTwplstGHF5j6TCySl+FUOApA+BgHSfBcNDTAhCPENSeI8kEEiANwOi3XSzCbFRAIQjHCQVSo7S8Ar2YXsT45FyEZdbNzKZDC0TE9AyMQED+/e1S28ymXDpSjHy8guQl1+A3IJLyLtYgHNnTuHHH7bh6rUyNkmz2BiktWuHtNQUdOjSnSec4uLibigHiOCp/CEhIUhOTsbKlSvRrFkzhwsmrlixQlLjmhrWDSKbijhyBfe+eQP9nhzidzFkpbGLIkD8OYip68YiuhzhpUACJPIiAT7tarMi2JvELZdNHHxdap6WTYTaxomnUCqR0raumw3MILu8yisqoLlYgAu5ubigycOF3Iu4kJuLPb/vR1FxCRs/KjISaan1wqlzN55wSkxMlFQ4RUZGYtSoUZJuOisW0escDR48GGPGjMFPP/1kFzZo0CAHKShWrJ6jG63P13rvvFFEUsDEECD5Az+gA619KYxuBPwhkAC/dLVZEeVNsi2fzSTIRLEAweOJKKr77v6mGxMbiz6xsejTq4ddHtXVNci9eBEXNLnIqRdNGk0u/vj0UxQUFrLxwsLC6oRTu3bo0JnfXdeqVSvR++vJZLKAPydFi6OMjAyHwuhGJSwsDH379hXkDWpq3WpiaOrCqCl4h7gEfPZZMC0JIDVSDcwWko9UAgnwzoskNB8R2AoGj8USm6Ef2oRIr5RgUeQob9ubLifcab42xyMiwtG9axd079rFLkxXq0fexXzkaHJxITcPFzQaXNDkYvOXXyK/oACW+nanUqmQ2q4d0lLboUOnzjzh1KZNG4erYGu1Wvz999/o0qVLwJ6XosVRx44dUVVV5bBb7ZFHHsEHH3wgiWGNBaVSiZYtWwqKK3ZAdlOhKQqjpuQdshJwQQR4fm4+vB5BUS/O8JdAElqWOy+SNR9A+jWGPPEqcQlkdxoHUYLIirs0zoSRUI+OnfCSITQ0FJ07dUTnTh3tbDYYTbh4MZ8VTBdy697/7/vvkXfxIkwmE4C6pQlSUpKRlpqK9A4dWdHUokULFBQUID09XZh9PkC0OOrRoweysrIwadIktG7dmrcg1b59+yQ1rjGg1+tRWFiIVq1aud1vSKvVIiQkJKD7xfiTpiSKAiqGAJ/+qw2ah7+/hFGwnK8/8bdAAgImkgDHAiNo2rkDPBJEVhyl5d58Pe2S84KQkBCkp7dHenp7O3tMJhPyCy7hQm4ucjW59QJKg107d+Kjjz5id5JgGAatW7VCWloaOnSsE05paWnse3h4uGT2OkL0U/r5559HYmKiw61CiouLJTGqMVFbW4szZ86gefPmbsWRTqe7IbrUmoIoCrgYAm4MQQR4d54+vk5BVU/OENpNJ6VAAqQXSULy9IJgEUxeCSEu7kSRu7JFjgNyVq7d+bg5P4VCgdTUVKSmpgIj+GEWiwWXr1zBqVOn8OuOnVAoFLhceBl//vEHvvjiC1RVVbFxExMTkZraDh068IVT+/btERMT49m5ce0Um2DAgAFOF3scNmyYaAPKy8tRXFyM8vJyxMbGIiEhQdLlwoMJrVYb9GsceUNjFkVNXQxZCbqHvb+FkS/PvymMY4JAgSSmTKEiyZon4Le6FCNUhNSJZMLHHUKFkRReI2/PScSDQSaToXWrVoiMiIDFQjB40EBExdStvUQIwdWrV3FBo4HmggaaXA0uXNDgzJkz2LZtG65evcrm06xZM6SmpiItLQ1du3bF3LlzRW/3JVocbdu2zWmY0BWyKyoqsHLlSnz99dc4d+4cALArbjMMg65du+LOO+/EU0891aSWQhcjjii+hwqiANOUhFFjQYD3CPBgIUZfiSShefsBvwkfVzgdSO1eGAWF/QJRq9Xo2CGdN2ONYRjEx8cjPj4eA266qSGydUmC8nJoNBpocnOhuXABFy5cwJm//8aXX36Jm266CaNHjxZlg2hx5KqfT8iA7AMHDmDGjBnIysrC888/j7S0NMTExECpVMJoNKKsrAw5OTnYsWMHMjIysGnTJvTs2VOsmUGJVqtt0t1qgu55QeRdkmLj36AQWDcSPlrHSLCAFBJPioe5F5vMWvF6Q1duXcvcbHbqK5HEzVto/k0Rl54dD4SRr7rUJEKlUqF9+7rxSi5bCaf8mJgY9OnTB3369GGP7d27F2PGjkVycrJoG0SLowcffNBp2M8//+wybWlpKV566SX89ttvLmd4DRgwANOnT4dGo8Fjjz2Gr7/+2uHsuGBAoVAgISFB0CDrG9lzFEyiyBskF0NCby4SbMdgV3RjWsMI8Flfc1B61iRY5NF7GzgzzyxOtkfywbpaRObiXhrsaxZJidsZaE5uqmIFi5RdahKJJaPRiGtlZWjerBkUIa7H8rpCo9GAYRiHW565Q/SZ/PTTTyCEsC+TyYSLFy/i+++/x6hRo1ymjYmJwQ8//CB46ntqaiq2bdsW1IIiPDwc/fv3FzRy3tZzdCN4HRim8QsjhhD25VeIpeElIQyxNH1h1JQfmlbc/Pt3+6+ekXn+ABaTh0gYi0myV6PDWp/uPEUihJFkXiM/otVqcfToMXb5G0/RaDRo3bq128lSjhDtOZo5cyZef/11u+Nnz57F+vXrXaZVKpVii/MojT+xWCwwmUxQKBRuVwGtrq5GmEChJ2S5kGCmMQsiuoaRDwkij1HQI8EaRoJ3ug+SBR5Fr1XkplxPBZJL75VUiPbKuLipOsmrMY0z8gWa3Ny6WXEeILrmHAkjAOjUqRP+/PNPj4xwxNSpUyXLy5dUVVXhl19+4U0xdIZOp0NoEx5zZP1D09iEEdczFFDvkA8ETMC9RFY8Pb9gGnjt7QrMniAkLwGeAMm8SH70JBFGxr7cwvW4SFC+ZF4qW7vE2ijkpipGGNm2FW9W4BaUxosZdBKQq9F4vJCkaHmcn59vd6y6uhr79+8Xvc5RRUUF1qxZg+PHj6OiooKdsQYAf/31l1jTgh6tVovExMRAmyE5jVEMBRQfi5WgEENc/Lnqtciygq6uPKWJr4ItequQAGwR4tZLVW+TW6+U0BuqC5EhSBh5kb/TMoIMTW4u7rr7bo/SihZHKSkpdrvvEkKQnJyMd999V1Re99xzD6qrqzFw4EC7MTt5eXliTQt6dFotr1vN1WypQD+/hdIYhFFTF0NAkD7k6VR9aQjGRR4DvMCj5PuqsRn7qA1xuwtdiCjCyBqmZzmaIdgEBIsQZDIZIiIiRG9Yy6WsrAzl5eVIS0vzKL1ocXTTTTdh06ZN7HeGYRAZGYnY2FjRhZeWluLo0aMOw8Qu2NQY0Np0qzGEOBVIjWXMkRQ2+lJgUWHUyBB6vQScs/dT2b0Rdy7SuhAwLm12EUYUIXUfBAokt2UBwr1IbMZNYLuQAIoLu3NwOEOQc0zOH4/rUhg5EhlSn6uE+UVGRiJz6BAAbqbyu0Cj0QCA/8TRe++959GaAY7o3bs3amtreQs9WUlKSpKkjGBCa+M5utHxh9dJirWMxMITZL662XJu/J7+W/S5qPLzasc3MoxR7zjAw7r3VKQ5CiMKm/t7ALcLYU0IcJuUxMNjNvI9UlbhVH/PY7vvGsHsNF+gyc0F4EdxlJSUhL1796J79+6IjY3F0aNH8dlnn6Fjx4547LHH7LrcXPHWW29h/vz5SExMRFJSEm8T2zfeeANTpkwRa57fiYqKwi233MKz3Rm1tbV2i0A2Be+RWBpDV5wY/OadkuiG7tcHg5iyJPQaCcLtLC2B3Vli07rw7rjs9nKVp7ObhYcCVfAWIgJgTLWCbRBUpsUCi8q7nRM8ESeubPN7d5aAlbLZ7jvSEJdnp1zE+kZ+Xm27srISBw8dwoCbB3rci5Sr0aB58+Yeb0cmWhwtWrQIubm5eO+991BbW4sRI0agS5cuOHToEHJzc7F8+XLBea1duxbvvPMO4uLi7ESDp5vYbt68GR999BHMZjMqKyvRtm1bLF++nDed7/3338f777+P0NBQxMTE4IMPPkCrVq08Ko9hGEELQAL1i0A24dlq7mgqosivXXUSChm//1v2hTBqTHghkAAn18uV2HE1DsgDkeTUDleeH0/DOGUKaacyfbXbOO4QK7CCYjyPlytl8zCb+F4lybvZPJ+pVreGopk3SUssGo0G7dq18zi9aHH0zz//YN++fZDJZHjllVfQsmVL7Nu3D4QQDBo0SFReH3/8Mc6ePetwqt2YMWPEmgYAmD59OrZt24bRo0fDYrHgwQcfxNixY3Hy5Emo1Wp8++23WLJkCU6ePIkWLVrg5ZdfxoQJE3D06FGPBn/V1NTg1KlT6N69u8uFIAkhdeLIQRdiU/ceNXZRFJDp/RISkC6EptKV5o33yF166/3GX14kd+mcIEisAZIJJbeDrR3dpz1YLdwTgeWtx8ojJFopW9RikO48qkKOBRhv1jgCPFjnSK1WsyLi888/x8MPPwyZTAa5XC5olWguXbt2dboGwZdffinWNADAbbfdxm4wJ5PJMGfOHGRnZ+PYsWMAgNdeew0zZsxAixYtAABz587F6dOn8eOPP3pUnslkQmlpKUwm19M4a2vrXMtNeW81WxrjmkcAArPukcRrHVnXNwqIt0hsmT7aLy1ocPfgcPGQcumtcLVejrtVlD14mLldd8ilPS7W93Gz/g+3XKdly2T2Lx8g01cLfnmM0PWQnF1jT66vu3Zme8j2/uKjddpc4uYcNRoNOnTo4HH2oluQxWLBhg0b8MorryAvLw/Tp08HUDfzTMhCiFweeeQRrFq1CpcvX7Zzn91xxx1iTQMAfPXVV7zv1sHeBoMB169fx7Fjx5CRkcGGR0dHo0OHDtixY4dH5QnFugx6MG+FIgWNcSHIgIshibvOAjbYNIhWvw70gFs7vBRIbkWS0zABIklqoeQuXzHhAsSSKMHkQ+FkV7wr8WTUsi9Ri0O6u8E6Se+3LkHu746QgHV76HQ6XL582ePB2IAH3Wpvv/02pk+fjsLCQrz99tuIj4/HN998g4cffhiPP/64qLxuvfVWAMDTTz8t1gzBHDx4EC1btsSgQYNw8uRJALBbiDExMZGd9ucrrOLI2Wy1xt611tjEUEBoyluDNOX90rztWhOaj4CtQFx2swGuu9oA191trtK7wOWWH7YPZbHhAuOI3lxZqECSanNfF+XJDA1eJmfnQULc9Mq4ED+SLAgpFdbr4UasRUREYNDgwYiI8Kwb07pOol/FUe/evXHmzBnescmTJ2Py5MmiC+/ZsydWrVpld5wQgnnz5onOzxa9Xo/ly5djzZo1UCqVrECx3YROpVI53eBOr9dDr2+YJltZWemRLTqdDgAQFtZ0PEeNRRA1NTEEBIkgAjw/x2BR+1IJH6nK83avtACKJK59gAdjlGzDhcZxEdfr6fx+EBFCtnZhjDq7Y7w8lPbPFcHeIjFeJXfjmCTyUMnlcsRERXrs8fJ2jSPAA3EkJc899xwyMzN5x6zrHr3xxhte5//oo4/izjvvZIWbdbwPV+xYvzsbL7V06VK89NJLTssIDQ1F9+7d3XaXsd1qTWDMUbCLoqa4cSwQRILIij+FUaDPXUoRJUQgAZ57kaxlAN6LJFd5uEGUUHJWjqOHozthKDC+N11N7n6LXndjuepydHCMMTU801gBzbVHwXEIiBF8vuiOE5CnTqfDhQsapLZv79FQFE1uLkJDQ71aLzGgQ8wvXbqEuLg4LFmyhD32zjvvYMiQIejWrZtXeS9cuBAKhQKvvfYae8w6cr2oqIgXt6ioyOmo9kWLFqGiooJ9FRQU8MJDQkKQkpKCkJAQl/aw4kitdvpjdfVQDwZBEoxjiWzHCzW1jWOBAI8jcoQ359oYhZEvEPLQcfMQE7Qpq9BBve42NvXyISlojJDt2Bsx8dyNyXL1kuB8BJ2fp+fi7riNXQ6LMenBmI11L5Oh4WV2sx+ct3j4wDAYDLiYnw+DweBReus0fjHrLtoSUM/Rxo0b8d1332Hw4MHssaeffhpdu3bF7Nmz8d1333mU77Jly5CXl4fPP/8cDMOwW5T07dsXvXv3xpEjR3DnnXcCqOsmO3/+PJYtW+YwL5VKZdcNx8VoNKK4uBgJCQlQKpVO47FjjhqZ5ygYxVBA8cODOqiEkC3e2Oana+ez+pO6C05IflJtByKku8wP3iQ2uc1D3G03IS+xSM+RqzTu0gUCIYLXBkEi2VmQycDPw9naRwKFWDCQq9Eg1Ys1joAAe47CwsJ4wsjK2LFjUVFR4VGe7733Hv773/9i7ty5OHbsGI4cOYKtW7fi1KlTAOq68j799FOUlpYCANasWYNu3bph3LhxHpWn1Wpx/Phxp2OWuPGAxjNbLVi8RAH1CgF+8QwBDd6hoBVG3p6/p9cuWOtDKoR6kAR0hUjiSQLEeZMk8CoBImagOSpb0Dm58R5JdB6CEWODi3DB19zNcad5cO99FlPDS8xYsACgyc1FuhfT+AEPPEeLFy/mdVV5w7Vr16DT6ewEg1arZcWLGKqqqjB79mxYLBYMHDiQF7Z+/XoAdUsElJSUYMyYMVCr1YiNjcXWrVu92v1XCEI9R4GetRZoQXQjeIasBK0Q4iKFjU1JGEntPRKTp4CxSIBITxIgzJsEuL6OEnqV2GwcPGwFn5PDDAXYFQwPeDc2iO62432X7gbPbk9i45Uk/haaNpjNZuTl5Xk1GBvwQBy98847OH/+PMaNG4dx48YhISHB48LHjx+PIUOGYM6cOeyJ5OTkYN26dZg4caLo/CIjI2E2O9rJmM+sWbMwa9Ys0fl7g3W2GisEiSU4foj1BEoU3UhiCGgkgggIrCi6ERHS7WVFQFcbIFAkiSnbE6EkJF8ReDX7zJP7rdTdqB7iUReWK2HkzGsk1XYibL15Js5UKhXapaS4HNLijEuFhTAajf4XRyNGjMC6devwww8/4IknnkBZWRmGDh2K8ePHo2/fvqLyeu211yCTyfD4449Dr9eDEAK1Wo158+bh5ZdfFmtaUKPVahESEiJ4HzZ/cEMKIiqGXCOVvd5eYw/t8Ki+xXqDfOE9Epu3QC8S4IFIAsQJJUCcWBKSvwcIFRCi2oif/8BKMo7HYdechDd7FzYKsp9b/07iq9VqdO7a1SMbciWYxg94II6++eYbAMADDzyABx54AJWVlXjhhRcwcOBAxMXFobCwUHBecrkcr7/+Ol544QXk5OSAEIL09HR2VevGgFwuR2xsLORyuct4Wq1WkvFGUnSt+VsUNcV1hpzR6MSQFSntDpAw8iu+FkiAz0QS4IGXRUqx5Ch/oeVIQDAPJPYKp2OLGKfxnHqNAozJZEJVVRUiIyOhUChEXTONRgOZTIbk5GSvbPDIjVFYWIht27bhhx9+wK5du2A2mzF8+HCMHz/eIyPUarXXU/cDRUREhMNB5bZIJY68wV+iiIqhRkQwiSKgcQgjfyFGgIkQSYBIoWS1hZeBSLEECGsfARRNjRKXA9e9uOELFSM+Epo1NTU4cPAQBg8aiOjoaPsILoalaHJz0bp1a7fL67hDtDjq1asXTp06hdatW2PcuHH44osvMGLECEFT1C9fvozc3FwMGjRIcHm7d+9Gjx490Lx5c7GmBhVarVbwNH5Xg7LF0qQFUYBumI1eEAHS192NKIx86T3ilgGIF0mA74QS1y42EyECy8nNyBvRJNaGxoxgweJmlmE9koxjEhPXw4eRWDs1Go3TdQvFILp2nn32WUyZMgWdOnVCUlISWrVqJfih37JlS7z55ptYtWoVu0u9M7RaLV5//XV8+OGHQS2MKioqsHXrVrdLD2i1Wqf7qolFSBvz9VT8prRZqyu4U+yDeqq9UKSuuwBuLmlLQK6Nv7poPJkB5MFGq5IuZig4LeP65Y0NwTR93x3e2Cl0+QVnSDAQO1i6K3M1GqSnp3udj2jP0bRp0zBt2jSYzWbs27cPX3zxBZ555hm0b98eEyZMYDeTdcbnn3+OefPmISkpCQMGDEBqaiqaNWsGhUIBo9GIsrIy5OTk4M8//8TMmTPZKfiNHZ1OJ+nWIY7GHvnaS+RX7xD1CkmHr85JyvYQ6Hr3xgvkDw8StyxAfHkeeJQAEYs1OsLVw1JUPgJvbJ62xyB5qAtG7I3ewfn5bOC3P9M7gBACTW4uptx7r9d5ibZu48aNAOoGIrdr1w4p9dPtNmzYgPvuu89t+vDwcHzwwQc4cOAABg8ejPz8fPzyyy/4/PPPsX37dhQWFmLkyJE4cuQI3n77bY+m8gUjdWOOpB1o7ukfLFFl+Ms7FACvEGDvGWpS+KoupfYWNYV69/cD1hvPhwceJSteb5dhxRfeHHceKLEvf+Aru8TUpVCvkR/bOMMwCAlRit7+49q1a6isrPR6phrggedo6dKlOHPmDLZu3Yq///4baWlpGDduHJ566ilkZWUJzqdz585YvHix2OIbLVVVVQgLbRxbh/jFQ0QHT/sGX56jL9qFRPZKcm299QD504NkW64VbzxKVkR4lthinTw4Pb4ugV6TCPCfQPIWkXUVrDPUuERFRWHUyJEAADF3HY1E0/gBD8TR+fPncfDgQTzwwAOYMGECOnbs6LURNwI6rRZR0VENB1yuFRGYH6VPRREVQ77D1+fpq3bRFK9PoAQSt3wrntohkWACfLT2kNNMgvNBH0y43ZZFKDZx7fKVaDC2WDS5uQACJI4efvhhvPPOO14X3FSIjIzE8OHD3U7T1+p0SExMFJSnlLPVxMAtM+ArV3sIFURSl0OFkWgCLZC4dnDxxiZXHgYPhRMXb8bA3DC/eS9wWL9ivEZ+Fp5VVVU4cvQY+vXtg4goB1P5nZCr0SAuLg5RUVHuI7vBo+1DAKC0tBR///03GIZB586dER8f77UxjRGZTIbw8HC38XRaLcLCgnfTWZ+LIT+tX+LJTZbeXIMIDx/o7q67qCnqUnoxgqltSSmWuAh5yEogoJwRLLOkGjVSeo0kKM9isUCr1cIist1ocnPRrl078fY4QPRZGQwGPProo2jZsiWGDRuGrKwstGrVit0CRChlZWViiw5KtFotjh07xm4s6wydTsefyu9m8LE/BkEHfCp+gLramsQgbH9NVfbV4FUhtvppTy7BtnlSn8E8fdwftlgs4oURd8C4sxfFO8RM3fekzQcIqdY4AjwQR08//TTOnz+Pr7/+GqdOncKpU6ewefNm/PPPP3j22WcF55OcnIxevXph/vz52LFjBwwGA4C6dYPee+897Ny5U6xpAcFoNKKwfqM7V2h1Or9si2K7/pCrl0McCRiRL8ZisntRIeRn/CVAg2idI78h1TToYBFKvhRwnggbq6By9fKk3Mb8khJvutM88hJ5PkTEkwUgO3To4HF5XER3q+3duxdHjx7lbaDatWtXjBs3Dv369ROcz/PPP48xY8bgp59+wuLFi3H69GkMGTIEo0ePxvDhw/HLL79gxIgRYs0LWnRaLcIEdL95ilfeHwkeoO6ER9ALk0Da14RXF/f5dffp7Lwgb7O+xt2DScoB30IQ44HyphsvGD1TYm1ydv62+Xgpgt0OxPYjWq0WRUVFkgzGBjwQR852lg8JCRG1JtH8+fMBAD179kR4eDhuu+02nDp1Crt27cKdd96JadOmiTUtqNHqdAj1wVT+YBdFQcuNJobYsv27hhSlCSP2Qehte/CVaLEVEhaL8LJ8KQZ8NYDeitjuNE/GGjnyGglIFx4ejv4ZGc7H8zrII1fCmWqAB91q8fHxeOONN6DT6dhjOp0OS5cuRVxcnEdGKJVKtG3bFuPHj8fKlStx7NgxyfoNgwFCSP3eatINyPZqrJCX3S2NspsqkGOdrF1PgeqCCtDimj7H12UEQ5dXU0LMODlfj6Xj4k03lpghB2Lx6VhCkcJIijxFoFAoEB8f59AR4wwp1zgCPBBHa9asYfc7S0tLQ1paGpo3b46PP/4Ya9eu9ciIS5cu4Z133mHH7URFRfllfI4UqFQqdOjQwaXXzLqPnMNFIEU2qECJokYniAI88DugYggI2Lk3qjZCadxILbZ8LdSkvid5aocEwseXXiOg7pl5LjvH7R6sXDS5uQgLCxO8ZI47RHertW/fHv/88w82btyIM2fOgBCC7t27Y+rUqQgJCfHIiBdffBEPP/wwFi9ejMGDByMhIQEAcM8993iUnz9Rq9VuF8K0etlCPfAcSTKTzEsvUaPgRu0m4xLAOvB7O/FXeYyMjj1qDLh66Prj+gWLl5Frh6PzFiRqPOhOk/j89Xo9snNykJCQINhRkqvRoF27dqK3HHGGaHEE1I0vmjlzpt1xT6fRKRQKrF+/HnPnzsXu3bsRExODKVOmeGKa3zGZTLh+/TpiY2OdugCt0/xD1X5e58gLL1HQQ8VQHUFwrRpFe/EGKpCCB2+9HkLTW0ziywk2bIWSBMJIUBrAK6+Rp2jqxZFUeCSOnPH//t//w65duzxO36tXL/Tq1Us6g/xATU0NDh06hKFDhyI62vFKnlZx5LdFIJuiKKJiqIEguU5B3V6khgok/yHVUgkeQhgZIBfXCxKo5UoEI5Ew8teCm55sc6LJzcVtt90mmQ2CxJFMJpPMVXUjwnqOwmzGHPmioXnwAw3ah1ygxgoFG0F2fQLeXgJVvvX3GujzbyoEgwiSCCIT5mdgnHmkAt2mPBVGQeI1MplMuHjxomSDsQGB4qhnz55YtWqVyziEEMybN08Km5ocrOfIzf5rXtEURBEVQw0E27VBELaXQEG9SOKQ6sHoYT4eiyAfPNAJ1yPloA05FU9O4kuCr4WRByiVSrRMagmlUiko/qVLl2AymfwvjhYtWoTMzExB8Sj2NHSrcTxHUv3wGrMoCsSU+mAlWK6JA4KmvQQT1Itkj5Riwp9CKFCDqW3LJRanHiiGO2aI2+a8aX8CBY/Xwkhk/RJGhrCwMPTu3UtwGqmn8QMCp/LffffdvO+EEOzevRubN28GAJw/fx4Wi8Uu3o2AdeNZmYu1MdjZalJ7jkT+MIJimrU/p5gHen0hZ0ixBoofCIr2Euz4Yt2dYMYX6+54mBdhZHYvj2x3a5/A/QXFvNzZ5+RcXZ6HmGvgjTASg4fpLRYLampq7DeedTbeSKOBXC5HcnKyR+U5QrTlBQUF6N69O0aMGIGFCxcCADZu3IiePXuyK1TeSERGRmL48OGIjIx0GocdcyRGHEm4qFhAH3L+EgG2QihYxFAjEUJcqCjyEKnEQiCRYj0fsWUIRJQQEluOlJsqC8FdGU7stjt32zieXicxwsiH3WnWMquqqrDnt99QVVUlKJ0mNxdt2rQR3A0nBNG1OHfuXEydOhUlJSWsSnvppZfw/vvv41//+pdkhjUlGgZkh7tvvBIt1BjQRRsDIYaCgUYohKw0ukU+GwO+FBhS2eJr27wow2diyBMBJLT+PK1jIUKJg9s9zVyev4fX2Zn9EnWneYOnywi5QrT1169fx7///W/ExcXxZrANHDgQ1dXVXhlTXl7uVXou//nPf8AwDPbs2cM7/v7776NPnz4YNGgQxo8fj8LCQq/KqaysxC+//ILKykqncbRaLZRKpWtV66E36IZ7qAWTGAIapRDickO1nWBBygdtoESP0PMSgd/EkNhzkLr+3OXtzFYhXiQX8cUcE9yd5k9h5CLPXI0G6enpkhYnep2jiooKh8f1ej2uXLnilTFdunTB5cuXvcoDAC5fvowVK1bYHf/222+xZMkSnDx5Ei1atMDLL7+MCRMm4OjRoy7HDLmCEAKDwQDi4oFdt6+ai01nBT6c6EMMwv7l+RNGHmgLvIKgcdsfjDAmfaBN8D0SPPxEj2fx9oHtaX6+hmuH7T3eei7W54s1LiceYWQNzwZGxs/D+l2oUIJ/VsAWXK6QdIRAk5uL6ffdJ6k9oq3p06cPpk+fjmPHjsFoNCI/Px+//vorxo8fL2hGmytcCQwxPPHEEw5nzr322muYMWMGWrRoAaCui/D06dP48ccfJSnXGVqt1vl4IwGCJyi6x8S8KJTGiEReGqIMbdIvTx+UfhszJEV+gcKZfY68SJw4ojxITs7f6XVxVldB0J0GAKWlpaiurpZ0phrggedo1apVeOihh9CvXz8AYPcymTJlClauXOmVMVIsNLl161YolUqMHTuWd/z69es4duwYTzRFR0ejQ4cO2LFjByZMmOB12c7Q6XT2niMRIsLaYJvETud25QVRF1ljIdi8Z8FEsD70GgFC/7kTpW9X+mfMRgGRBI4T8gGeeDg8unfbeolsvUjWOPXhLj1I3PxsEDXwmmuHmDRusLUhOjoa48eNE5Svpn4iWMDFUUREBL788kssXboUZ86cAQB069ZN0j1NPKWmpgaLFy/GL7/8Ar2e79q2roNgu2NvYmIiG+YIvV7Py8vV2CJn2HmORI4t8iueNG5PbaTCyDPc1duNLJ4ag+fSy4e2v7ZwcIkPbSAKldd5uFxMUagdEp6jo7wE39vdiSR3AkmsKOKWaXdcem+Rt/WcW//8lnpAtsd7qyUnJ4NhGDAMg7Zt20ppk8c8//zzmDVrFpKSkpCXl8cLs84YU6n4PzyVSsWGOWLp0qV46aWXnIaHh4dj8ODBCA8PdxqHFUfBLIrc4Qt7buSHOOXGQsIHbVDcGxzYQNx0VxE//t6J3P2Ubsb2T4bYehV6TZ3kyxUFgq6p3XgiRphAclGuwzIcHpfeW+TKlurqapw4eRI9e/RARGSUyzw0Gg1atGjhcjkdTxB9Vnq9HvPnz0dMTAzat2+PtLQ0REdHY8GCBXbeGn9y/Phx/PHHH5g1a5bDcGu3lq2Ner3e5WDpRYsWoaKign0VFBTwwhUKBWJjY6FQONeZdQOyhbmiAz57qLGPI3K03lFTeFGCDzFjkZo47EPOxVhExmJ2/iLE5QuQ/idlAcN7EZlc8EvUNRXQHkQvZMl+Z/hhttfDQRmC8uWF+VcYAYDZbEZ5eTnMZrPbfDS5uT7puRLtOXr00Udx7NgxvP7660hLSwMhBBcuXMDHH3+M0tJSfPLJJ5IbKYRt27ZBp9Nh+PDhAIDa2loAwL/+9S/ExMRg+fLlAICioiJeuqKiIowaNcppviqVys7bxKW2thYXLlxAWloa1Gq1wzhVVVUIC3UxWw0B+jcYDKKHPviF4Uk9Uc+cZ9wAYkYoPuvCE5kvQwhsW7MYT5Sjn4/FznPU8FHmJm9ba5z2Njn73XLP3+Y+LGiMKdeL5MKD5BIhg9w9TSsVAsrR+GAaP+CBOPrtt99w5swZO2/Lgw8+iB49ekhmmFief/55PP/88+z3vLw8tGvXDqtWrUJWVhYAoHfv3jhy5AjuvPNOAHXjh86fP49ly5Z5XK5er4dGo0Hr1q2diiOdVouoaMeuQb+KIn+VRQVPcODoOlDBRMVPPcEifJzh6244VwLITji5w4mwsooou8lmtoOq2QT8Kfp1cZ3ctwUIJKfpXOEHUSRl28vVaDBmzBjJ8rMi2sJOnTo57IaKiIhA+/btJTHKVzz33HP49NNPUVpaCgBYs2YNunXrhnHcUfE+QFerc+g58rkw8kXXGO0CatzcSNfpBu3isuJo7zFRU+kdIWEXImEYly9BeUjYK20hhH15Azcf68tsqXvZdunZnbODunTbHcZ+dtzFxn5313UmZCkELxHX9ty3gerqahSXlEg+Uw3wwHN0zz33YNWqVXj88ccREhICADAYDFi3bh3Gjx8vuYGe8K9//QuHDh1iP3fq1AmbNm3CHXfcgZKSEowZMwZqtRqxsbHYunWrxwtACkWn1SE0tMGr5FNRJKUIojRt2H+aTcCbdAOJHis3gufHm9uQtyLHFzjqyrP1NPE0Dsd/QWw8QnaDronF3oPkCj8vhyCmvYaFR6Bnz56uF08G2P1cAyaObKfIFRUVYcGCBUhISAAhBCUlJbBYLGjTpg3mzp0ruZFiWbVqldOwWbNmOR207Su0Oi1CQ8N8J4q8zTcIbyIUP9IYRdINIoaCXQAB3ougpiaAxOJKMLkUS5wkDHfKvu3lsHAGNQdo9XCx7VipVKJ169Zu41mX4QmYOFKpVFi4cKHLOIQQr8buNFZCQkKQkpLCetEcodXqEBbqeDySx3gjiPx9QwmGgd++oKk9oAkJXoHU1Oqaw40ggADPbzuBEEDelijlr4h7+jyxxMgbZvJxy7a938pcbBFku9WID/BkmxiDwYArV64gKSnJ5bNVk5uL8PBwdtcLKREkjh577DHMmDHDbTxPFkhs7ISGhqJ79+4u4+jc7a0mlGBbbLGpih6hCF2bhOIZTazuqAhyj7+EkK9LcZW/kBq21oPbWXP14S49Sq7w4W/Mo/Zen0an0+H06dOIiYlxKY5yNRqkpqZKsruGLYLE0ZNPPikoM6HxmhJmsxnV1dWIiIiAXO5YoWt1OsHrHDlErAiR8gZzowsgb/Fm1kggCLT3KBjrxAN8IoSoCBKNJ6VYfGSazLqwtYMwZ1eDW09sV5uDXnDCMA0z4BjHQolXno/v694IIzH4ao0jwIPZahQ+1dXV2Lt3L6qrqx2GE0Kg0+kQ6madI8eJRcwyk2IWUmNe/LExQuu6gUY8k0yymWBWJJxl581MMF4+XkxKdTR7y1cQm5druxy/XOZPiKiXu/Ic2e3cXn792V4Hh9fWSTuSfBajDdbFjG1fzhN4Vq5Go0GHDh08tNI1Hm8fQhGGXq8HIYQ3W80lYh6S3gqhIEDqfzBBse+UpwjcKLJJ0cjOUfL21YS8QYB/xweJLUmMR8hW2HiKs3ys3UC2NskYm24xJ/lyu91sPUk8L5LDwm3anJNFKB0m9eJ+7fK342K7E2cYjUbk5+f7ZDA2EATiqLa2FlqtFs2aNWOPXb16FTExMS635GgsWPdtc7dCts9FkQ/FUFDs9VSPz368gcAPgyUDRiM5H0nbRBBNkQcalxACgkcMedPtxnat2ZTnSCwJEUrORJJtGxEllriIEE6SUF+eQi5DXHy8Sw1QUFAAs9nsM3Ek6ZmeOXNGdBqlUonVq1fj1KlTMBgMOH78ON57770mIYwAjjhyNuZIaJeKWH+2xF02ztykwSSMvMXVOQb8PJtK11uQd59J1sXgw24xj/KRYK1Wf3WNWRHTRWbF0+4xoXl6Ox7JWdeaI3vs4sB5Pdh2t9nicTuSYLFPTwgPD8dN/fu73NDdl9P4AS88RxUVFaisrOQ1rIcffhgHDhwQlY9cLseSJUswadIkXL9+HcuXL8fnn3/uqVl+h2EYKBQKMAyDqqoqWCz8B1hFRQWAug1qrZ+tDzmlUomwsDBYLBZUVVXZ5R0VFQUGQE1NDUwmEy8sNDQUISEhMBgM0Ol09fmS+rLkCA8PByEElZX2+UZGRkAmk0Gr1cJotMlXpYRKpYLRaIRWq+OFyWQyREZGAAAqK6vsbioREeGQy+XQ6XQwGIy8MJUqBGq1GiaTCTU1Wrs6jIqq21G5qqrarg7Dw8OgUChQW1sLvd7AC1MqFZw6tB/3FV2/bUt1dTXMZn6+YWGhUCqV9XVYywsTWofVWh1MJv7miGq1ymkdyuUyRETU1WFFhf3sTsF1aJNvXR3Wnavt7xKou9k01CF/8+WQkBCEhoaykwtsB2RHR0cDsNYh/1zDwsKgVCqh1+vZ/QytKBQKhIeHN7RvmxtqVFQUGIZx2b7r6pDfXuRyOacOK2BLZGQkp33b1qGK0w5reAKorn3XtUNRdcjI7OuQA/faOLpHWOuw1mCwq0NB9wibOrSa7fAeUY/12tS1b/t2GB4R4bQO1Wo1p33zr427OrROXKlr3/zfskqlgopzbbg4q0OrcHDVvq11aDabHdaho/bN1mH9tTEYDKi1qUO5QoGw+jqsclCHEfXtsKamBmab9q1Sq6Gur0Mdpw4Zht++ba+NjGmow1ondRgWGgqjkV+HdYtfu75HRISFCb9HuKtDzh85UfeIeggY9ro5m4mm0WigUCjQtm1bh+HeIloc/frrr3jkkUfsdqcnhHg8nU4mk2HDhg0YMWIEPvzwQ4/yCBRRUVG45ZZbAAB79uyx+/GdPn0aADD+1kkIUakgk8khl8uhVMihUoUgMiKyruEYDAhRKhASEoKQkBCoQkKQlpaGiPBwlFdWgFgsCA0NRVhoKELDQtGtS1e0b58GbY0Wly4VIDw8nJ0t16xZM9x8U38QQrDPgVgdMSwLarUaZ8+exZWiYl5Yxw7tkZ6WhmtlZThy7C9eWGREBDKHDAIAHPjjDztRMGTgzYiOjsIFTS7y8vntIzUlGV06d0JVdTX2H/yDFxYSosToEcMBAEeOHUeNzQ33poy+iI+Lw8WCS8jOucALa5WUiN69ekKn0+H3AwftznXCLXV77pw4dRrXy/kP0l49uqN1q5a4fKUIp//+hxcWH9ccN2X0g9lsdpjv6BHDEBISgn/++QfFJaW8sM6dOyO1XQpKr17F8b9O8MKioqIwZNBAAMCBQ4fsHpRDBw9CZGQksnMuoODSJV5YWmo7dOrYERWVlTj0x588EaNSqTFy+DAAwJ9HjkKv59+EBvS/Cc2bN0PexYu4UP+Py0qb1q3Ro3t3aLXa+vbSkK9MJsMtY+vq8PhfJ+xu1r1790LLpCQUXr6Cf/7h12GLFi2Q0a8vTGYL9h04ZFeHY0aPgkKhwOkzZ3D16jVeWNeuXZCSnIzikhKcOHGSFxYTE4NBA28GAOzbb9++szKHIjw8HOfOn8fly1d4Yent2yO9Y0eUlVfgz8OHeWHhYWHsPox//PEnDEb+g2fgzTcjNjYWmtw8dmVeK8nJyejWrRuqq6uxb98+XphCoWD3fjp+/Diqqqp4/9z79u2LxMREFBQU4Ny5c7y0iYmJ6Nu3LwwGg12+ADB27C2QyRicPHkSZdfKeGHde3RHmzZtUVxchFMnT/HCmjVvhgEDbgYhBL/v+90u3+HDR9TfI/6x26y7Q4eOaN++PcquXcPRY0d5YZERkRgydCgA4NDBgzCZ+aJg0KDBiI6OhubCBVzMv8gLS0lph85duqCqqgqHDvKvq1IZgpH1G4QfOXIUWi1fPGVk9EdcfDwK8vORk5PNHicEaNkyCT179YZOp8OB/fvtzvWW+u2jTp48ifLycl5Y9x490apVKxRduYK//67rGbFKirjmcejXvz/MZjMOHLDPd/iIkQgJCcG5f/5BSWkJL6xTp85IadcOpVev4sRfxwE0/OqioqIwcNBgyBjg4IED7D3C2mQGDxmK6KhIZGdn49Ilm/tsaho6deqE6+XlOPwH/z6rUqsxYsQIMAxw+PBhO6EyYMAANG/eHLkXL+LChQu8rrg2bdqgR48edfcIm3Yok8nYZ+Bff/1l94eld+/eaNmy7j77999/g+v/qrtH9IPJZMK+/fsBm87DrKwsp94jTW4u2rZt67NeJoaIHHnWpUsXzJ49G0OHDmVVKFAnju69914cPGj/IBFKRUUFq0CDlcrKSkRHR6OiooJ3/oDjf4ULFizA+++/j7T0jjCZTTAaDHUvkxFmkxlmswlmsxlmsxkWiwXEYvF6MCAjk0HGMJDJ5GBkMsjlMlaUyeVyqEMUUCiUUMjlkCvkCFEqoax/qdV1/6xDlCFQyOVQ1XtB1CoVQkNDERUVhbCwUDAMgzB1KELVaqjUdf9WmjWLQVhoGBiGgGHkUKtVCFWpoVKFIDo6CmFhYb71HFXz8wV87zmq+8fu3HNUo+P/A5PMc8StQ4YJXs9RRKQor4cVKT1HXO+QreeIi1OvR316UXXIgWEYRNbXoSvPkaM65HqOHLVDIXXI9RxZWO+ya8+RK++bN56jcDeeI2fXhsC198322nDLdeV9IwSI4rRvi037tnqO9E48R+E2niNut5s7z5FKpYLZxPccAYBMLkek1XNUUWG3skZkZCRbhyaOgGdc1KHMyT2Cm7er9q1SKsV5jjh44jnihjnj7nvugU6nw/bt253GscXV89sW0eIoKysLe/bscRh2/vx5n02rCxbEVC4AdOneEymp7fH2h+tFl1VbW4vKigpUlpejqrICVZWVqK6uRE11Naoqq1BTUw1tdTV0Wi10Oi1qdVrodLo6d6teD4NBD6PeAIPRAJPJCLPJBFP9y2IVZGYzzBYziMVSJ84E9sN7D8O6eq0P97qXDDKZ9V0GRlYn8mSyuu8qhYz9LJfJIZNbhaCsXhTKIJPLIJc1xGuIXxcmk8nZz/J60Sir/66o/yyXKyCXy1hBKZfJ2HiMNS9ZfbmMDAw452I9Q855AQDqRas1Tl18gAEDRsbUvbs7xs2TYWsSYJiGBeM4d7yGReT4u4M37CfIP84wsvrr0ZA30/CFPa+6vGUOj7Pv9WXU2ddwnFugzCaNNTOZzP4446DNWFPw68XJZ5t4tse59cIwMpdpmPo2x7YPed0fEYVcDqa+nSjk1j8ncjauTCaDQqGwS2s9bs3X+Twl4QTL1hqeWiF2fI8vBlWLGeskBTKby864CmN/Q47jO87feQzBw5CCpF1l9O+PIUOGYN26dYLTiHl+i/ZHDRgwANnZ2UhPT7cL++STT/DGG2+IzbLJcvbsWfxz+iQef3q+R+lVKjXiW6gR3yLBLszVj9FV27W4+bnbprVYLNBptdDWVEFbo0V1dRW02hroamrqxJhWC72+FvraupfRaIDRYKzzjhnrXiajESajEcb6d5PJVPe53ntmFW5ms7leuJlg4oo3sxkWswkWiwV6kwUWi6lOzBELiMXB2iKEgIAv8hqON5wk92bqezFIoXhOg/DmiGb2TwTD/jFg2D8DdYJLHaLgiTCrhzhEpYIqJIT1YKjVaoSGhkKtDkVYWChCQ0MRHhaOsLAwhEWEIzwsHOEREYiMiEBERARiYmIQExuL6Ohou427vfkleSIyAiWKfLFYpDVP2wUjGUdh9UNZuMcJXAskR4tKWuFWoyuhxO0SDpRQIoQgNzcXDzzwgM/KECSOHnzwQfaz2WzGzTffjD59+iApKYm3KvTPP/9MxRGHTZs2ISIyCkOHjwq0KR4jk8kQHhGB8Ho3r1T/Rm16uJziSXlmL2y0LY8QUifajMY6D1u9WON53QgBSP2ME9SLMAezT4jFArOZsPGsgs1icZDOwo/DE35czx47s8XC/Vr/2cKeAwDUS0MQi604rM/Dwo9fryT5edi9s4Xx80CDfYTYPsAc52V7Lg1Z2NaFTR7WMrh1aM2ArS9OXqR+3g/hfufaY2koniOqecK7XpTXCfQ6kW6pbwusB9bSEG49ZrHUzTq0WNOQ+rhmCyyoO2Y213l2TSYzzCYjzOZ6j6/R+ifCxHqBzWYzzCYTLJaGPxJ1XfRmWMwWVGt1bHe9xWKpO261h+Mp9harx0sml9d5XRUKKJRKKENUiApTQ6VW14+XDKsXWuGIiopGbGwMmjWPQ1xcHFokJCAhMRGJiUlo1qyZnejiItbmYPUUCcmfO6XfViRZ68Eqkmzjui6D1OdjH5PtUXaTSaCEUnFxMWpqanw2Uw0QKI5++uknjB07FkDdw3LixIlsGP3H7RhCCD7b+DlGjZsAlVr8prMuvT8eeo28KbOuXP8KI4/ylrg9WmcjSjXoz5fnTqGI/Y1yfy9msxm6mmrUVFdDV1OFmuoq6GpqoK2p77qvqUatTge9TgudtgY6bU19t341arU61Oq00NfqYNDXwqA3wGjQQ6/T4kpVJesZJvXiTBBs12WD0ApRqdEsKqJOXEVHo3nz5oiPb4GExAS0bNkKbVq3QZvkZLRq1QoymazRiSJnZTrzJDnyIjmK6zp/70US0CCU/CGSNPUTIgIujiZMmCBoFtm8efO8NqipcOLECeTmZOPfrwSPJ81dl1qwESxjJqSCCiNKMGH7R0IulyMiKhoRUdHsMVdiwOwk0Nnv1szzahLoaqpRVlqM61dLcP1qKSquXUVF2VVUlV9HVWU5aqoqoa2uRq22GrXaOuGl01bjYsV1mIxGWMwml3/OGYaBTK6AQhmCELUasVERiIyMQnR0NFok1Iuptm2RktoO7duno03bZJd/ggIhjGzL5gofR14k2242a1ygaYmk3PoZt6mpqT4rQ5A44gqjixcvIjk5mRduMBjw8ccf47nnnpPWukbMpk2bENOsGQYMyQy0KRSBNDUxRrmxCOb2a7YxjWEYhEVEIiwiEq3btQdgb7+t+OKGW/OzWCwoKy1GaWEBrhYV4lrRFZRfLUbFtauoKi9DTWU5aqqroNdqUXqtDFeuFMFkMoI48V4xMhkUCiWU6lCowyPQukVzxMW3QEJiIlq1boO2bZPRqUsXdOrcBWoPegSsuNtWxBm2niHG5jh3SR1uXNv4rssgTgduEyJ84LYvRZJGo0FiQoLL2WzeIrqvYObMmdi1axfvmHUBxLvuussu7EaEEIL/ff4Fxk6YBKVS6UF652G0S81F3sH8cKBeI0ojI5CeElscCSOgbphHsxaJaNYiER2RAYsDo1khxcnDaDajrLgQl3MvoPTSRZQUFqC8pAiVZaWoKi+DrqoS2soKnCkthtl80uENkmFkUISEQBUWjpYJ8WjRIgGtWrdGu9RUtE/vgC5duyE1rT1v7JS7YSjcMUTO60KcQAIC50UCfCOSNLm5aOdDrxEg0d5qSqUS8+fPxzfffCNFdo2eP/74A4UF+bhl0h2BNoWFdqkFV3kUipR4M9bIE8R0qdl6jYSkc5a/q3SuhBH/GIFMJkNcUhs0S2jNi2dnR/33muoqlF7KwxVNDkov5eHa5XxcL76C6rKr0FaVQ6PJxflz5xyLKLkcIaowJMY3R0JSItompyA9vSO69eiOnr37ID6+hV0adyLJmUDipuemDbQXCYD7DXFFoNFo0KlTJ0nycoYgcbR69WqsXr0aAFBUVOSwn6+iogL9+vWT1rpGyrsff4oWiUnoN2BgoE0RBPUa+RbqNaJQPMdXf1wciSlnqMMi0KZDN7Rs35UVbrbvAKCtrkZx3nkU52bjWmEerl8pQEVpEWquX8XlklLkF+Tjz0M2q8UzDORKFULCIpDWpiVatW6N9u07oGefPrjp5oFISkpybL8DgeRokLaj+Nw07pBaIAHee5Fyc3Mxfvx4r/JwhyBxlJWVhZiYGBBCsGzZMixcuJAXLpPJEB8fj+HDh/vEyMaE2WzGT/+3BeMnTeYtcyCUQHSpUSiUGwchfySkHIjtvizhXiOuJ8id10iobe68Ro5EkDNbVWHhaNWpF1p16sVLZ/1sshAYarUoufAPii78g7KCHJQXXULNtWLoqsrx9z//4PSpk/gFPzZkyjBQqEKhiohBz05pSE/vgB69eqH/gJuR3qEjFHL+kgfBLpAA77xIVVVVKC0t9elMNUCgOOrZsyd69uwJoG558nvvvdenRjVm9u7di9KSYtwyaXKgTWGhXWrBVR6FIiXB3H6FdKm5wptzc9alBojzGjnMW4BQsj1mqv8cog5DUuc+SOrcp044EcITUhaLBWWXclGafQJXc8+iojAXNdeuQF9VjgP79+GAzV54MqUKirBIdEtvh/T27TF23AQMG5aF6JgYAMErkDxFUz9TzdfiSPT2IVYOHTqEf/75BwzDoHPnzrjpppukti0ocbf8+JT7H8T+Pbuw/fAJjzbi9YXnyJU4CsYuNX+Pn/Dlw4V2qVF8jdS/F19N33deHmewtYAZarbHnQkdRx4hW3Ek1mvkqkvNkafI1mvEjWsVRrbxGr5bePmY6uPoyktRlnMSZbl/o7IwF7qrl6GvKoNJVwOQhhtOs2bNkZqainZpqUhNTUNqWhpSU9OQlpaG5s2b8Z5PQp9UUmw/wkvjwb13y3ffYerUqSgpKUF8fLyotD7dPiQvLw933XUXjh7l78bcr18/bN68GSkpKWKzbDIYjUb8su073D19ZqMQRsEI9RpRKMLx9x8JcWW5j+Or358rr5HXebsRRrbHAHth5Cg/V9+56UNj4pHYZzjiew1jw80WgiuHt+Pvz17GunXr0KxZM+Tk5CAnJwdnz53H3j17UFxczOYRHROD1FSraEplRVNaairiW7RwMRA88N4jjUaDyMhIxMXF+bQc0eJoxowZ6NGjBz755BPWrZWTk4NVq1ZhxowZ+O233yQ3srGwfft2lF+/jvG3B0+XWjBAB2JTKBSxOPMaeZoHe8yN14gt04WXyBXOBJJtHLMLjxnXa+QqL6swMum0yPn+XcT1GIrHHnvMYZlVVVW4cOECK5pycnJw7vx5HDywH5cvX2bjRUZG1gmntDSOgEpDWloqEhOT/Nd/5oRcjQap7dp55IAQg2hxdO3aNTsBZBVL3bp1k8ywxsgHG/6LtA4d0aFLV0nz9dV6I/7qUqNQKIHHnwOxg3H6vlBcxRU6ONtXXiPrMdtuuLwd/4OxpgJ/frfBqe2RkZHo1asXevXqZRem1Wqh0WiQnZ3dIJzOnceRw4dx6dIldmmBsLCwei9TnXhK4winli3rtmzxtXbyxxpHgAfiqFWrVg6PE0J4XWp//PHHDTMOCQB0Oh12/PQDHnz8Ccm71DxNR7vUgqs8CkVKmnL79fX0faGeKCFeI2eiyBdeI0fHa0ouIX/nJjz374Vo166dq9NxSlhYGLp16+bQwVFbW4vc3Fzk5OSw4unc+fP49ptvUFBQwO6Vp1Kp6sY4paYird7zlFb/atOmjWT7U2o0Gtxzzz2S5OUK0dbefffduPPOOzFnzhy0bdsWhBDk5+fjk08+wf3334/8/HwAdfusHThwQHKDhXDx4kXMnz8fpaWluHr1KpRKJVasWIFhw+r6aN9//328//77CA0NRUxMDD744AOnok8oP/30E2qqq3DLbcGz8KMrgnEgtui8g/jhQLvUKMFEsE3fF5o/4Jvp+87i2A7EdmhPAL1G1uNcz1HOd+8gJDIGCxYscGqzN6jVanTu3BmdO3e2CzMYDMjLy0NOTg7bZXfu/Hn8/PPPyM3NhclkAgAoFAqkpKTUe5tS2fFNaWlpSE5ORkhIiCBbDAYDCgoKfD5TDfBAHD388MMAgG+//Zb1kFhdbhs3bgTDMHZTB/3J1atXMWzYMHz44YcYMWIECCGYMmUKzpw5g2HDhuHbb7/FkiVLcPLkSbRo0QIvv/wyJkyYgKNHj/KWeRfLR5/+D12690Rq+3QJz+bGWduIeo0oFOEEc/v1diB2sE3f96QrzR9eIwC4+vcfuHpqHzZt2uTTfcacERISgg4dOqBDhw52YSaTCQUFBXZjnH777TesX78etbW1AOrWSWzbti3S0tKQ2q4dT0C1a9cOoaGhbJ75+fmwWCx+EUeip/LffPPN2LRpk8s4hBDce++9OHjwoFfGecL8+fORn5/Ps9FaoSkpKejbty9GjhyJZcuWAahb2TsuLg5btmzBhAkT3ObvaCpgVVUVWiQk4IlnF+Gh2XNF2xyIWWr+8BzR6fsUim/w5/R9wL/jjYJ5+r4j4eJsCr8jr5GjdY3475aGQdYOp/dzXkYj/lw2E8qIGFzPPh4wh4QnWCwWXL58mS+czp2D5sIFXNBoUFNTw8Zt1aoV62myWCz49LPPkJub69HMeJ9O5V+2bBmSk5MFxQsE33zzDZ555hnesbZt2wIArl+/jmPHjmHRokVsWHR0NDp06IAdO3YIEkeO+L//+z/U6nQYe+vtnhvuR270gdhN/fwoTZsbdR81d/hi+n6gvUa8tDZhhb9/C21JAY7//F2jEkZAnbeodevWaN26NbKysnhhhBAUFxfzu+rOncOJkydx4cIFJCUloU2bNj63UbQ4Gjp0KGpqarB582Zcv34dTz31FPbt24euXbsiNjaWF8/f1NTUQKPRwGKxYNq0acjLy0NYWBgeffRR3HnnnezKmomJibx0iYmJbJgter0eer2e/V5ZWWkX5+NP/4c+GTehVZu2om2m24U0LbFCvUYUiudIcS/wZPq+J1uF2B6TeqyRq6n7+ooyaH5aj5Y3T3A4+6wxwzAMEhMTkZiYiMGDB/PCCCEghHg1BEYoosXRmTNnMHz4cOh0OiQmJuKpp57CiRMn8NBDD2HTpk3o3bu3L+wURHl5OQDgueeew86dO9GnTx/8+eefyMzMhNlsRsuWLQHUjarnolKpoNVqHea5dOlSvPTSS07LLCsrw749OzH/xdekOQkJCIZZajfqQGwKJZgItoHYvtpHzR+LPjo7JtRr5Pq7xaF3yBrXNuzCtg/AyGQ48f3Hwk6iicAwjN+8ZKLF0dNPP423334bU6dOZWd/zZ49G6NHj8acOXPwyy+/SG6kUKxqcsKECejTpw8AoH///rj99tvx9ttv45133gEAnifI+t3ZYLZFixbhqaeeYr9XVFSgbdu22L9/P8LDw/Hjjz/CaDTi123f4+De3ZKej8fT+wNQpj/LI16coa9Pj8o2im8R18IE/UfxwEPt6LAgy2wy5NlnkwFx9s1BQcTBZ+twWmuRruwj3Hg28W3zsR5rCOfEsYkHznEL5zv3vC2cAgkhsNiWZS2P1N37iNmMsr8PYe7cufj7779dnBXFFutYJiFDrUWLo9raWkydOhUAeAouPT0dBoNBbHaSEh8fD5VKhdatW/OOJycnY+fOnUitXziqqKiIF15UVIRRo0Y5zFOlUvE8TdZutXHjxvHiHT6432v7KRQKhUIRwurVq7F69epAm9EoqaqqQnR0tMs4osVRRUUFTCaT3YJO5eXlvL1bAoFCocDNN9+MK1eu8I4XFxejbdu2iI2NRe/evXHkyBHceeedAOrEzvnz5wUPIG/ZsiUKCgoQGRkJhmFQWVmJNm3aoKCgwO3od4p00HoPDLTeAwOt98BA6z0w+KreCSGoqqpih9i4QrQ4GjlyJEaNGoUnnngCVVVV2Lt3L86ePYu1a9fi9tsDP1trwYIFmDJlCnJzc9GuXTtcvHgRW7ZswZo1awDUjUeaPXs2nn76acTHx2PNmjXo1q2bnSfIGdZR9rZERUXRH08AoPUeGGi9BwZa74GB1ntg8EW9u/MYWREtjpYuXYrFixdj2rRp0Ov1yMrKglqtxrx58/Dyyy+LNlRqxo4di7Vr12Ly5MkICwuDyWTCypUrcd999wEA7rjjDpSUlGDMmDFQq9WIjY3F1q1b/TL6nUKhUCgUSvAjehFIKzqdDjk5OQDqxhup1WpJDWssiFlUiiIdtN4DA633wEDrPTDQeg8MwVDvHrtLQkND0b17d3Tv3p0VRuvWrZPMsMaCSqXCkiVL7JYHoPgWWu+BgdZ7YKD1HhhovQeGYKh3QZ6jzz77TFBmb7zxBp1aSKFQKBQKpVEjSByFhobyVpUuLi6GyWRCixYtAAAlJSUghKBNmzZOV5qmUCgUCoVCaQwIGpA9YMAA7N5dt8Dhhg0bUFZWhtmzZ7MuL71ej7Vr19pN76dQKBQKhUJpbAjyHNXU1LArSI8bNw4//vijw3hjxowJ6ArZFAqFQqFQKN4iaEA2d2uNs2fPOlwJu7a2lp29diOxZcsW9OvXD0OGDEFmZibOnDkTaJOaDC+++CJ69eqFrKws9nXbbbfx4rz//vvo06cPBg0ahPHjx6OwsDBA1jZuDAYDFi1aBIVCgby8PLtwd/VMCMHLL7+MPn36oH///pg+fToqKir8ZH3jxVW9P/DAAxgwYACv/T/66KO8OLTexbN582aMHj0aI0aMQEZGBiZPnmw3HIS2d+lxV+9B196JSO69915y0003kU8//ZTs3buX/P7772TDhg3kpptuItOmTRObXaPmjz/+IBEREeTs2bOEEEI+/fRT0qpVK1JZWRlgy5oGS5YsIbt373Ya/s0335CEhARSXFxMCCHkpZdeIr169SJms9lPFjYNcnNzyYABA8j9999PAJDc3FxeuJB6XrlyJenatSupqakhhBAyc+ZMcuutt/rtHBoj7up9xowZdsdsofUuHqVSSX755RdCCCFms5nMmDGDpKenE51ORwih7d1XuKv3YGvvosVRdXU1eeSRR0hISAiRyWSEYRgSEhJCZs2aRaqrq31hY9Byxx13kLvvvpv9bjabSUJCAvnPf/4TQKuaDu7EUZ8+fcj8+fPZ7+Xl5UShUJCtW7f6wbqmw6lTp0h2djbZvXu3w4e0u3o2mUwkPj6erFu3jo1z5swZAoCcOnXKL+fQGHFX7+4eFrTePePOO+/kfT98+DABQPbv308Ioe3dV7ir92Br76LXOQoPD8f777+Pa9eu4fjx4zh+/DjKysrw7rvvOt3Zvqmyc+dOZGRksN9lMhn69u2LHTt2BNCqG4Pr16/j2LFjvPqPjo5Ghw4daP2LpFu3bmjfvr3DMCH1fPLkSZSWlvLidO7cGeHh4fRauMBVvQuB1rtnfPXVV7zv1nX6DAYDbe8+xFW9C8Hf9e7xIpARERHo0aMHevbsecOJIgC4du0aKioqeEscAEBiYiJdzkBCPvnkE2RlZWHQoEGYMWMGLly4AABsHdP69y1C6tlRHIZhkJCQQK+FlyxduhRZWVkYPHgwZs+ezdvcm9a7NBw8eBAtW7bEoEGDaHv3I9x6txJM7Z1uKOYhWq0WAOxW8FSpVGwYxTvatm2L3r17Y8eOHfj999/Rrl079O3bF4WFhbT+/YSQeqbXwjd06NABQ4cOxa5du7Br1y7o9XoMGDAA1dXVAGi9S4Fer8fy5cuxZs0aKJVK2t79hG29A8HX3qk48pCwsDAAdReZi16vZ8Mo3vHggw9i3rx5UCgUkMlkeP7556FWq7Fu3Tpa/35CSD3Ta+Eb/v3vf2PatGmQyWQICQnBW2+9hfz8fHzxxRcAaL1LwaOPPoo777wTkydPBkDbu7+wrXcg+No7FUce0rx5c0RHR6OoqIh3vKioCKmpqQGyqmkjl8uRkpKCCxcusHVM69+3CKlnR3EIISguLqbXQkKioqIQHx/Pdi3TeveOhQsXQqFQ4LXXXmOP0fbuexzVuyMC3d6pOPKC4cOH48iRI+x3QgiOHTuGkSNHBtCqpsPcuXPtjl2+fBlt2rRBbGwsevfuzav/yspKnD9/nta/hAip5x49eiA+Pp4X5+zZs6ipqaHXwgts279er8e1a9fQpk0bALTevWHZsmXIy8vDBx98AIZhcPToURw9epS2dx/jrN6BIGzvks9/u4H4448/SGRkJDl37hwhhJD//ve/dJ0jCUlJSSHff/89+/3DDz8kKpWK/P3334SQuvVIEhMTSUlJCSGEkFdeeYWuc+QFzqaUC6nnlStXkm7durHrjzz00ENk4sSJfrO9MeOs3kNCQsjhw4fZ78899xxp3rw5u/4OIbTePeHdd98lXbt2JQcOHCCHDx8mhw8fJkuWLCHr168nhND27ivc1XuwtXe6GZoX9O/fH59++immTp2K0NBQyGQy/PLLL4iMjAy0aU2C1157DatWrcLbb78NvV6PkJAQbN++HZ07dwYA3HHHHSgpKcGYMWOgVqsRGxuLrVu3QiajDlExGAwGjB49GuXl5QCAKVOmoE2bNuzUWyH1PG/ePFRXV2PQoEFQKpVIT0/HZ599FojTaTS4q/cVK1awY+60Wi3i4uKwe/dudsNvgNa7WKqqqjB79mxYLBYMHDiQF7Z+/XoAtL37AiH1HmztXdDeahQKhUKhUCg3CvQvNoVCoVAoFAoHKo4oFAqFQqFQOFBxRKFQKBQKhcKBiiMKhUKhUCgUDlQcUSgUCoVCoXCg4ohCoVAoFAqFAxVHFAqFQqFQKByoOKJQKBQKhULhQMURhUKhUCgUCgcqjigUCoVCoVA4UHFEoVAoQQohBIWFhT7J22AwoKSkxCd5UyiNHSqOKJRGwOrVq9GpUyekpKQITrNnzx5s2LDBZzbZ4omNvmDVqlW4/fbbeccc1YWjeMFEdXU1brvtNmg0Gp/kzzAMpk+fjv379/skfwqlMUPFEYXSCJg7dy4WLlwoKo2/xZEnNvqCFi1a2Ak0R3XhKF4wMW/ePGRlZWHIkCE+yV+pVGL9+vWYMWMGrl+/7pMyKJTGiiLQBlAoFIqUTJ06FVOnTpUsXiD4559/sHnzZly5csWn5bRq1QpZWVlYuXIlXn31VZ+WRaE0JqjniEJppHz11VcYOHAghg0bhv79++Opp56CXq8HALz11lvYsGED/vrrL2RlZSErKws6nQ4AYDQa8eyzz6JXr17IzMzE6NGjcfr0aQDA119/jV69eoFhGPzwww+YOHEiWrZsiUmTJrktUwjcrre33noLI0eOREpKCmbMmMHaBwAmkwkLFy5Et27dkJGRgWHDhuHEiRNs+Oeff84eHzBgAP7973+zx632W3FUFxs3brSL565cbt1s27YNt956K9LT0/HEE08IPn+hfPPNNxgwYADCwsIc2jZ06FBkZGRg1apVdrZt3boVEydORLt27fDaa6+hoqICDz30EPr06YMxY8bYeYmGDx+Or7/+WvJzoFAaNYRCoTQK1q9fT5KTk9nvkydPJt9//z0hhBCDwUDGjh1LXnrpJTZ8yZIlJDMz0y6f+fPnk6FDh5La2lpCCCH/+9//SHx8PKmsrCSEELJ7924CgCxZsoQQQkhOTg6ZOnWqoDJtbXR2HnK5nCxfvpwQQkhVVRXp1q0befrpp9k4ixYtIr169SJVVVWEEELef/99Eh8fT8rLy0lhYSGRy+XkwoULhBBCioqKSGxsLJvWaj8XR3XhKJ6rcrlpli1bRgghpLi4mKhUKrJr1y6X5yyW8ePHk1mzZtnZ1rt3b9a2vXv3OjzvlStXEkIIOXfuHGEYhsyePZvU1NQQs9lMBg4cSF588UVevocOHSIAyLVr1yQ9B0dUVFT4vAwKRQqo54hCaaSsWLECEyZMAFA3fmTSpEn46aefXKbRarVYvXo1nnjiCahUKgDAtGnToNPpsHnzZl7cmTNnAgDS0tKwceNGj8t0BMMwmDNnDgAgIiICDz/8MN59910YjUbodDq8/fbbmD17NiIiIgAADz30ECwWCz744AMUFxfDbDYjPz8fAJCQkICtW7eKtsEWd+VysXbHtWjRAl26dMFff/3lNN+DBw9i/fr1eOyxx/D999/jgw8+wMSJE1FUVOQ0TXFxMZo1a+bStiFDhmD27Nl2ae+++24AQIcOHRAXF4fExESEhYVBJpNh4MCBOH78OC9+TEwMW6avuXLlCtauXevzcigUb6FjjiiURkpNTQ2mTZuGixcvIiQkBEVFRW67uHJycqDX67F06VLeQyohIcGuu6V169aSlOmIhIQEqNVq9ntaWhq0Wi3y8/Oh1WpRW1uL9PR0NlwulyMlJQWnT5/GM888g/vuuw/Dhw/HkCFDMG3aNEyfPl20Dbbk5OS4LJdLUlIS+zkyMhKVlZUO86yoqEB2djZmzpyJiIgIvP3229i5cyd27drFO39H6RSKhtuz1bb27dvz4r3yyit2abm2hYWF8b6Hh4ejoqKCF1+pVAIAysvLndojFR07dsSxY8cwZ84cvPXWWwgJCfF5mRSKJ1BxRKE0QqqrqzF8+HDcc8892LhxI2QyGTZs2IAXX3xRUPoVK1Zg2LBhLuPI5XJJy+RCCHH4nWEYuzAuDMOAYRh89tlnWLBgATZs2IDFixdj5cqV+PPPPxEdHS3aFmc22ZbLhVs3rmxWKpW49957AQB//vknJk2aBLlcjk2bNrm0JSYmBkajUZBtttheN9vvtnlZy4mNjXWZ74EDB3DHHXcItsMZWq0WVVVVyM/Px5YtW+zso1CCAdqtRqE0Qs6ePYuSkhLcddddkMnqfsYGg4EXx3ocAGpra2E0GpGeng61Wo1z587x4q5duxZ79+71ukyhlJSUoLa2lv2u0WgQFhaGtm3bsjZmZ2ez4WazGXl5eejWrRsKCwtx8OBBdO3aFcuXL8eZM2dw6dIl7Nixw2l5jurCFnflekJYWBjrmdm+fTtGjBgBAHbeG1sSExNRVlZmZ1tOTg4v3ooVK6DVaj2yzYq1nISEBJfxBg4ciKKiIq9f69atw/z58/Htt99SYUQJWqg4olAaIampqQgNDWUFgdlsxvfff8+LEx8fz3aVPfXUU/j1118RGhqKefPmYe3atWxYdnY2Vq9eja5du3pdplAUCgXee+89AHUeqY8++giPPfYYFAoFa+O6detQU1MDAPj4448hk8nw8MMPIzs7GwsWLIDJZALQ4AnhdofZ4qgubHFXrif89NNPePvtt3HhwgVkZ2ejW7dusFgs+Oyzz1ymGzRoEE8IObLt559/xpYtW3gz2jwhJycHXbt2des5koITJ05Ap9Nh2bJlvG5DCiXoCNxYcAqFIpRVq1aRjh07EpVKRTIzM0lVVRXZsmUL6dChA+nfvz+ZNGkSmTlzJlGpVGT48OGEkLqZVBkZGWTQoEFk3Lhx7Ow0o9FIFi5cSDp27EiGDh1KRo4cSQ4fPkwIIeSnn34iPXv2JABIZmYm+eqrr3h2uCrTkY2OsM5o+/DDD8no0aNJcnIyuf/++4lWq2XjGI1GsmDBAtK1a1fSr18/kpmZSY4fP04IIeTKlSvkgQceIP369SNZWVkkIyODfPLJJ4QQQjZu3MizPzs722FdbNiwwWE8V+Xa1s21a9fIAw88QKKjo0lycjJ588037c71k08+IXPmzCHvvPMOefXVV8mqVavI2rVr3c4MO3/+PImMjOTVodFoJPPnzyddunQhQ4cOJRMnTiT5+flObRs1ahRRqVSkY8eOZOPGjWTlypUkOTmZREdHk3vuuYfN9/7772dnJvqampoav5RDoXgLQ4iIzmwKhULxEus4pby8vECbEtTMnTsXLVq0wOLFi31WhkajwS233ILDhw8jKirKZ+VQKI0N2q1GoVAoQciyZctw6tQp7Ny50yf5GwwGzJo1C1988QUVRhSKDdRzRKFQ/Mbq1avx7rvvIi8vDwMGDMBPP/2E0NDQQJsV1JSWliI+Pl7yfI1GI7RarVcz/CiUpgoVRxQKhUKhUCgcaLcahUKhUCgUCgcqjigUCoVCoVA4UHFEoVAoFAqFwoGKIwqFQqFQKBQOVBxRKBQKhUKhcKDiiEKhUCgUCoUD3dwmiCCEwGKxBNoMCoVCoVACSqA3JabiKMAYDAbs3r0bt9w7G6SqEDDVuk9EoVAoFEoTJhoKtEEo1h/ehb59+4JhGL+WTxeBDABVVVX46aefMOWRZ0GqrgAyBZioVmAiW0MW3gKMrE4xW9+tnxlZfS+oTA4ZG0dmE68uDsM0xGdkcjBWFS5r6EllGG4+NvEZvmpnZDJOHnIwTENcmYzhxGPq82Ygq2/MjIxhO3BlDD+uNb6MYVCfJe9HwI3Dz7OhrLrTYqyJYU0us0nLjcstV15frlzG8M5FXp9GwTkulzGQ19eTnJdnXZj1ODe+FQVjmw/TkJaTV8PxhjhyGcPG4dahjGEgt566rOEz9zj3/LnHZRx7uHnKGUCGBhuspyBnGj5b7W7Isz4+GG4Ta7henDwZBg35cPMD59oxDUHc49wkDMcepqGJ8dsPNx8GDvO3lmHNnGFviQQM4XhyrZ8JYT8znM+wjeswDuHFY7hpreUSC/84mydh4zCc/EEsAMfjTKzHLea6FwBi5sSvP1aXtP6zhTR8JmZ+fmYH+RHSkA8vP44txAyYG/LnxSNmNj4xE7Ycq+1smfWfWY+6xcKGcePXmcHJxxqHNOQPAKg/brFY6mwFQMxmEAtpsJ9brplTrjWOmTQct9ZFffms3WbCqQaOjRbC5mMxc2wzE1gsDXY2xCEcOwl7jtzrY7GAV4cWjp1sHEJgqbfTTACz1WYCmNEQj82eNHw2E/DSNsQlnPgEZs5xrqgwOyvXQZ7WfAiAfOhQAB0KUQslZGgDNd7Z8T2GDh0KpVIJX0PFkZ8oLi7G1q1b8ci8F0BqioGQCDCRrSCLag2oY9kbOqMMcyGO6o/LbUWNA3HEjc8RR7Z5OsrHNk9HeXDjOhVH1s82YoQbl+EIAUfiiCdwZHzB5UgcMRyRJUQcyW0FCFccyRrEET+OjBdulw/Dj2/FPh/X5TqLI3cijmQ2AoorjrgiiCegnIkjpqFcvjji2sm1wV5scvN1Jo64osepOGIYm3jWtO7FET8frki0EUccOxlHIqX+e907VxzZiBRuXIujOK7EUcNn9ji3m91VubYCBbARRxzB41AcWTifbcUR93iDqHEujhqON6S1tZErjjhix9LwuaF8Cyxm1/HriuMct37mxOfma+HlY3ZRrn0+duKIK2R4cYhdnhYLYUULVxyJzpN33oQvjjh5snEIcShSuJ+t3+veCU8cORIy/Dj8z9zBIe7KdZantl5umUFQDD3yocMl6GAGQWuEYsW3/8Po0aMRHh4OX0C71XyIRqNB+sA7YKkqBLTXgNBmkEW1giyxNxhVZKDNo1AoFAolqJGDQUuo0RJqEMTgKgwogA4z7rgbWpiRBBVeWf8uJk6ciObNm0tWLp2tJiGEEBw/fhyyFt3AqGOQ1j4dpKYYsuhkyDtMhCJ1JGRxnakwolAoFApFJAwYxEOFPojBbUjAOLRAHELwzMxHEB8Xh0RGjdWrV+PixYtel0XFkZeYTCbs2bMHsuYdIFNFoE+//oC+ErL4zpB3vA3y5EzImrUHo6Q7j1MoFAqFIgUMGMRAie6Iwjgk4HYkIhmheONfC9AuJQXNmRD0YqJx+vRpeDJ6iHareYBOp8P27dsxacZckKrLABgwUa0gS+oLJjzBbrwOhUKhUCgU3xEOBToiAh0RAT0sKIQOBahFr+49EAYZ2iAUH+z7GQMGDBC0TAAVRx4QFtcW0F4FVNGQtR4IJjyenb1FoVAoFAolcKggQyrCkYpwmEBwEVocRQUGDx6MrojAaVLlNg/6RPeAAzv+D0yzdMBihKVgHyyXDsFScRHEbAi0aRQKhUKh3PDUwISzqMZuXMVBXEc45OiJKHyf85eg9NRz5AE333wzLNfOgxCCv/76C33H3AdL6T9A4Z9gwluAiWxV96LjjCgUCoVC8TkEBBUwoaB+faQyGNECKixatQyTJk1CcnKyqPyoOPIChmHQu3dvWEpOAwAuXLiADoMmw1JxEbhyjJ26z0S2pjPUKBQKhUKREALCTu3PRy20MCEJaqxY/wEmTJiAuLg4j/Om4khC0tLSYC76CwB/0UdLyWmniz5SKBQKhUIRhrNFIT/9drOki0LSMUc+IiEhAf/v//0/WKouo7KiHF9+9iFgrIE5bw/M57fCfOUoLNXFvOXvKRQKhUKh8DHCgjxo8Tuu4StcxkFchwzA1h2/otqgxwVSg9tvv13S1bKpOPIDkZGRuPvuu2Epv4habRV+3rYFIASWwkMwn/se5kuHYKm8BGIxBdpUCoVCoVACjg5mZKMGu3AVm3EZJ1GJCChw4PCfqLYYcZZUY8SIET7bZ43urRZALBYL/vjjDwya+CBI1SXAqANCIthw+643hvPWsBcUf5coNjEvXcNXm7gOjjvu8mNExLU1wcGuoY6+OrHRaRHcfdqcZOowKbf+OJHsaptjD9c0x7XDOMzH1naGE8lVPBsLXZRra7+4OnF0jZy0OpfXriEO49BOu3RuIrkKdn9ejlM7S+c8BQGc3h0dBDi9lRKnXxmHBRCHH4WX6yg94X+2C+bm4ey8Hefh9Lxd5Enc2sjNxrb+HNcPmycvum253A/E7rNtUjjKk9jY78gWZ2l55hMHaRxk6jCOkzbi5BLZWuzss5PTdRLXQTuyjQO+Pa7ica0kACphQnOE4Nllr2DSpEno0KGDgxS+g4qjIIEQghMnTmDlypW45557EBISEmiTBGEwGPDll19Sm30Mtdk/UJv9R2O0m9rsHwwGA3bv3o3XX38dKpUqIDZQcRREVFZWIjo6GhUVFYiKigq0OYKgNvsHarN/oDb7j8ZoN7XZPwSDzXTMEYVCoVAoFAoHKo4oFAqFQqFQOFBxRKFQKBQKhcKBiqMgQqVSYcmSJQEbgOYJ1Gb/QG32D9Rm/9EY7aY2+4dgsJkOyKZQKBQKhULhQD1HFAqFQqFQKByoOKJQKBQKhULhQMURhUKhUCgUCgcqjgJIWVkZXnzxRQwePBhZWVno1asXXn31VZhMrvdYI4Tg5ZdfRp8+fdC/f39Mnz4dFRUVfrK6juzsbAwcOBBZWVmC0+zZswejRo3CsGHD0KFDB4wcORJXrlzxnZE2iLFZq9XirbfewtChQzFs2DD06dMHTz31FKqrq31vaD0GgwFz585F37590bdvXzz55JMwGAwu01y8eBGTJ09GRkYGhg4dilGjRuHUqVN+stgzm7lMnjzZ5ZY0UrBlyxb069cPQ4YMQWZmJs6cOeMy/r59+zBgwABkZmZiwIAB+P33331qnyPE2mxl27ZtYBgGGzZs8K2BDhBjMyEEr776Knr27InMzEz069cPH3zwgR+trcNgMGDRokVQKBTIy8tzGXfHjh249dZbMXz4cNx8880YPXo0jh8/7h9DOYixGQCuXr2K//f//h+ysrLQr18/dOvWDV9++aXvDeWwefNmjB49GiNGjEBGRgYmT54MjUbjMo3ff4eEEjD++9//ki5dupDy8nJCCCGFhYUkISGBPP/88y7TrVy5knTt2pXU1NQQQgiZOXMmufXWW31ur5XPPvuMDBgwgAwaNIhkZmYKSvP777+TtLQ0UlBQQAghpLKykrRr146cOnXKh5Y2INbm33//nbRo0YK1t7y8nHTr1o3cd999Pra0gSeeeIKMGDGCmEwmYjKZyMiRI8mTTz7pMs3gwYPJXXfdRcxmMyGEkFWrVpHWrVuT2tpaf5jskc1Wtm7dSmJiYogvb0t//PEHiYiIIGfPniWEEPLpp5+SVq1akcrKSofx8/LySFRUFNm9ezchhJA9e/aQqKgokpeX5zMbbRFrs5Xq6mrSs2dPAoCsX7/eD5Y2INbmjz76iERFRZFLly4RQgjJz88nUVFRZNu2bX6zOTc3lwwYMIDcf//9BADJzc11GT8tLY188MEH7Pfnn3+eNG/enBQXF/vY0gbE2qzX60nPnj3Jp59+yh575plnyNNPP+1jS/kolUryyy+/EEIIMZvNZMaMGSQ9PZ3odDqH8QPxO6TiKID8+OOP5OOPP+Ydmz17NklPT3eaxmQykfj4eLJu3Tr22JkzZwgAvwmNH374gej1ejJjxgzB4igjI4O8++67vGPHjh1ze4OXCrE2//XXX+TVV1/lHVu+fDlRq9XEZDL5yMoGrl69SpRKJfnxxx/ZYz/88ANRKpXk2rVrTtNFREQ4bBvHjh3zqb2EeG4zIXUP8h49epClS5f6VBzdcccd5O6772a/m81mkpCQQP7zn/84jP/UU0+R/v37845lZGT49WEi1mYrTz31FHnvvfcCIo7E2jxnzhyH9SxUWEvBqVOnSHZ2Ntm9e7cgoXHPPfewf0IIIaS0tJQAIBs3bvSxpQ2Itfmdd94hN910E+9YaWkp+fvvv31opT133nkn7/vhw4cJALJ//36H8QPxO6TdagHklltuwYMPPsg7plarXXZDnDx5EqWlpcjIyGCPde7cGeHh4dixY4fPbOUybtw4URsYFhQU4PDhw8jMzOQd7927NyIjI6U2zyFibe7ZsycWL17MO6ZWq2E2m2GxWKQ2z469e/fCaDTyrnNGRgaMRiP27t3rNN3kyZOxZcsW6HQ6AMDGjRshk8kQFxcXtDYDwPPPP4/HHnsMiYmJPrVx586dPPtkMhn69u3r9LezY8cOXnyg7pz89VsDxNsMAMePH8eff/6JRx55xB8m2iHW5ttuuw3//PMP2wV84sQJnD59GgkJCX6xFwC6deuG9u3bC46/adMmyGQNj1C1Wg0AorqRvUWszd98843dfTguLg6dO3eW2jSXfPXVV7zv7uouEL9DKo6CjIMHD+Kuu+5yGm7tl+U+RBiGQUJCgts+20BhveHl5ubilltuwcCBAzF58mScPHkywJaJ4+DBg7jtttugVCp9XpZGo4FCoeCJmvj4eMjlcpfX+aOPPkLr1q3RsmVLJCcnY8WKFXj99dfRpk2boLXZXw/ya9euoaKiwk6AJSYmOrVPo9GIii81nthssVgwe/ZsvPPOOz4fv+UIT2weOXIk1q9fj+HDh6NLly7seMrHH3/cHyZLwsGDBxEaGooJEyYE2hSnnDp1CqGhoXjssccwaNAgDBs2DO+99x5IgJc7PHjwIFq2bIlBgwY5DA/E71Dhs5wpotm1axfy8/Px448/Oo2j1WoBwG7lUJVKxYYFG9evXwdQ5x34+eefER8fj//85z8YMGAAzpw5g3bt2gXYQvecPXsWv/zyC44cOeKX8rRarUNPV0hIiMvrfP/996O0tBQFBQUIDw/HN998g9DQUF+ayuKJzdYH+Xvvvcf7F+4r+wBxvx2tVhvQ35onNq9duxaDBw9Gjx49fG6fIzyxedu2bXjkkUfw66+/om/fvtBoNNi8eTPCwsJ8bq8UkPoB5a+88opfvLSecv36dSxduhTfffcd3n33XWRnZ2PIkCGoqKjAggULAmKTXq/H8uXLsWbNGqd/PAPxO6SeIx/w4osvgmEYly/bh2xhYSFmzZqF77//HtHR0U7ztt4s9Ho977her/fqRuKJzUKxPvQef/xxxMfHAwDmzJmD2NhYvP/++0FpM5eqqirce++9+Oyzz5CSkuJVXkJtDgsLc+hiNhgMTq/z8ePH8cUXX+DFF19EREQEGIbBxIkTcc8992D//v1BafN//vMfDBo0yC8Pck9+O2FhYZL/1sQg1ubCwkJ89NFHWLJkiV/sc4Qn9bx48WLccccd6Nu3LwAgNTUV2dnZmDNnjm+NlYgXX3wRrVq1wtNPPx1oU1wik8nQv39/3HLLLQCA9PR0PPjgg3j77bcDZtOjjz6KO++8E5MnT3YaJxC/Q+o58gHPPPMMZs2a5TIO999FWVkZbr31Vqxbtw59+vRxmS41NRUAUFRUhNatWwOo+9dSXFzMhvnDZjFYu3Ss9gJ1XYFt27ZFbm6uR3kCvrXZSm1tLSZNmoR//etfGDdunFd5AcJtLigogMlkwtWrV9lzKC0thdlsdnqds7OzAYAn4FQqFRITE/HNN984dVkH0uZff/0V169fZ5dXKCoqAgBkZWUhIiIC27Zt88hmRzRv3hzR0dFsGVaKioqc2peamioqvtSItfnXX38FAIwfP553/I033sCGDRvw6quvYvDgwb4zGJ7Vc3Z2Nu6++27esXbt2uGtt94KyJR+Mbz//vs4fPgwvvvuu0Cb4pY2bdrw7sMAkJycjOLiYuh0Or95ma0sXLgQCoUCr732mst4gfgdUnHkAyIiIhARESEoblVVFSZOnIgXXngBI0eOBAB88MEHTsdf9OjRA/Hx8Thy5Aj69esHoK7Lp6amhk3va5vF0qdPH4SFhdmtaVRcXOzVjdqXNgOAyWTC3XffjTvuuAMzZswAUDeQcOTIkYiNjfUoT6E2Dx06FEqlEkeOHMHYsWMBAEeOHIFSqcTQoUMdpmnVqhUA4MqVK+xns9mMkpISr256vrT5hx9+4H3fsGEDZs6ciT179nhsryuGDx/O8yYSQnDs2DG7wfdWRowYgQMHDvCOHTlyxKvfmljE2Dxz5kzMnDmTd4xhGCxcuBAPPPCAr01lEVvPrVq1srs/XLlyxe8Pa7F88cUX+PLLL/HDDz8gJCQEGo0GGo3Gr+1DDEOGDLH7Q1pcXIy4uDi/1/WyZcuQl5eHzz//HAzD4OjRowDAeg+5BOR36LN5cBS36HQ6kpWVRZ566ily+PBh9tWnTx82TklJCWndujVvvY+VK1eSbt26sescPfTQQ2TixIl+t9/ZtHhHNi9cuJDcdNNNRKvVEkII+e6774harSbnzp3zl7mEEOE2m81mMnXqVDJlyhTetZkwYYLb6bJS8cQTT5BRo0YRk8lEzGYzGT16NHniiSec2mwwGEjXrl3JlClT2CnGa9asIQqFghw5ciQobbZl/fr1Pl/nKDIykm13//3vf3nr7zzwwANk+vTpbHzr+iq//fYbIYSQvXv3ksjISL+vcyTGZlsQoHWOxNj8+uuvk7i4OHLx4kVCSF29N2vWjPzrX//yq92EEKfT4m1t3rp1K2nbti3ZtWsXe3947733yJIlS/xrMBFu84kTJ0hoaCj5888/CSGEXLt2jaSlpZGXX37Zn+aSd999l3Tt2pUcOHCArbslS5aw7TQYfodUHAWQtWvXEgAOX1aKiopI8+bNyZYtW9hjFouFvPTSS6RXr14kIyODTJ06lVy/ft1vdn///fckMzOTJCQkkOjoaJKZmUk++ugjlzabTCaycOFC0r17dzJkyBCSlZXldE2LYLB527ZtTq+Nv8RRbW0teeKJJ0ifPn1Inz59yJw5c3iLOTqq57y8PHLXXXeRfv36kQEDBpABAwaQH374wS/2emqzlczMTNKxY0cCgGRmZpKlS5f6xMZvv/2W9O3blwwePJgMHTqUnD59mg2bMmUKmTx5Mi/+3r17yU033USGDBlC+vfvT/bu3esTu1wh1mZCCFm6dCnJzMwkAEjHjh0Fr0kmFWJsNhqNZOnSpaR3795k0KBBpHv37mTx4sVOFwX0BXq9nmRmZrILZ95000289XhsbY6Li3N4f/CnOBJrMyGE/PzzzyQjI4MMHDiQ9O/fnyxbtswva7dZqaysJDKZzGHdWcVRMPwOGUICPIePQqFQKBQKJYigs9UoFAqFQqFQOFBxRKFQKBQKhcKBiiMKhUKhUCgUDlQcUSgUCoVCoXCg4ohCoVAoFAqFAxVHFAqFQqFQKByoOKJQKBQKhULhQMURhUKhUCgUCgcqjiiURgwhBIWFhQEp22AwoKSkJCBlByuBvB6NHdqeKMEEFUcUikQcPnwYWq3Wb+VVV1fjtttug0ajcRt39erV6NSpE1JSUgTlLSQ+wzCYPn069u/fL9Bi/xLM18MXiL3GnqbxFcHenig3FlQcUSgS8cknn/h1Z+t58+YhKysLQ4YMcRt37ty5WLhwoeC8hcRXKpVYv349ZsyYgevXrwvO218E8/XwBWKvsadpfEWwtyfKjQUVRxSKBFy+fBktW7YEwzB+Ke+ff/7B5s2bMWvWLL+U54xWrVohKysLK1euDKgdttyo16OxE6ztiXLjQcURhSIBGzduxLRp0/xW3jfffIMBAwYgLCyMPfb5558jIyMDw4YNw4ABA/Dvf//bZR5fffUVBg4ciGHDhqF///546qmnoNfr7eKtX78eY8eORUpKCmbMmAGdTscLHz58OL7++mtpTkwiguF6PP7441AqlejSpQv++9//snb17NmTjXPHHXcgOjoaixYtAgAYjUY8++yz6NWrFzIzMzF69GicPn2ajS/0mgFAUVER+vXrh6ioKGRlZQkeC+WujEGDBoFhGPTp0we//fYbAOD+++9HZGQkW+euzuPrr79Gr169wDAMfvjhB0ycOBEtW7bEpEmTAARne6LcgBAKheI1s2bN8mt548eP55VZWFhI5HI5uXDhAiGEkKKiIhIbG8tLs379epKcnMx+nzx5Mvn+++8JIYQYDAYyduxY8tJLL/Hiq9VqsnLlSkIIIVVVVaRbt27k6aef5uV76NAhAoBcu3ZN0nP0hkBfDyuZmZlkwYIF7Pd7772XACD5+fmEEEKKi4vJHXfcwYbPnz+fDB06lNTW1hJCCPnf//5H4uPjSWVlJSFE2DWzXuOamhoyduxYsm/fPpe2i20XZrOZtG3blixfvpw9dvXqVTJixAjB57F7924CgCxZsoQQQkhOTg6ZOnUqISTw7amioiIg5VKCC+o5olA4fPjhh+jTpw+SkpKQlJSETp064Y477nCZ5siRI+jXr58keQmluLgYzZo14303m83Iz88HACQkJGDr1q0u81ixYgUmTJgAoG68x6RJk/DTTz/x4phMJjz++OMAgIiICDz88MN49913YTQa2TgxMTGsDd4iRZ0Fw/WwMmHCBGzbtg1AXV1evXoVrVu3Zo/98MMPGDduHABAq9Vi9erVeOKJJ6BSqQAA06ZNg06nw+bNmwEIu2YAUFtbi3vuuQfPPPMMBg0aJOpc3JUhk8kwY8YMrF+/nj32v//9j/UaCTkPKzNnzgQApKWlYePGjQCkbU+ecOXKFaxduzYgZVOCB0WgDaBQgoX58+cjPDwchw4dQlVVFQYOHIgTJ06wN3hnbN68Gc8995wkeQmloqICCkXDz7dXr1647777MHz4cAwZMgTTpk3D9OnTXeZRU1ODadOm4eLFiwgJCUFRUZFdF01CQgLUajX7PS0tDVqtFvn5+UhLSwNQ9wAFgPLycq/OSao6C4brYWXChAl49tlnkZeXh7y8PAwcOBDt2rXDDz/8gMceeww//vgj1qxZAwDIycmBXq/H0qVLeQ/nhIQEdoCykGtmNBpx1113YdeuXVi9erXocxFSxsyZM/Hqq6/i0KFDGDBgAL766iv8/PPPgs/DSuvWre3Kl6o9eUrHjh1x7NgxzJkzB2+99RZCQkICYgclsFBxRKEAOHr0KI4dO4YdO3YAAJo3b46wsDBUVlbixIkTePTRR/Hkk0/ioYceQkREBJvOaDRCr9cjKipKUF7x8fF2ZRcWFqJVq1ai7I2JieF5bxiGwWeffYYFCxZgw4YNWLx4MVauXIk///wT0dHRdumrq6sxfPhw3HPPPdi4cSNkMhk2bNiAF198kRePEOLwO3egs9WO2NhYUefAxV2d7dixg70Ga9as4b1zr4kU18MTbK+HlU6dOiEtLQ3btm1DXl4epkyZgsuXL2PKlCmoqKjAtWvXkJSUxEuzYsUKDBs2zC4vodespKQEDz30ECorK/Hoo49i+/btgs9DaBnt2rVDVlYW1q9fj5CQEKSnp/N+F67Og4tcLrc75k17OnDggCTeQK1Wi6qqKuTn52PLli0O7aQ0bag4olAA7Nixg+1KAICLFy8iPDwc8fHxGDlyJNq0aYN77rnH7gGwbds2jB8/XnBejti+fTseeOABUfYmJiairKyM/V5YWIj8/HzcfPPNWL58OZ599lm0a9cOO3bswOTJk+3Snz17FiUlJbjrrrsgk9X1rhsMBrt4JSUlqK2tZb1HGo0GYWFhaNu2LRvHakdCQoKoc+Dirs6412DLli28d+41keJ6eILt9eAyfvx4bNu2DbW1tVi+fDk6d+4Mi8WCF154AUOHDmXjpaenQ61W49y5czxRsXbtWvTo0QNhYWGCrlmrVq0wadIkdO3aFT169MCGDRsEty+h7QKo8x7NmTMHJpOJ7R4Tch7cc3aEN+1p4MCBKCoqEp3Olv/97384deoUXnvtNSqMblDomCMKBXXdUpWVlQAAnU6H559/Hh9++KHbdNu3b8fIkSMlyUsMgwYNQk5ODvs9OzsbCxYsgMlkAtDg4UlPT3eYPjU1FaGhoaw3xWw24/vvv7eLRwjBunXrANR5FT766CM89thjvC6knJwcdO3alfdPf/v27TzvjTukqrNguR5cxo8fj507d6J9+/ZgGAbh4eHIysrCunXreEIuNDQU8+bNw9q1a9nup+zsbKxevRpdu3YVfM2spKenY8mSJXj66acFrzwtpow777wTAPDbb7/x1nZydx7ucNSe/MmJEyeg0+mwbNkyh12llBsDeuUpFABjxoyBVqvFhg0bUF1djRUrVqBFixYu01y9ehXNmzdn/2GLyUuj0eDAgQMAgIMHD7I3YblcjnvvvdetvXfccQdee+01VFdXIyIigu2+ufnmmxEREYGamhr2nzpQtxLyu+++i6KiImRlZWHbtm34/PPPsWDBAvz8889o2bIlEhISsHPnTowYMQK33nor3n33XbRu3RoMw2DUqFHIzs5GZmYmXnnlFZ4tO3bsYB+UVs6ePYs+ffq4PQ8xdeYOb64HAFRVVeHLL7+0O56cnIxRo0a5LNv2enDJysqCWq3mCaHx48fjr7/+shs4/vLLL4MQgptvvhkJCQkICQnBF198gebNmwOAy2t233334Y033mCv8c6dO7Ft2zaUlZVh8ODBmDdvHh577DFeeWLbxc6dO9m0oaGhuOuuu5CSkmK3npSr8/j555/ZhSezsrIwZ84cXvtx1J78SXp6Om+5BcoNSiCnylEojYXMzExy5coV3rHVq1eTM2fOeJ33+vXrPUr35JNPkldffdXr8r3hwoULpEOHDrzpz2VlZaR9+/Zk+/btkpZlvQa271akuh6eEgzXw9+MGzeOXLx4UbL8HLUnCiUQ0G41CsUNO3bsQEFBATZv3ozq6mr2+JkzZ9ClS5eA2bVs2TKcOnWK92/enxgMBsyaNQtffPEFrwutsLAQr7/+ul33ljdwr4Htu/Wa3OjXw19s3rwZOTk5uHDhAhiG4Y0/8wZn7YlCCQQMITbTUSgUils0Gg1+/fVXSbaL2LdvHwYPHuxx+tLSUkkHFwvFaDRCq9U6nA3nb6S8Ht4SqOvhL9auXYuVK1ciPj4eH3/8Mbp37y5JvsHUnigUKo4oFAqFQqFQONBuNQqFQqFQKBQOVBxRKBQKhUKhcKDiiEKhUCgUCoUDFUcUCoVCoVAoHKg4olAoFAqFQuFAxRGFQqFQKBQKByqOKBQKhUKhUDhQcUShUCgUCoXCgYojCoVCoVAoFA5UHFEoFAqFQqFwoOKIQqFQKBQKhQMVRxQKhUKhUCgc/j9fr9h+fRW3dgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -483,12 +603,11 @@ } ], "source": [ - "weac.plot.deformed(\n", - " pst_cut_right,\n", - " xsl=xsl_pst,\n", - " xwl=xwl_pst,\n", - " z=z_pst,\n", - " phi=inclination,\n", + "fig = pst_cut_right_plotter.plot_deformed(\n", + " xsl_pst,\n", + " xwl_pst,\n", + " z_pst,\n", + " pst_cut_right_analyzer,\n", " scale=200,\n", " aspect=1,\n", " field=\"principal\",\n", @@ -505,13 +624,13 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 53, "id": "20f83370", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -521,7 +640,7 @@ } ], "source": [ - "weac.plot.displacements(pst_cut_right, x=xsl_pst, z=z_pst, **seg_pst)" + "pst_cut_right_plotter.plot_displacements(pst_cut_right_analyzer, x=xsl_pst, z=z_pst)" ] }, { @@ -534,13 +653,13 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 54, "id": "71a3f159", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -550,7 +669,30 @@ } ], "source": [ - "weac.plot.stresses(pst_cut_right, x=xwl_pst, z=z_pst, **seg_pst)" + "pst_cut_right_plotter.plot_stresses(pst_cut_right_analyzer, x=xwl_pst, z=z_pst)\n", + "# pst_cut_right_analyzer.print_call_stats()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "de2c24ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gdif [2.27724548e-04 2.25296601e-04 2.42794667e-06]\n", + "Ginc [ 1.07401758e-04 1.11156619e-04 -3.75486071e-06]\n" + ] + } + ], + "source": [ + "Gdif = pst_cut_right_analyzer.differential_ERR()\n", + "Ginc = pst_cut_right_analyzer.incremental_ERR()\n", + "print(\"Gdif\", Gdif)\n", + "print(\"Ginc\", Ginc)" ] }, { @@ -564,34 +706,38 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 56, "id": "2c49a232", "metadata": {}, "outputs": [], "source": [ - "# Input\n", - "totallength = 1200 # Total length (mm)\n", - "cracklength = 400 # Maximum crack length (mm)\n", "inclination = 30 # Slope inclination (Β°)\n", "n = 50 # Number of crack increments\n", "\n", - "# Initialize outputs and crack lengths\n", + "\n", + "scenario_config = pst_cut_right.scenario.scenario_config\n", + "scenario_config.phi = inclination\n", + "pst_cut_right.update_scenario(\n", + " scenario_config=scenario_config,\n", + ")\n", + "pst_cut_right_analyzer = Analyzer(pst_cut_right)\n", + "\n", + "da = np.linspace(1e-6, 400, num=n)\n", "Gdif = np.zeros([3, n])\n", "Ginc = np.zeros([3, n])\n", - "da = np.linspace(1e-6, cracklength, num=n)\n", "\n", - "# Loop through crack lengths\n", - "for i, a in enumerate(da):\n", - " # Obtain lists of segment lengths, locations of foundations.\n", - " seg_err = pst_cut_right.calc_segments(L=totallength, a=a)\n", + "for i in range(n):\n", + " L = 1200 - da[i]\n", + " pst_ERR_segments = [\n", + " Segment(length=L, has_foundation=True, m=0),\n", + " Segment(length=da[i], has_foundation=False, m=0),\n", + " ]\n", + " pst_cut_right.update_scenario(\n", + " segments=pst_ERR_segments,\n", + " )\n", "\n", - " # Assemble system and solve for free constants\n", - " C0 = pst_cut_right.assemble_and_solve(phi=inclination, **seg_err[\"nocrack\"])\n", - " C1 = pst_cut_right.assemble_and_solve(phi=inclination, **seg_err[\"crack\"])\n", - "\n", - " # Compute differential and incremental energy release rates\n", - " Gdif[:, i] = pst_cut_right.gdif(C1, inclination, **seg_err[\"crack\"])\n", - " Ginc[:, i] = pst_cut_right.ginc(C0, C1, inclination, **seg_err[\"both\"])" + " Gdif[:, i] = pst_cut_right_analyzer.differential_ERR()\n", + " Ginc[:, i] = pst_cut_right_analyzer.incremental_ERR()" ] }, { @@ -604,13 +750,13 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 57, "id": "e62ef6d4", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAERCAYAAACKHYuuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSwUlEQVR4nO3dd3gU1dfA8W82vVcghJpACEWkI9ISQkcsgFiiooAFRZSiGF5QivIDbBQpAiogoIgKohRRmhTpvSS0UAJpkLLpye5m3j8WFiKBlN1kN8n5PM88uzs7c+dkxDk7986910pRFAUhhBDiAVTmDkAIIYTlk2QhhBCiUJIshBBCFEqShRBCiEJJshBCCFEoSRZCCCEKZdJkIU/hCiFExWRjqoI0Gg0DBw5kzZo1qFTl64YlLy+PmJgYXF1dsbKyMnc4QghhNEVRSEtLw8/PzzTXZMVE3n77bUWlUinh4eGmKrLMREdHK4AsssgiS4VboqOjTXKdtFIU4+uO5s+fj5eXF2+88Qbz588nOzuboUOHGltsmVGr1Xh4eBAdHY2bm5u5wxFCCKOcvHmSIeuGcG70OVJSUnB3dze6TKOTRVpaGrGxsTRo0AA/Pz9iYmI4ceIEDRo0wMHBwegAy0Jqairu7u6o1WpJFkKIck2Xp+P5Dc+jydTw23O/mey6ZnRFlqurKw0aNMi37uGHHy43iUIIISqSn87+RGRSJGPbjDVpueWrJVoIIcR93cy6ydyjcxnQYABNfJqYtGxJFkIIUUF8cegLrFXWvNviXZOXLclCCCEqgINxB1kftZ7RrUbj4eBh8vIlWQghRDmnydPwv/3/o1mVZjxZ/8lSOYbJOuUJIYQwj5VnVhKljuKnvj+hsiqdewC5sxBCiHIsLiOO+cfnE9YwjIZeDUvtOJIshBCiHPv04Kc42zrzVvO3SvU4kiyEEKKc2np1K39f+ZuxbcbiaudaqseSZCGEEOVQWm4a/9v3P4JrBtOrbq9SP54kCyGEKIdmHZ5FhjaDCe0mlMlo2ZIshBCinDkcf5jV51YzsuVIfJ19y+SYkiyEEKIcydHlMOnfSTSv0pxngp4ps+NKPwshhChHFh5fyPX068zqMqvU+lQURO4shBCinDibdJYlp5bw2sOvUc+jXpkeW+bgFkKIckCXp2PSv5Oo616XVx96tcyPb9JqqDVr1piyOCGEELf8EPkDpxNPs7zPcmytbcv8+Ca9s3j00UdNWZwQQgggOjWar45+RVijMJpVaWaWGCyyzWLt2rW0bt2aTp06ERwczOnTp4u03/r167GysmLp0qWlG6AQQpQRXZ6OCXsm4OXgxTst3jFbHBb3NNSBAwcYNGgQhw4dIigoiO+//56ePXsSERGBq+v9u7NnZGQwYcKEMoxUCCFK34qIFRxNOMp3Pb/DydbJbHFY3J3FjBkz6NOnD0FBQQC8+OKLaLVali1b9sD9PvroI958882yCFEIIcpEVEoUc47M4cXGL9Lat7VZY7G4ZLF161batGlj+KxSqWjVqhVbtmy57z5Hjx7lwIEDvP7660U6Rk5ODqmpqfkWIYSwJNo8LeN3j8fPxc+s1U+3WVSySExMRK1W4+ubv/u6r68vUVFRBe6Tl5fH8OHDmTdvXpHHR5k2bRru7u6GpVatWkbHLoQQpvTdqe84k3SG/3X8Hw42DuYOx7KSRWZmJgD29vb51tvb2xu++6+5c+fSsWNHHn744SIfZ9y4cajVasMSHR1d8qCFEMLEziadZcHxBQx9aChNqzQ1dziAhTVwOznpG29ycnLyrc/JyTF8d7fr16/zzTffsHfv3mIdx97e/p6EJIQQlkCj0/B/u/+PAPcAhjUbZu5wDIxOFikpKcTHx5OSkoKnpyfVqlXD3d29RGV5e3vj7u5OXFxcvvVxcXEEBATcs/1ff/0FwGOPPZZv/fTp01m6dCmffPIJHTt2LFEsQghhDguOLyBKHcWqx1ZhZ21n7nAMSpQs1Go1X3zxBb/88gtnz54F7gz1YWVlRZMmTXj66acZPXo0Li4uxSo7NDSUQ4cOGT4risKRI0cYP378PdsOHjyYwYMH51tnZWVFeHg4r7zySjH/KiGEMK+TN07y3anveLPZmwR5BZk7nHyK3Wbx77//0rp1a2JjY/nwww/Zu3cvERERXLx4kcjISPbs2cPYsWOJioqiTZs2HD9+vFjlh4eHs3HjRs6dOwfAypUrsba25uWXXwb0CeKll14qbthCCGHRMjQZfLDrAxp7N2Zo06HmDucexbqzuHHjBpMnT+aff/7Bz8/vvtu1a9eOF198kaioKN58801++eWXB3aou1vbtm1ZtmwZYWFhODo6olKp2Lx5s2H/7OxsNBrNPftNnz6dP//80/B+6dKl7Nixozh/nhBCmM20/dNIzEpkYbeF2KgsqjkZACulGEPFajQarKyssLEp+h9Skn3KWmpqKu7u7qjVatzc3MwdjhCikvnz0p+8v/N9pnacyhP1njBJmaa+rhWrGsra2ppt27Zx9epVACIiIoiIiHjgPra2thadKIQQwpxi0mOYsncKvev25vGAx80dzn0V6yo+duxYNBoN3377Lc888wwDBgwgJCREqnuEEKIEtHlawneF42rnyoRHJxS5Y7E5FCtZtGrViueffx6AjRs3cvjwYezsLOfRLiGEKE8Wn1zM8RvHWdprKW52ll0FXqxqqLy8PObPnw9Anz59UBSF+Pj4UglMCCEqsmMJx1h4fCFvPPwGLaq2MHc4hSpWsujRowfe3t6Gz61bt2bhwoUmD0oIISqytNw0wneF09SnKa8/XLQBUM2tWNVQVapU4dlnn823rl27diYNSAghKjJFUfh438eoc9R80+Mbi3xMtiClNpBgWFhYaRUthBDl1s/nfmbTpU1MfHQiNV1rmjucIjMqpanVaubMmcPRo0dRq9Xc3WXj2LFjxsYmhBAVypnEM0w/MJ1ng56ll38vc4dTLEYli2effZb09HTat2+Ps7Nzvu8uX75sTNFCCFGhpOWmMWbHGAI9AxnbZqy5wyk2o5LFjRs3OHz4cIHfSU9oIYTQUxSFj/Z8hDpHzaIeiyxqNNmiMqrNokWLFmRnZxf4XfXq1Y0pWgghKoyVESvZcnULH3f8mFqu5XNmTqPuLL788kvGjh2Lr68v1atXx9ra2vDd9OnTee6554wOUAghyrPjN47zxaEvGNR4EF1rdzV3OCVmVLKYO3cu8+bNw8fH556Z7KSznhCiskvJTuH9f96niU8TRrYaae5wjGJUsvj222+JjIwkMDDwnu969uxpTNFCCFGu5Sl5jN8znixtFp8Hf46tytbcIRnFqGTRpEmTAhMFwE8//WRM0UIIUa4tPL6QXdd2Ma/rPHydfc0djtGMauB+/fXXmTVrFjExMfx3Woz+/fsbFZgQQpRX269uZ/7x+bzd4m061exk7nBMoliTH/2XSqXPNfcbVlen05W06DIlkx8JIUwlSh1F2IYw2lVvx5chX6KyKrWBMh7I1Nc1o6qhmjVrxqxZs+5ZrygKo0aNMqZoIYQod9Jy03h327v4OvkyteNUsyWK0mBUspgwYQLBwcEFfjd9+nRjihZCiHIlT8nj/3b9H4lZifzY90ecbZ0L36kcKXbaCw8PZ+fOneh0OgYMGHDf7eRpKCFEZfL18a/559o/TO88nTpudcwdjskVO1lotVqGDRuGt7c3Tz/9NN999x2xsbGlEZsQQpQL265uY8HxBQxvPpzONTubO5xSUeIG7itXrrBx40Y2btzIjh07qF+/Pn369KF37960b9/e0PhdHkgDtxCipKJSogjbaP4G7f8y9XXNqKehbsvNzWXHjh1s2rSJjRs3cuPGDXr06EHv3r3p27dvvtn1LJEkCyFESSRnJxO2IQwHGwdW9FlhUe0UFpks/uvixYuGxNGlSxfef/99Ux/CpCRZCCGKK1eXy2t/vcbl1Mus7LPS4iYyMnuyePrpp/nll1+MPrAlkWQhhCgORVGYsGcCf176k297fkvzqs3NHdI9zN7PYs+ePQwZMqTQ7aytralWrRrBwcF07969RMEJIYQl+vbUt/x+8Xemd5pukYkCgIxEkxZX7GSRnZ3NpUuXirTtsWPHmDVrFu+99x6TJk0q7qGEEMLibLmyhdlHZjOs2TAeC3jM3OEUTFFgo2mr/4udLJo3b8727duLvH1iYiI9evSQZCGEKPdOJ55m3K5x9Krbi7eavWXucO7vyPdw4S+TFlnsZ7w++eSTYm3v7e2NnV35m0JQCCHuFpcRx4itI2jg2YCPO3x83zHxzC7xIvw5Dpo9b9Jii50sOnToUORto6Oj6dSpE87OlvM4mRBCFFd6bjpvb30bG5UNs0Nn42DjYO6QCqbTwprXwaUqdJ1o0qKLlSxiYmLYs2dPkbf39fVl8ODBrFq1qtiBCSGEJdDoNIzcMZKYjBjmdZ2Hj6OPuUO6v12fQ8xR6L8Y7F1MWnSxkoWfnx+ffvops2bNIjs7+4HbZmZm8tlnn7FlyxZ8fCz45AohxH3kKXlM2DOBI/FHmNNlDoGeBU/2ZhGuHYJ/PoXO70GtNiYvvtgN3D/88AOjRo2ievXqtGvXjoCAALy8vLCxsUGj0ZCUlMSFCxc4cOAAgwcPZsmSJSYPWgghysKsw7PYdGkTnwV/Rmvf1uYO5/5y0mHNa1C9GXQunU7QJe7BHRERwZo1a9i3bx/x8fGo1Wo8PDzw9fWlQ4cO9O/fn/r165coqLVr1zJ16lQcHR1RqVTMnz+fJk2aFLjtzp07+eqrr0hMTESr1aJWq3n99dcZPnx4kY8nnfKEEP+14swKZhycQXjbcF5o9IK5w3mw39+Bkz/DG7vAR3/dNfl1TbEw+/fvV1xcXJTIyEhFURRl2bJlSo0aNZTU1NQCt3/jjTeUyZMnGz4fO3ZMUalUyvr164t8TLVarQCKWq02LnghRIWw6dImpenSpsoXB78wdyiFi9igKBPdFOXgt/lWm/q6ZhnDI95lxowZ9OnTh6CgIABefPFFtFoty5YtK3D7d955J9+sfM2aNcPDw4Nz586VSbxCiIrlYNxB/m/X/9HbvzcjW400dzgPpr4O64ZDg17QanCpHsriksXWrVtp0+ZO44xKpaJVq1Zs2bKlwO0bN26Mq6srAHl5eSxevBh7e3sGDhx432Pk5OSQmpqabxFCiMikSN7d9i4tq7Xkkw6fWMxw4wXSaeHXoWDjAE/Oh1Lu92FRZyIxMRG1Wo2vr2++9b6+vkRFRT1w308++YTq1asza9Ys/vrrL2rWvP8IkNOmTcPd3d2w1KpVyyTxCyHKr0vqS7zx9xvUcqvFrJBZ2FrbmjukB9sxDaIPwNPfgnPpTwNhUckiMzMTAHt7+3zr7e3tDd/dz4QJE4iLi2PkyJEEBwdz8uTJ+247btw41Gq1YYmOjjY+eCFEuRWTHsNrf72Gp70nX3f7Ghc70/ZRMLmL22DXF9Dl/6BO+zI5pNHJIiMjgyVLlvDll18CsHv3bpKTk0tUlpOTE6CvJrpbTk6O4bsHsbKy4rXXXqNRo0ZMmTLlvtvZ29vj5uaWbxFCVE43s27y2l+vYaOyYVGPRXg6eJo7pAdLi4NfX4N6XaDj6DI7rFHJ4vTp0wQEBPDuu+/y9ddfA3D8+HHatWvH0aNHi12et7c37u7uxMXF5VsfFxdHQEBAgfvk5ubesy4oKIgzZ84U+/hCiMpFnaPmjb/fIFubzeIei6nqVNXcIT1Yng5+fRVU1tBvEZTh9NVGHWnMmDHMnDmT1NRUatSoAcDw4cNZv3494eHhJSozNDSUQ4cOGT4risKRI0fo1q1bgdu3atXqnnWxsbH4+fmV6PhCiMohU5PJW1vfIiEzgUU9FlHLtRy0Xe78DK7sgQHfgEuVMj20UckiOzubsLAwgHwjMAYGBhb4i78owsPD2bhxo+HR15UrV2Jtbc3LL78MwODBg3nppZcM26elpTF//nzD53/++Ye//vqrSBM0CSEqpxxdDu9sf4eLKRf5utvX1POoZ+6QCndpJ+yYDsEfgH/nMj98sYf7uJtarUar1WJjk7+YlJQU4uPjS1Rm27ZtWbZsGWFhYYYe3Js3bzY8HpudnY1GozFs/7///Y/FixezYsUKVCoVOTk5fPvttzz/vGmH5xVCVAy5ulxGbR/FsYRjLOi2gCY+BY8OYVHS4vTVT/6dSm04j8IYlSy6detG9+7dGTFiBGlpaezcuZPIyEjmzp1Lv379Slxuv3797rv/jz/+mO9zWFiY4e5GCCEeJFeXy6gdo9gfu5+vun5FG1/TD7hnctpcWP0yYAX9v9G3V5hBiceGAtBqtYwfP545c+YYnmBycHBg1KhRTJkyBWtr8/xRxSVjQwlR8Wl0GkbvGM2/Mf8yJ3QOHWoUfW4es9r4PhxaAoM3Qq22Rd7N1Nc1o5LFbVlZWVy4cAHQt1c4OFjoxCD3IclCiIpNo9Mw5p8x7L6+mzmhc+hYo6O5QyqaYz/Cb8PgsS+hzdBi7Wrq65pRDdy37yYcHR1p2rQpTZs2xcbGhk2bNuVrVxBCCHPR5Gl4f+f77L6+m1ldZpWfRBFzDNaPhOYvQmvzP7BjVLLo3bv3Pet0Oh3r16+nf//+xhQthBBG0+Rp+GDnB/xz7R9mdZlF55pl/xRRiWQkwk8vQtVG8NgXpT7uU1GYvEeHvb098+bNQ61Wm7poIYQoMo1Onyi2R29nZsjM8pModFr4ZTBoMuGZ5WBrGdX6xX4aatmyZYbhwo8dO0ZoaOg92yQnJ98zvpMQQpSVbG02o3eMZl/sPmaGzCSkVoi5Qyq6bVPg8m4Y9Bt4WE5HwWIni7p16xIcHAzApUuXDO9vU6lUVKlShQEDBpgmQiGEKIZMTSYjto3g5M2TzOs6j0f9HjV3SEV36lfYMxt6TDVLx7sHKXayCA4ONiQINze3fBMPCSGEOaXmpvLWlre4kHKBr7t9TctqLc0dUtFdOwy/vQVNn4FHiz4tdFkxqs3iQYmie/fuxhQthBDFkpydzKubX+WS+hLf9PimfCWKlGj48Tmo3gye+MoiGrT/y6ge3BqNhhkzZrBp0ybi4uK4u8vGf0eOFUKI0nIj8wav/fUayTnJfNfzO4K8gswdUtHlpOkTha0DPLvSYhq0/8uoZBEeHk5ERAQvv/wyM2fOJDw8nNzcXNatW1dgw7cQQpjatbRr+mHGddks7bUUf3d/c4dUdHk6/dwUyVdg6F9lPpJscRiVLPbs2cOePXuwtrZm1apVhpFhhwwZwjPPPGOSAIUQ4n7OJp1l2JZhONk4sazXMmq63n86ZYu0ZSKc3wzP/wTVGps7mgcyqs3C2dnZMP7T3UOSW1tbExMTY1xkQgjxAAfjDvLKn69Q1akq3/f+vvwliiPfw79fQc//QYMe5o6mUEbPZ7FhwwYURaF27dqMGjWKPXv2MHnyZFJSUkwUohBC5LflyhaG/T2MJj5N+K7nd3g7eps7pOK5tAvWj9IP4/HIMHNHUyRGVUONHDmSpUuX0rRpUyZMmEBoaCizZ8/GycmJH374wVQxCiGEweqzq5m6fyo96vRgasep2FnbmTuk4ok/A6tegLodofenFvnkU0FMMursbRkZGURGRhIQEICnp4VPen4XGXVWCMunKApfn/ia+cfmE9YwjA/afoDKquzmoDYJ9TX4pjs4eemHHHdwL7VDmfq6ZtSdRf/+/XF2dmb58uWAvg2joDmxhRDCGJo8DVP3TeXX87/yTot3eLXpq/mmci4XspJhxQBQ2cALv5RqoigNRiWL/fv3s3v3blPFIoQQ90jLTeO9f97jQOwBPu7wMU/Vf8rcIRWfJht+DIP0eBjyF7hVN3dExWbUPVyrVq3w9y/4meY1a9YYU7QQQhCbHsugTYM4eeMkX3f/unwmijwdrHkVYo7oH5Gt0sDcEZWIUcli2LBhTJkyhWvXrvHfpo+5c+caFZgQonI7nXiasI1hZGmzWNFnBY9Uf8TcIRWfosCmDyByAzy9BGqXw7/hFqMauFUqfa65X92hTqcradFlShq4hbAs265uI3xXOPU96jMndA4+jj7mDqlkdn0BW6dA31nQenCZHtqiGribNWvGrFmz7lmvKIqMRiuEKDZFUVh+ZjmfH/qcbnW6MbXjVBxtHM0dVskc+k6fKII/KPNEURqMShYTJky4Zz6L26ZPn25M0UKISiZXl8uUvVNYd3Edgx8azMiWI8vfo7G3Hf8J1o+Gtm9AyDhzR2MSJu1nUV5JNZQQ5nUj8wYjd4wkMjGSSe0n8Xi9x80dUslF/AGrX4Zmz8ETc0FlnoRnUdVQQghhrFM3T/Hu9ndBgaW9ltK0SlNzh1RyF7bCL0Og0eP6eSnMlChKQ8X5S4QQ5c6GqA288ucrVHOqxo99fyzfieLKv/phPAK6QP/FoLI2d0QmJXcWQogyp8vTMfvobJacWsIT9Z7go0c/wt7a3txhldz1I7DyGajZGp5ZBjblbLyqIjA6WWRkZLB69WqSk5MZPXo0u3fvpkmTJuVqbCghRNlJzErkg50fcDD+IO+1fo9BjQeVv6E77hZ/Glb0h6oN4flVYFtOn94qhFHVUKdPnyYgIIB3332Xr7/+GoDjx4/Trl07jh49apIAhRAVx/Ebx3lm/TOcTznPNz2+4eUmL5fvRBF3CpY9Du414YWfwd7F3BGVGqOSxZgxY5g5cyapqanUqFEDgOHDh7N+/XrCw8NNEqAQovxTFIUfIn7glT9fwc/Zj9V9V9PGt425wzJO3Mk7iWLQ7+BYsWtTjKqGys7OJiwsDMjfizswMDDfzHlCiMorU5PJ5L2T2XhpIy82epHRrUdjq7I1d1jGiT0O3z8JHnVg0G8VPlGAkclCrVaj1WqxsclfTEpKCvHx8UYFJoQo/6LUUYzZMYbr6df5rPNn9PLvZe6QjBdzTJ8ovALgpbXg6GHuiMqEUdVQ3bp1o3v37qxZs4a0tDR27tzJokWL6Ny5M/369TNVjEKIckZRFH678BvPrX8OnaLjx8d+rCCJ4ih8/wR416tUiQKM7MGt1WoZP348c+bMIScnBwAHBwdGjRrFlClTsLYu2XPGa9euZerUqTg6OqJSqZg/fz5NmjQpcNstW7YwZ84c0tPTycrKwtXVlRkzZtCiRYsiH096cAthOhmaDD7Z9wnro9bTr34/wtuG42TrZO6wjHf9MCzvBz4N4MVfLX7yIpNf1xQTyMzMVE6cOKGcOHFCycrKMqqs/fv3Ky4uLkpkZKSiKIqybNkypUaNGkpqamqB29erV09ZtGiR4fOHH36oeHt7K/Hx8UU+plqtVgBFrVYbFbsQld2Zm2eUx9Y8prRd0VZZf3G9ucMxnUu7FWVqDUVZ3E1RssrHdcLU1zWT9OB2dHSkadOmNG3aFAcHB6PKmjFjBn369CEoKAiAF198Ea1Wy7JlywrcvnXr1gwdOtTw+Z133iExMZEtW7YYFYcQougURWFlxEpe2PgCTjZOrH58NY8FPGbusEzj3GZ9P4oaLfVVTw6Vs/bBpMN9pKWlsXbtWk6dOlXiMrZu3UqbNnceqVOpVLRq1eq+F/9Vq1YZ5tUADMlKnsYSomwkZiXyzvZ3mH5gOs8EPcOKPiuo41bH3GGZxslfYFUY1O9W4ftRFMaoZDF+/Hh8fHzYu3cvWVlZtG3blpdeeolHH32U77//vtjlJSYmolar8fX1zbfe19eXqKioIpWxd+9eHB0d6du37323ycnJITU1Nd8ihCi+f6L/of/v/TmecJw5XeYQ3jYcO+sKMtTFwW/h11eh6TMwcBnYlOPhSEzAqGSxbds2zpw5w6OPPsqKFStITEzk8uXLXLhwgfnz5xe7vMzMTADs7fP/R7G3tzd89yCKovDJJ5/w8ccf4+Nz/5m1pk2bhru7u2GpVatWsWMVojLL1GQyZe8U3t72Ng/5PMSaJ9fQpXYXc4dlOru+hA2j4ZFh8OQ8sJZh9Iw6A05OTlStWhWAlStXMnjwYMNF2smp+E8/3N7n9pNVt+Xk5BSpvEmTJlGjRg3GjBnzwO3GjRvH6NGjDZ9TU1MlYQhRRCdvnGTc7nEkZCbwYbsPGdhgYPkesuNuigJbJsKe2fpJi4I/gIrytxnJqGSRlpbGlStXuHz5Mrt372bBggWAfu7tjIyMYpfn7e2Nu7s7cXFx+dbHxcUREBDwwH0XLlzIwYMH+e233wo9jr29/T13L0KIB9PkafjmxDcsPLGQRl6NmNt3LnXd65o7LNPR5sLvb8OJn6DXdGj3prkjsihGJYuRI0dSv3598vLyeOmll2jUqBH79u3jgw8+4KGHHipRmaGhoRw6dMjwWVEUjhw5wvjx4++7z48//shPP/3Ehg0bsLOzIyoqiqioKLp161aiGIQQ+Z1NOsuHez7kXPI5Xnv4NV5/+PXyP2TH3bLV8NNLcHUvPP0dPDTA3BFZHKOnVY2NjSU+Pp7mzZsDEBMTw/nz52nUqJGhiqo4Dhw4QLdu3Th06BANGjRgxYoVhIeHExERgaurK4MHD0ar1bJ8+XIA1q9fz/Dhw1m6dCmurq4AHD58mNjYWCZNmlSkY0qnPCEKpsnT8M3Jb1h0fBF13evyScdPaOJdcAfZckt9HVYOhNRr8NyPULeDuSMyCYubVrV69epUr17d8NnPzw8/Pz+6d+/O33//Xezy2rZty7JlywgLCzP04N68ebMhEWRnZ6PRaAzbDx48mJs3bxIaGpqvnIkTJ5bwLxJCAEQmRfLhng85n3yeoU2H8sbDb1ScJ51uizulTxQqaxjyl35OClEgo+4sNBoNM2bMYNOmTcTFxXF3UXFxcUV6gskSyJ2FEHdodBoWn1zM4hOL8ffw55MOn9DYu7G5wzK9qB36qifPuvo+FK6+he1RrljUncXt6qGXX36ZmTNnEh4eTm5uLuvWrbvnl74QwvIdSzjGpH8ncTn1Mq82fZU3Hn4DW+sK1DZx29EV8Me7EBACA5eCvau5I7J4RiWLPXv2sGfPHqytrVm1ahUvv/wyAEOGDOGZZ54xSYBCiNKXmpvK7MOzWX1uNU19mvJT358I8goyd1iml6eDvz+CvXOh1SvQ53OoiMmwFBiVLJydnQ0jy949vIa1tTUxMTHGRSaEKHWKorDl6ham7Z9GhiaDcW3H8WzQs1irSjZitEXLToVfh8KFLdBrBjzyhvShKAajZ8rbsGEDffr0oXbt2owaNYqnn36aLVu2kJKSYqIQhRClIS4jjqn7p7IjegehtUIZ98g4fJ0rVr29QVIU/Pg8pMbCC79A/a7mjqjcMbqfxdKlS2natCnjx4+na9euzJ49GycnJ3744QdTxSiEMCGNTsOyM8tYdGIRrrauzAqZRdc6FfjieWkXrH5JP/Xpq1ugSgNzR1QuGd3P4m4ZGRlERkYSEBCAp2f5mZNWnoYSlcW/1/9l2oFpRKdF80KjF3iz2Zu42FXQkVQVBQ4vgY3vQ50O+oZsJy9zR1VmLOppKNAniNWrV5OcnMzo0aPJysoyOighhGnFpsfy2aHP+PvK37Su1povQ74k0DPQ3GGVHk0WbHgPjq2ANq9Br2nSkG0ko5LF6dOnCQ0NJSsrC19fX0aPHs3x48cZOnQoq1atKtbUpkII08vR5bD8zHIWnViEi60LMzrNoLd/74oz8F9Bki/r+0/cPAdPfQ3Nnzd3RBWCUUOUjxkzhpkzZ5KamkqNGjUAGD58OOvXryc8PNwkAQohik9RFP66/BdP/vYk847OY2CDgfz+1O/0CehTsRPF+b9hYTDkpMLQvyVRmJDRT0OFhYUB5PsHGBgYKDPVCWEmpxNP8+mBTzmScITgmsEs6LYAf3d/c4dVuvLyYOdnsGMaBPaA/gv1DdrCZIxKFmq1Gq1Wi41N/mJSUlKIj483KjAhRPHcyLzBnKNzWHdhHfU86rGw20La12hv7rBKX2YSrB0G5/+CLv8Hnd4DlUlnjBYYmSy6detG9+7dGTFiBGlpaezcuZPIyEjmzp1Lv379TBWjEOIBMjQZfH/6e5acXoK9tT3jHxnPgAYDsFFVgtndrvwLvwwFbbZ+fKfA7uaOqMIy6tFZrVbL+PHjmTNnjmF2OwcHB0aNGsWUKVMMvbstnTw6K8ojTZ6GX8/9yoLjC0jPTef5hs/zerPXcbOrBP+G83Sw6wt9tVPtR6H/YnCvYe6oLIqpr2sm6WeRlZXFhQsXAH17hYODg9GBlSVJFqI8URSFzVc289WRr4hOi+bxeo8zvPlw/Fz8zB1a2UiLgzWv6TvbBY+FzmNljuwCWFw/CwBHR0eaNm2ab11mZmaJ5uEWQtzf/tj9zDo8i1OJp+hUoxNfhnxZMQf8u5/zW2DtG6CygZd/B//O5o6o0ii1dNy3b1+2bdtWWsULUakciT/C3GNzORh3kIe8H+K7nt/RxreNucMqO5ps2DoF9s2D+t30/Sdcqpg7qkql2MkiICCgSNvFxcUVOxghRH6nbp5i7tG57InZQwPPBszpMoeQWiEVu6/Ef8UehzWv6wcD7DEV2r0lTzuZQbGThb29faEd7hRFYcaMGSUOSojK7mzSWeYdm8f26O34u/vzWfBn9KjTA5VVJbpI5ulgz2zY/j+o0hBe/weqVcAZ+8qJYieLN9980zDJ0YOkpqaWKCAhKrPTiadZdHwR26K3Ucu1Fv/r+D/6+PepmPNLPEjSJX3fiej90HEkhIwDG3tzR1WpGf001H8HEty9ezdNmjSRUWeFKIZjCcdYeGIhu6/vpo5bHV5t+iqPBTyGraqSDX6nKHDke9j8f/oRYvsthDqVoGNhKbCop6FkIEEhjHMo7hBfn/ia/bH7CXAPYHqn6fSs27NydKj7r+TL+nmxo3ZAixeh5zRwkB9vlsKoO4tevXoxaNAgwsLC6NKlC9u3bwfg/PnzvP3222zevNlkgZYmubMQZSlPyWNH9A6WnFrCsRvHaODZgDcefoNudbpVrjaJ2/Ly4OA3sGWSfjynJ2brn3gSRrGoOwsZSFCIotPoNKyPWs/S00uJUkfRomoLvgr9is41O1fOJAFw8wL8/jZc3Quth0K3SXI3YaFkIEEhSll6bjq/nPuF5WeWk5CVQEitECa1n0SLqpW4mlangb3z9MN1uFaHVzZA3Y7mjqrcS0jL5siVFI5eTWb/2WsmLVsGEhSilFxLu8YPkT+w5vwacnQ59A3oyytNXqGeRz1zh2Zecaf04zolRUHoh9BmKNg6mjuqcidXm0dEbCpHryZz5GoKR64mcy1ZP1NpdXcHHvIx7dNjRg8kOGHCBGbPni0DCQqBvo/R0YSjLD+znG3R23C1c2Vgg4E8F/Qc1ZyrmTs888pOAVtnmd60BBRF4XpKFseiUzh6VX/ncComlVxtHnbWKprUcKNlbU/9UseD6u6OltVm8cwzz+Ds7ExSUlK5HkhQCGPl6nL568pfrDizgtOJp6nrVpfxj4zn8XqP42hTyX81KwqcWA3HVurHcxKFUmdqOH4thePRKRy/lsKxaDU30/U/yGt7OdG8lgePN/OjeS0PGvu5YW9T+j/MjUoW+/fvZ/fu3QUOJChEZRCbHsvP537m1/O/kpSdxKPVH2V+1/l0qNGh8jZa3y0hEja+B5d3QYdR5o7GImXl6jgTq+Z4tJoT11I4cU1N1M0MANwcbGhWy4Pn29aiWU0Pmtf2wMfFPJ0TjUoWrVq1wt+/4Oka16xZQ//+/Y0pXgiLpCgK+2L3sSpyFTuu7cDJxokn6j3Bsw2fJcC9aGOnVXhZKbBjOhxYBB614cVf5XFY9O0MZ+PSOHE9hZPX1By/puZcfBq6PAU7GxWNq7vRKdCHEV3r06ymB/4+zhYzDphRbRYbN27k0KFDDBkyhBo1auT7o0JDQ8vNqLPSZiGKIjk7md8v/s4v537hcupl6nvU5/mGz9M3oC9OtjIcP6Afz+nocv0Isdoc6PyefuC/SjhUR642j3PxaZy6rubEdTWnrquJjE0jV5eHtcqKBtVcaVbTnYdrevBwTXcaVHPFzsZ0d6MWNfmR6tbIj/fLfDqdrqRFlylJFuJ+FEXhYNxBfjn3C1uubkFBoWvtrjwX9BytqrWymF99FuHKXtg0FuJOQLPnoetEcKtu7qjKRLZGx9m4NE7FqDl1PZVT19WcjdMnBpUVBFZ1pWlNdx6u6c5DNdxpXN0NB9vSbWewqAbuZs2aMWvWrHvWK4rCqFFSPynKr5tZN/n94u/8eu5XrqZdpa5bXd5t+S6P13scLwcvc4dnWZIu6e8kTq8Bv5YwdAvUqrhzbaRlazgTk8ppw6LmQkI62jwFa5UVgVVdeKiGO0+3qslDNdxoVN0NJ7vyP3yLUX/BhAkTCA4OLvC76dOnG1O0EGVOo9Pwz7V/WHdhHbuu78LaypoedXswuf1kuYsoSGYS7Pxc3y7h7ANPzoNmYRVmrglFUUhIy+FMTCpnYlNvJQg1lxMzAbCzUdHQ15UWtT14oV0dmtZwp6Gva6nfMZiLSebgNrW1a9cydepUHB0dUalUzJ8/nyZNmtx3+7y8PGbNmsX48ePZtGkTISEhxTqeVENVbpdSLvHTuZ/YELWBlJwUHvJ+iCfrP0lv/96427ubOzzLo8mGAwv1HevydPohxNsNBzvTtNvcSMvh292XOB6dwpnYVLyc7ZgX1pLGfqX3/6ZGl8fFG+lExqYREXsnOSRm6IctcnWwoXF1Nxr7udHEz50mfm7Ur+qCrbXlJkaLqoYqDQcOHGDQoEEcOnSIoKAgvv/+e3r27ElERASurq73bJ+cnMzTTz9NvXr1yM7ONkPEorz7YNcHJGQm8FT9p3ii3hMEegaaOyTLlKeDk7/Atk8g9Tq0HgzB4Sad3nTPhZtsPh3HyG4N8HK2I0ero9XHW9Dlme43bWJ6DpFx+qQQcSs5XEhIJ1eXB0AND0ca+7nxYrs6NPZzo3F1N2p6Olb6O0uLu7MYMGAANjY2/PTTT4D+rsHPz48JEybw9ttv37P9tWvXiIuLw8fHB39/f7Zv3y53FuXEzaybLD+znFM3TxGZFImngydfBH9BkFdQmcZxOO4wzao2q5zDgheFokDketg2FW5EQMO++gH/fEybVM/GpTH5j9MsH/oI1ir9hXlbZDybTsbx2cBmJSrzQkIax6PVRMal3koQaYbObfa3qpEaVXczLA2ru+LmUDF6mFf4O4utW7cyYcIEw2eVSkWrVq3YsmVLgcmiZs2a1KxZk8uXL5dhlMJY+2L3sfXKVt5q/haeDp7k6nLp/FNntIq2zGNp5duqzI9ZLigKXNgK2z6G2GMQ0AWenAs1W5fK4Sb+forXOgUYEgVALU8nZgx4uMRlvrvqGKdjUqnt5URDX1fC2taiYXU3Gvq6UsfbOd+xxINZVLJITExErVbj6+ubb72vry8HDx402XFycnIMY1mBTAFb1s4nn+ebE9+wsPtCw3Sh+2L30b1Od5p4379tSpShy3v0SeLqXqjVrtRHhY1OyuTApSSWDm6bb31gNVeORafQvJZHicr9fGAzank54WJvUZe6csmo1pmXXnrJVHEAkJmpf8rA3j5/Bx57e3vDd6Ywbdo03N3dDUutWrVMVrYo3LQD03ip8Uv55pWu4VKDye0nmzEqgaJA1D+wtC8s7QOaLHjhVxjyZ6kPH346Ro2Xs/09TxKt2HeFudvOl7jcRtXdJFGYiFHJYt26dfTo0YNly5aZ5GLu5KR/muLuX/23P9/+zhTGjRuHWq02LNHR0SYrWzzYtbRrHI4/TDu/dvnW1/Oox+mbp80UVSWnKHB+C3zXE75/AnJS4dmV8PoOCOwGZdCwq8uD5MxcUjLvTJqWq81jyZ5LPFrPh93nb9L50+18t/uS4TUjp+yrLCszo5JFv379WLVqFWq1mp49ezJ06FB2795d4vK8vb1xd3cnLi4u3/q4uDgCAkw35o69vT1ubm75FlE2IpMi8bT3xN46/93j6rOrWXRikZmiqqQUBSI3wuIusHIAKHkQ9jO8/g806muyJJGeo+XEtRS2Rdx/QrRWdTyxtrLiw3WnyczVkp6jZcr601y8kUFow6p0DPShursDfZtVN7w6yx1DmTLqbC9btgyAd955h3feeYejR48yf/58hgwZwiuvvMKgQYOoWbNmscoMDQ3l0KFDhs+KonDkyBHGjx9vTKjCQugUHSk5Kahz1IY+DBqdhhURKxjYYCB7Y/YyZe8UXmj0Av0D+xc45lJ8RnyBc0Pcve/KiJUPLKNS02ng1K+wZw4knIY6HeCl3yAgpMQJIi9PIUadRdSNDC7eSM/3Gpeqf6S9iZ8boY0KntPD192BWc81Z87W8zw5dw8d6vvQ1t+bMzGp+Ps4l/APFaZkVLLYtWsXnTp1AvT9I5YsWcLPP/8MwKVLlxg2bBgqlYpp06Y9sFPd3cLDw+nWrRvnzp2jQYMGrFy5Emtra15++WUABg8ejFarZfny5caELsykeZXmqKxUTN03lUntJ6GgMPPwTC6pL9G5ZmfquNXB19mXXv697nuR3xu7l6fqP3XP+kf9HjXsu/Xq1geWUSnlpMGR72HvfEi9BoE9oM+nxWqPUGdqiLqpTwKXbmYY3l9OzCBbo++nYGejwt/bmXpVnXm6VU0CqjhTv6oL9au6PLDsPk2r06fpnbGkwn89wYhQ6fNiKYxKFqNGjSIsLIzvvvuOiIgIQkJCmDt3Lk8//bRhAqSLFy/ywgsvsG/fviKV2bZtW5YtW0ZYWJihB/fmzZsNHfKys7PRaDT59unfvz8xMTEAjBw5Eg8PD7Zu3VpuZuqrTKo5V2N6p+ksPLGQsA1htPNrR6tqrYhMiqSOWx1zh1cxpcXD/q/h0LeQmwFNB0L7EVCt4B9wmblaLt/M5NJNfRLQJ4Z0LidmkpRxp03B182BgCrOtKrjycDWtQjwcaZeFRdqeDoW+5HUHK2Ob3ZdolF1V0IaVOVsfBq21iq6NKxq1J8uTMeoZHHkyBESExMZNGgQgwcPpm7dugVul5CQUKxy+/Xrd985vH/88cd71q1Zs6ZY5Qvz6lG3Bz3q9jB8nvTvJF5/+PUH7hOdFs2xhGMAHL9xHGsr/Q8Baytr+gT0KbVYy71tU2HPLLC2g1avQLs3wb0mWl0e0TcziIxN5VJiBlduZnIpMYPLNzNISLvzgIm7oy3+Ps4E+DgTElSVurfe+/s4m7TNIDNHR3RSJj8fimaadSTPtK7FlCfvJLPd528Sq85mw4lYw+szrWtJu0UZMupMt2/fnl27dj2wG/yRI0cYM2aMMYcRFUiuLpdlp5cR5BVExxodOZ98HhuVDZ1rdn7gfrVca1HLVf+Is07R8Xi9x8siXPNKT4C98+D6YYg7CU7e8Mwy8C3GrJSxxyB0ArQchNbOnZ3nbvD1qr0cuJRk2MTVwQZ/H2fqeDvTzt+LurfeB/g44+lsZ/q/qwCeznZMf0Dnu46BPuwc2wWAwR0KnnBNlC6jkkVYWFih46UMHDjQmEOICiZTk8n19Ov8duE3vlR9Sb/Afox/5M7DC3tj9hKXEcfmy5vpV79fsdoc7t63pGVYjKgdELEeQsaBs7d+IqFP60FeMR8Xfe5HUnLy+O3odXaeu4Cbgw2PBnjzfNta1PZypq63E17OdpV+3CNROKPGhmrcuDHjxo2joCJsbW2pW7cubdq0wcbGsm8VZWwo4ymKQkxGDIfiDnEt7RrDWwwvtWMdiT9Cy2otS618s4s/A39+oH9C6XbHxXOb4czv8NS8YhWVkJqNg511hRnvSBSdRY0NlZWVxdChQwGoWlXfEJWQkICtrS1VqlQhISGBOnXqsH79eurVq2d0sMJyKIrC5dTLHIo/xOH4wxyOP0xcRhxWWNHbv3epHrtCJwrQzzb36Nt3EgWARx144qtiF1XVzcGEgYnKzKhk8c4776DT6RgxYoRhiI6cnBwWLFiAm5sbgwcPZvHixYwaNYrff//dJAEL89DoNEQkRXA04SjHbxznSPwRErMTUVmpaOTViJ51etKqWitaVmspc0DcoigKSRm5XE/J4npyFtdTstDlKbwR/IAfTsmX4coeeOGX/OurNoRrh6GmDHoozMOoZLFp0yb++uuvfOvs7e0ZOXIkvXv3ZsiQIbz++uvSJ6IcSspO4uSNkxy7cYyjCUc5dfMUOboc7K3tecjnIfoF9qN1tdY0r9ocZ9vK2WkqV5tHfGo211OyiLm1XE/JvpUcMolJySZLc2ceekdba0KCCpn7IfYEOPmA7X/uCA5+C+f/hrBVpfCXCFE4o5LFhQsXyM3Nxc4u/xMT2dnZnD171vDZ1lbqSy2ZRqchMimSEzdPcOKGfrmWfg0AbwdvWlRtwYgWI2hRtQWNvBpha13x/3vm5SnczMghNiWbWLU+CcSmZBGrziZGrU8MCWk53N1c5+FkSw0PR2p4ONK5QRVqeDhS09ORGh5O+Hk4FK0hWdFBZqJ+ylKnW3N9a3P1/SRaDYaL22H9SHhkGLR4Cewf3NFNCFMxKlm0a9eOzp0789Zbb+Hv74+VlRUXL15kwYIFtG/fHkVRWL58Obm5uYUXJsqENk/LJfUlTt08xenE05y+eZqzyWfR5GmwVdnSyLsRIbVCeLjKwzT1aUoNlxoV/kmZ349d53RsKnHqbH1ySM0iXp1jmDkN9L2S/dwd8PNwJMDHhU71ffDzcLxrccDJzgQPctR6RN9WsfE9fRuFkgd/T4Sb56BBT/CuB241oUl/SRSiTBn1r3vx4sWMGTOG1157Da1Wi6Io2NraMmTIED7//HPUajUnT57kww8/NFW8ohg0eRqiUqKISIogMimSM4lniEyKJEubhRVW+Lv708S7CX3r9eVhn4cJ8grCzrpsnqu3JN/uuURSRi7V3R2p7uFAyzqeVHd3wNfdgRoejlR3L+JdgSm4+UH/xbDzM1gcqh+vqU57fT8Lb3lIRJiPUcnipZdewtnZmcTERKKiolAUhfr16+PsfKcO+7PPPjM6SFG49Nx0zqec52zSWSKTIolIiuBC8gVy8/R3dXXc6tDIqxFda3elsXdjGnk1wsVOfpkCrH2zAypLmjGtyVP65bbfR0Dn980VjRCAkcli//797N69GxcXFx5+uORTH4qi0+ZpiU6L5kLKBc4ln+Ns0lnOJZ/jevp1AGysbAjwCKChV0OeqPcEDb0aEuQZJInhAcokUaQnwJl1EHtcPzXp/Whz4N+v9L2063eHhDP6oToa9Lj/PkKUAaOSRatWrfD3L7jr/Zo1a+jfv78xxVdqujwdMRkxRKVEcT7lPBdTLnIh5QJRKVGGuwUvBy+CPIPoVrsbDbwaEOQZhL+7v9mrkvLyFKysqPBtHYVSX4fIDRDxu/5xWCsVtB7y4H1yMyDlChxbCdYfQYsXoc/nd76/uF0/YuzptfrvpN1ClBGjenBv3LiRQ4cOMWTIEGrUyN8QGhoayrZt20wSZGkzZw/ubG02V9Ouckl9iSh1FJdS9K+XUy+To9MP6OZi60I9j3rU96hPoGcg9T3qU8+jHj6OPmUWp1aXR1JmLonpudxMzyExPZcbaTncTM/hRnoON9NzuXnrc2JGLtVc7fONK+RkZ42Xkx0eznZ4Otni6WyHp9Ot9052eDnb4elsh7uDrWVVCRVX4kV9coj4Qz+mk8oWAoKh0RPQ6PE7TzgJUcpMfV0zKlmoVPqJ9u73C1Kn0xW43tKUdrLQ5mmJzYjlaupVLqde5krqFS6r9a+xGbEo6P8TeDl44e/uT4B7gOE1wD0AX2dfk/9Kz8tTSM3WkJiRS1JGLom3LviG97deE9NzSczIJTkzl//+S3G2s8bH1R4fF3t8XOxuvdpTxVW/+LjYU/XWq6NdBR0uPk8H1w7BuU1w9k+4EQE2jvrpSBs9oX+CyUE6KYqyZ1HDfTRr1oxZs2bds15RFEaNGmVM0eVOtjab6+nXuZ5+nei0aK6mXuVq2lWi06K5nnYdraIfAM5WZUtt19rUda9LL/9e1HWrS133utR1q4ung2eJj6/R5ZGcmUtyhobEjBySMzQkZeh/5Sdn5BqSQtJd73V5+a/+KivwcrbH29kO71sX/4a+blRxvb3uTlLwdrEzzaOi5VFOGlzcpk8O5/+CzJv6EWEDe0DoeKjXFezK4eCFQjyAUf+3T5gwgeDg4AK/mz59ujFFW5xcXS5xGXHEZMQQmx5rSAzX069zLe0aN7JuGLa1U9nph9R2q0VwzWBqu9amlpt+iG0/Zz+sVQ/+lZ2rzSMlM5fkTI1hEvukDM2tZHBn/e3PiRm5pGXfOxqpjcoKT2c7vG9V+Xi52FG/qgtet9Z5u9jne+/hWM6rgEqLokBCBFzYol+u7gVdLlRpBC1fgga9oWbr/GM5CVHBGFUNBZCRkcHq1atJTk5m9OjR7N69myZNmuDpWfJfyWXt9u3a/kv7SVelE5sRS3xGPLEZsfoEkR7DjawbhuoiK6yo4lgFPxc/arrW1C8ud16rOFVBZaWvolMUhVxtHpm5OtRZGhLTc4hRZxOdnElsSjbJmbmoszSGu4KUzFwycu+tvlNZgYeTHR5Otvq6fyc7vJz1df9eTnb5Xr1v1f+7OdhII3NJZaXApZ1w4W+4sBVSr+url/w7Qf1u+rsIL5lXQVgui2qzOH36NKGhoWRlZeHr68u5c+eYN28ec+bMYdWqVbRo0cLoAMvC7ZPaaEEjrB2tsVXZ4uvsq1+cfPFz8buzOPvh6+yb74mjtGwNCak5xKqzuJqUxaWbGUTGpRIZl8aNu2Ydu83JzhoPR1vDxV+/3Gnsvf3+9quXsx1u5b3h19JpcyB6P0T9o59LIuaIvve0TwN9cqjfTd85ztbR3JEKUSQWlSx69erFoEGDCAsLo0uXLmzfvh2A8+fP8/bbb7N582ajAywLt0/q3qi91Petj5eDl+HOAOBGWjbXk7O4lpLFtWT9CKKx6ixSMjVk5Gqxs7HG3dEWD0db3G8tHk63X+0M72+vt7eR6gqz02n1fR4u74JL/8CVvaDN0rc9+Afre04HhICnzAsuyieLauDOzs4mLCwMyP9EVGBgYLkcDyopqQoH0jXkaGPQ6hQURUFlZYWLg/5CH+DjQovanrg52OBiL1U85YpOAzHH4MpuuLwbru6D3HSwddLfMYSO1yeJag+BSlVocUJUNkYlC7VajVarvWcmvJSUFOLj440KzBw6BlaRmfIqipw0/SOtV/fpG6SvHQJNBtg6Q+120GkM1O0Ifi2gEoyiK4SxjEoW3bp1o3v37owYMYK0tDR27txJZGQkc+fOpV+/fqaKUYgHUxRIuQrXDuqXq3v1A+8peeDoCbXaQfD7ULcTVG8myUGIEjCqzUKr1TJ+/HjmzJlDTo6+IdfBwYFRo0YxZcoUrK3LR928zMFdzuSkQczRW8nhsP41I0H/nWddqP2o/u6h9qPgHSjVSqJSsqgG7tuysrK4cOECoG+vcHAoX/P+SrKwYLmZEH9KnxyuH9G/3jwHKGDnCjVaQs02t5bW4Fx2Q6AIYcksqoH7NkdHR5o2bZpv3RdffMGYMWNMUbyoLLLVEHcK4k7opxeNO6HvDKfo9COv+jbV93NoP0KfGHwaSEc4IcqI0cnin3/+4dixY6SmpnL3TcrSpUslWYiC5eVBymWIPwPxpyH+pL6NIfmy/nsbB6jaGGq0gjav6u8eqjQCm8o3MZMQlsKoZPHOO++wePFiGjdujKura75HSVNSUoyNTZR3igLp8fq7gxtnIeG0PkEkROifTAJw9IJqTaBhX/2dg+/D+jsG60o67pQQFsqo/yP//PNPrl69SpUqVe75bsiQQsbtFxVHnk7/NFLiBX17wo1IfXK4EamvWgKwtocqDfT9GBo/CdUa69+7VAPpryKExTMqWTRq1KjARAHw5ZdfGlO0sDSKAhk3IekiJEXdSgzn9a+JF+HW3BvYOOjvDKo01A/PXaWhfvGsK+0LQpRjRj0NtWHDBiIiIggLC6N69eoy+VF5l6fTD5iXfPnWckWfGJIuQtIlyEm9s62rH/jU1ycG78A7791qyqOqQlgAi3p0ViY/Kmd0WkiL1VcZqaMhJRrUV/WvyZf16/JuD3VuBW5+4BWgH13Vq57+vXc9/V2CnbMZ/xAhRGEs6tFZmfzIgui0+o5pabH6uZ9TY/RzNauv6+8W1Nf13yl3JXAnb3CvBR61oFFffRLwqHvrtRbY2JvpjxFCWBqZ/MjSaXMgPeHWEn9rSYD0OEiL0yeFtDh9olDy7uxn46C/M3Crob8jqNtR/96jtn5xryl3B0KIIjNJD25TW7t2LVOnTsXR0RGVSsX8+fNp0qTJfbffvXs37733Hvb29uTk5PDZZ5/RqVOnIh+vTKuhtDmQmQSZifmXjJuQcePWcvt9wp2niW6zUoFzFXCpCq7V7yxut9/76tsNnLzkKSMhKjGzV0P5+/tjZWXFd999R0hIyD3fr169mg8++ID4+HgyMzOLHdCBAwcYNGgQhw4dIigoiO+//56ePXsSERGBq6vrPdtfuXKFxx57jHXr1hESEsI///xD3759OXHiBHXqlNJcBDqNfnyi7BT9xfz2knX7cwpkJd9ZMpP032UlQ27aveWpbPXDVDj76BOBR219RzTnKrcSQzVwraZ/dfKWp4qEEGWu2HcWd09yNHny5HyN2x999JHh/aOPPsrevXuLHdCAAQOwsbHhp59+AiAvLw8/Pz8mTJjA22+/fc/2Y8aMYffu3ezfv9+wrm3btnTu3JnPP/+8SMc0ZOCNH+Nmq4WcdP1cBzlp+tfsVP37nFT9e23W/QuzdwcHd3Dy1I946uip73jm6AmOHuDko7/gO3nrf/07eYO9q9wFCCFMyux3Fncnh7p16wIwY8YMwsPD77tdcWzdupUJEyYYPqtUKlq1asWWLVsKTBZbtmy5p8qpTZs2bNmypfgHP/gNuLnpL952LmDvAg4e+l/69m76xeHWq72rPik4uOuTgIO7fr386hdCVEBGNXC//PLLgH4cqEGDBhkdTGJiImq1Gl9f33zrfX19OXjwYIH7REVFMXDgwHu2j4qKuu9xcnJyDEOqg34SJ4DUIbv1yaIkNNwZwkIIIcwsNVXfL8pUzdImGYDHVNOL3m7jsLfP/8imvb39fds/MjMzi7U9wLRp05g8efI962vVqlXckIUQwqIlJibi7u5udDnFThaxsbEsX748X7aKi4u7Z92NGzeKHYyTkxNAvl/9tz/f/q6gfYqzPcC4ceMYPXq04XNeXh5JSUl4e3vLvNrFkJqaSq1atYiOjq7YnRlNSM5Zych5Kz61Wk3t2rXx8vIySXnFThZnz541VD/d7b/rSnLR9fb2xt3dnbi4uHzr4+LiCAgIKHCfgICAYm0P+juP/96NeHh4FDteoefm5ib/AxeTnLOSkfNWfCoTDb9T7FKCg4PJy8srdGnbtm2JAgoNDeXQoUOGz4qicOTIEbp161bg9l27ds23PcChQ4fuu70QQojiK3ay+PTTT4u0XUHDgBRFeHg4Gzdu5Ny5cwCsXLkSa2trw53L4MGDeemllwzbv/vuu0RERLBz504Adu3aRUREBCNGjCjR8YUQQtyr2NVQbdq0KdJ2jzzySLGDAX0fiWXLlhEWFmbowb1582ZDh7zs7Gw0Go1h+zp16rB+/Xref/997OzsyMnJYcOGDaXXIU8Y2NvbM3HixHuq9MT9yTkrGTlvxWfqc2aRw30IIYSwLDLxgBBCiEJJshBCCFEoSRZCCCEKJclCFElubi7jxo3DxsaGy5cv3/P9woULadmyJR06dOCxxx7j+vXrZR+kBVm9ejU9evSga9eutGnThgEDBtwzBI2cs/zWrVtH37596d69Ox07dqRVq1asXr36nu3kvN3fV199hZWVFTt27Mi33iTnTBGiEJcuXVLatWunDBo0SAGUS5cu5fv+119/VapVq6bEx8criqIokydPVpo3b67odDozRGsZbG1tlc2bNyuKoig6nU55+eWXlcDAQCUrK0tRFDlnBenZs6eybNkyw+fff/9dUalUyokTJwzr5Lzd3/Xr15XatWsrgLJ9+3bDelOdM0kWolAnT55Uzp8/r2zfvr3AZNGyZUtl7Nixhs8pKSmKjY2N8scff5RxpJbj6aefzvf54MGDCqDs2bNHURQ5ZwU5dOiQotFoDJ9TU1MVQFmzZo1hnZy3++vfv7+yYMGCe5KFqc6ZVEOJQj300EPUr1+/wO+Sk5M5cuRIvv437u7uNGjQoGTDxFcQP//8c77PDg4OgL46T85ZwVq1aoWNjb7rl0aj4bPPPqNx48Z0794dkH9rD/LHH39ga2tLr1698q035TmTZCGMcrsevqBh5R80THxls3fvXvz8/OjQoYOcs0IMHz6cKlWqsHXrVjZv3oyLiwsg/9buJyMjg/HjxzNz5sx7vjPlOZNkIYxSkmHlK5vb88LPmTMHW1tbOWeFmDdvHomJiXTt2pUOHToQGxsLyL+1+/nwww8ZNmwY1atXv+c7U54zSRbCKCUZVr6yeeONN3j66acZMGAAIOesKKytrZk0aRKKovDll18Cct4KcvToUfbv38+wYcMK/N6U50yShTDK7aHgiztMfGURHh6OjY0NU6dONayTc1aw3NzcfJ9VKhWBgYGcOXMGkPNWkPXr15OVlUVoaCghISE899xzAIwcOZKQkBDy8vIA05wzSRbCKJ6enrRo0SLfMPGpqamcO3eu0g8TP2PGDC5fvsyiRYuwsrLi8OHDHD58WM7ZfbRs2fKedbGxsfj5+QHyb60gH374IUeOHGHHjh3s2LGDVatWAfpRv3fs2EGbNm1Md85M9NSWqATu9+jsr7/+qvj6+ioJCQmKoijKxx9/XOmffV+wYIHSpEkT5d9//1UOHjyoHDx4UJk4caKyZMkSRVHknBXEyspKWb9+veHz8uXLFZVKpezatcuwTs7bg126dKnAfhamOGcmmYNbVGy5ubn06NGDlJQUAJ577jlq1apleDy0f//+JCQk0LNnTxwcHPD09OSPP/4w2Qxd5U1aWhrDhw8nLy+P9u3b5/tuyZIlgJyzgsyePZupU6cyffp0dDodVlZW/P7773Ts2NGwjZy3+xs5ciT79u0zvG/YsCGrVq0y2TmTIcqFEEIUStKxEEKIQkmyEEIIUShJFkIIIQolyUIIIUShJFkIIYQolCQLIYQQhZJkIYQQolCSLIQQQhRKkoUQQohCSbIQQghRKEkWQlRgiqJw/fr1Uik7NzeXhISEUilbWB5JFqJYsrKymDJlCp06daJLly60b9+ebt26MXfu3FK/cMyePZuGDRtSt27dUt3HVHbs2MHSpUvzrfvll19o3rw5VlZWpX789PR0nnzyyVKbctTKyooXX3yRPXv2lEr5wsKYbGxcUeFlZmYq7dq1U95//31Fo9EY1q9Zs0axtbVVJk6cWOoxLFmyRKlTp06p72MKEydOVIKDg+9Zf3uo99L26quvKl988UWpHuPatWtKvXr1lKSkpFI9jjA/ubMQRTZx4kRycnKYMWMGNjZ3Rrfv168fb775phkjE/8VERHB6tWr7zvdpqnUqFGDkJAQvvjii1I9jjA/SRaiSLRaLYsWLeLZZ58tsAplzJgx9O/fP181y4YNG3j88cfx8/PjqaeeAuDnn3+mffv2dOnShbZt2zJ69Oh88wNrtVrCw8N56KGH6Ny5M23atGHWrFkFxhQXF0fr1q1xc3MjJCSkyHXzGo2G999/n+bNmxMcHEyPHj04deoUkL+aaP369TzxxBMEBgYyYsSIfGWkp6cTFhaGv78/3bp148svv6Ru3bo0bNiQuXPn8uWXX7J06VKOHTtGSEgIISEhZGVl5SvjdvkNGjS4p3xj/frrr7Rr1y7fPMsPOrd3/91//PEHjz/+OP7+/kydOhW1Ws3QoUNp2bIlPXv2JDk5Od+xQkND+eWXX0wav7BA5r61EeXDyZMnFUBZt25dodverma5XS114cIFJSwsTFEURRkwYIChjNzcXKVXr17K5MmTDfuOGzdOadGihZKWlqYoiqLs3LlT8fT0NHx/d5VSRkaG0qtXL2X37t0PjOe/1VBjx45VOnfurGRnZyuKoigrVqxQqlSpoqSmpuaLf8aMGYqiKEp8fLxib2+vbNu2zVDG66+/rrRp00bJzMxUFEVRPv30U8Xa2towE56iFF4Ndbv8GzduKA4ODvnKN9Zjjz2mDBs2LN+6ws7t7bhuV12dPXtWsbKyUoYPH65kZGQoOp1Oad++vTJp0qR85e7bt08BlMTERJPFfz9qtbrUjyEKJncWokjUajUALi4uRd5n8ODBANSrV4+VK1cC8Pnnn9O3b18AbG1teeqpp9i0aROgbzyfOXMmw4cPNxynU6dODB8+/J6ys7OzefbZZ3nvvffo0KFDkWPKzMxk9uzZjBgxAnt7ewBeeOEFsrKyWL16db5tw8LCAKhatSqNGzfm2LFjgH4mvCVLlvDmm2/i6OgIwIgRI4rdaH27fB8fHxo1amQovyAajYYJEybw9ddfM3v2bHr06EFSUtJ9t4+Pj8fLy8vwuTjn9plnngGgQYMG+Pj44Ovri5OTEyqVivbt23P06NF823t4eBiOWdpiY2OZO3duqR9H3EuShSgST09PADIyMoq8T82aNe9Zl5GRwQsvvED79u0JCQlh5syZxMXFAXDhwgWys7OpX79+vn0+/vjjfJ81Gg0DBw5k27Zt+Pv7F+vvuHDhAjk5OUybNs1QPRQSEkK1atXuqV6pXr264b2rqyupqakAREVFodFoCAgIMHzv4OBA1apVixXL3eW7ubkZyi/Ia6+9RvXq1Rk2bBi9e/fm2LFjhv8mBVGr1fnalYp6bv8bl5OTU77Pzs7Ohh8Ot9na2gIYpt0tTUFBQXh7e/P222+Tm5tb6scTd8gc3KJIgoKC8PDwICIigscff7xI+1hbW+f7nJ6eTmhoKM8++ywrV65EpVKxdOlSJk2aBOj7BBRFQkICQ4cOJTU1lTfeeIO///67WH8L6O9wunTpUuT4raysDPHdfjX28df/np/7/f3Hjh1jzZo1LFy4EIATJ04QGhr6wON7eHig0WgKLbsocRUW5+3jPCh5Afz777/079+/yHHcT2ZmJmlpaVy9epW1a9feE58oHXJnIYrE2tqat956i59++qnAC0/fvn157733HlhGZGQkCQkJDBw40DBZ/N2/DgMDA3FwcODChQv59vv888/JzMw0fK5RowZPPfUU33zzDbt3776nL8OD3D7G2bNn862fO3cuO3fuLFIZ9evXx9bWlosXLxrWZWdn39PP5PbfePv7uy/exbFt2zY6duxoqDbbtm0bXbt2feAveV9f33zVVEU9tyVx+zjVqlV74Hbt27cnLi7O6GX+/PmMHTuWNWvWSKIoQ5IsRJF99NFHODk58cEHH6DVagH9r8yvvvqKM2fO8P777z9w/4CAABwdHdmyZQsAOp2OdevWGb53dHRk1KhRzJ8/31Dd9eeff7J27dp8T/XcFhgYyMSJExkzZkyROwTePsbcuXMN1U7nz59n9uzZNGnSpEhluLi4MGTIEBYsWGB4wmnBggX5qn0AqlSpYjjG6NGj+euvv4pU/n95eHgYLsTJycmsX7+ezp078+OPP953nw4dOuRLDMU9t8Vx4cIFmjRpUuidhSkcP36crKysex7fFmXAfG3rojzKyspSJk+erLRv314JDg5W2rVrpwwdOlS5evWqoiiKsmnTJqVZs2YKoAQHBys///xzvv3Xrl2rNGjQQGnbtq3y1FNPKYMHD1bs7e2V0NBQRVEURaPRKGPHjlUaN26sdO7cWXn88ccNZS9ZskQJCgpS7O3tleDgYEWr1SodOnRQACUwMFCZP3/+PfHOmjUr3z5paWmKRqNRwsPDlaCgIKVz585Kt27dlIMHDxYYf2JiovLKK68o7u7uSp06dZRPP/1UURRFSUtLU55//nmlbt26So8ePZTFixcrtWvXVlasWGE4dnx8vNKmTRulQ4cOSp8+fZTs7Owil3+3jIwM5ZVXXlF++OEHZenSpcrYsWOVGTNmKNu3b7/vf6dz584prq6uhiefCju3BcXVvXt3xd7eXgkKClJWrlypfPHFF0qdOnUUd3d35dlnnzWUO2jQoDLpkKko+nMhzMNKUYpRmSmEAPS/8N3c3AzVIHl5eTg7O7Nly5ZiPZ1Vmt59912qVq3K+PHjS+0YUVFR9O7dm4MHD+Lm5lZqxxHmJ9VQQpTA1KlTWbFiheHzN998Q+3atWnTpo0Zo8pvxowZnDx5kq1bt5ZK+bm5uQwbNowff/xREkUlIHcWQpTAn3/+yZQpU7Czs0Or1eLh4cHMmTMJDAw0d2j3uHHjBlWqVDF5uRqNhszMTNzd3U1etrA8kiyEEEIUSqqhhBBCFEqShRBCiEJJshBCCFEoSRZCCCEKJclCCCFEoSRZCCGEKJQkCyGEEIWSZCGEEKJQkiyEEEIUSpKFEEKIQv0/QBiQ9Rv2cgkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -620,7 +766,8 @@ } ], "source": [ - "weac.plot.err_modes(da, Gdif, kind=\"dif\")" + "pst_cut_right_plotter.plot_ERR_modes(pst_cut_right_analyzer, da, Gdif, kind=\"dif\")\n", + "# pst_cut_right_analyzer.print_call_stats()" ] }, { @@ -634,14 +781,13 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 58, "id": "b705ba41", "metadata": {}, "outputs": [], "source": [ "# Example with six segements, two skier loads (between\n", - "# segments 1 & 2 and 2 & 3) and a crack under segments\n", - "# 4 and 5\n", + "# segments 1 & 2 and 2 & 3) and a crack under segments 4 and 5\n", "\n", "# | |\n", "# v v\n", @@ -656,34 +802,55 @@ }, { "cell_type": "code", - "execution_count": 48, - "id": "85548ac0", + "execution_count": 59, + "id": "e971709d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Input\n", - "li = [5e3, 10e2, 25e2, 3e2, 3e2, 5e3] # Beam segment lengths (mm)\n", - "ki = [True, True, True, False, False, True] # Foundation (bedded/free = True/False)\n", - "mi = [80, 80, 0, 0, 0] # Skier weights [kg]\n", - "inclination = -20 # Slope inclination (Β°)\n", - "\n", - "# Obtain lists of segment lengths, locations of foundations,\n", - "# and position and magnitude of skier loads from inputs. If,\n", - "# in addition, a list k0 is passed to calc_segments, we may\n", - "# replace the 'crack' key by the 'nocrack' key to toggle\n", - "# between cracked (ki) and uncracked (k0) configurations.\n", - "seg_skiers = skiers_on_B.calc_segments(li=li, ki=ki, mi=mi)[\"crack\"]\n", - "\n", - "# Assemble system of linear equations and solve the\n", - "# boundary-value problem for free constants.\n", - "C_skiers = skiers_on_B.assemble_and_solve(phi=inclination, **seg_skiers)\n", - "\n", - "# Prepare the output by rasterizing the solution vector at all\n", - "# horizontal positions xsl (slab). The result is returned in the\n", - "# form of the ndarray z. Also provides xwl (weak layer) that only\n", - "# contains x-coordinates that are supported by a foundation.\n", - "xsl_skiers, z_skiers, xwl_skiers = skiers_on_B.rasterize_solution(\n", - " C=C_skiers, phi=inclination, **seg_skiers\n", + "# Skiers on B Profile\n", + "skiers_on_b_layers = load_dummy_profile(\"b\")\n", + "skiers_config = ScenarioConfig(\n", + " system=\"skiers\",\n", + " phi=-20,\n", + ")\n", + "skiers_segments = [\n", + " Segment(length=5e3, has_foundation=True, m=80),\n", + " Segment(length=10e2, has_foundation=True, m=80),\n", + " Segment(length=25e2, has_foundation=True, m=0),\n", + " Segment(length=3e2, has_foundation=False, m=0),\n", + " Segment(length=3e2, has_foundation=False, m=0),\n", + " Segment(length=5e3, has_foundation=True, m=0),\n", + "]\n", + "skiers_on_b_input = ModelInput(\n", + " scenario_config=skiers_config,\n", + " layers=skiers_on_b_layers,\n", + " segments=skiers_segments,\n", + ")\n", + "# Multiple skiers on slab with database profile B\n", + "skiers_on_B = SystemModel(\n", + " model_input=skiers_on_b_input,\n", + ")\n", + "\n", + "skiers_on_B_analyzer = Analyzer(skiers_on_B)\n", + "xsl_skiers, z_skiers, xwl_skiers = skiers_on_B_analyzer.rasterize_solution(\n", + " mode=\"cracked\"\n", + ")\n", + "\n", + "skiers_on_B_plotter = Plotter()\n", + "fig = skiers_on_B_plotter.plot_slab_profile(\n", + " weak_layers=skiers_on_B.weak_layer,\n", + " slabs=skiers_on_B.slab,\n", ")" ] }, @@ -697,15 +864,15 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 60, "id": "ebbb8ba1", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -713,14 +880,13 @@ } ], "source": [ - "weac.plot.deformed(\n", - " skiers_on_B,\n", - " xsl=xsl_skiers,\n", - " xwl=xwl_skiers,\n", - " z=z_skiers,\n", - " phi=inclination,\n", - " window=1e3,\n", + "fig = skiers_on_B_plotter.plot_deformed(\n", + " xsl_skiers,\n", + " xwl_skiers,\n", + " z_skiers,\n", + " skiers_on_B_analyzer,\n", " scale=200,\n", + " window=1e3,\n", " aspect=5,\n", " field=\"principal\",\n", ")" @@ -736,13 +902,13 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 61, "id": "01235a76", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAERCAYAAABowZDXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABTwUlEQVR4nO3deVxU1fsH8M8Mywz7vm+CICruCIoLIGqWZrm0aeZSv8o2zTXNvrmUXzPTzEpNyzWzslK/ama5JJkL4L4ggiwCyg4zwDAzzHB+f1wZQQaYGWaYAZ/368UL5t5z733ODDPP3HPuOZfHGGMghBBCmsE3dgCEEELaBkoYhBBCNEIJgxBCiEYoYRBCCNEIJQxCCCEaoYRBCCFEI5QwCCGEaMTc2AG0NTU1Nbh79y7s7OzA4/GMHQ4hhLQYYwzl5eXw9vYGn9/4eQQlDC3dvXsXfn5+xg6DkFZhaWmp9TZyudwAkZDWkJ2dDV9f30bXU8LQkp2dHQDuibW3tzdyNEQbe/bswbPPPttm9msKdPnw1yXJEOMSi8Xw8/NTfb41hhKGlmqboezt7SlhtDHW1tYGec0MtV9TIJPJtN5GIBAYIBLSGpprZqdOb0IIIRqhhEEIIUQjlDAIIYRohBIGIYQQjVDCII8MGjdDSMtQwiCPjKeeesrYIRDSptFltaTdSckrxy/ns3EqrRgZRRUAgC5e9lj4RBdEBlobOTpC2i5KGKTdSL4nxhdHU/HH9Ty42FhiaBd3jO/jA8aA3y7m4r1fr+DPWdGwMNPviXWfPn30uj9CTBUlDNLmlUnkWPnHTexOyIafsxU+faYHxvb2qZcYBgS7YNS6U/jlfA4mRPprfQzGGC7cKcWBy/dwMbsMxRUyuNkJMLSzOyYPCNJndYyCMYbCChlKKuUQmpvB39kafD71+ZD6KGGQNosxhl8v5OK/vyejWlmDZU+HYUKkv9oziDBvBzzdyxurjqRgaBd3uNsJNT7O6bQirDySgsvZZfC0F2JAsAuiglyQUyrBVyfSkFZQgbUv9NZn1VoFYwyJmaX4MfEO4m8VoajiwahuO4E5xof74v8G+sLNVvPnirRvPMYYM3YQbYlYLIaDgwNEIlG7nQ6iLcgoqsT7v13FmfRiPN3LG4tGdWk2CRRXyDBi7T8I87bHd1P6wryZpqmUvHKsOJyMv1MK0dvfETOGhiAmxK3eN+/tpzOx9MB1/D13CPxd2kb/SLm0Gvsu5uL7s3eQkl+OQFcbjAjzRC8/R3jYC1AhU+BsejF2nbsDS9Tgs+d6oF+gi8b7p6lB2h5NP9coYWiJEoZxyRU12BR/G+uOp8HDXoDlY7ojupObRttWVVUhIbsCL29LxKjuXlj1bA8IzM0alEsrKMf6v29j38Vc+Dtb473HO+Pxbp5qL8uVVisxaOVxDO3sgZXP9Ghx/Qwp+Z4Y35/Nwr6LuZAqajC8iwcm9Q/AgI4uapufiipkmPVDEs5nlWLtCz0R08ldo+NQwmh7KioqEB0djfj4eNja2jZajhKGlihhGE9iZgkW7b2K24WVeHVwEGYODYGVZcMP/MYcP34ccXFxOHz1Hmb8eBEBLjZ4I6Yj+gQ4oYYx3LgrxoHLd/FXcj487IR4I7YjJkT6w9K86TORLacy8NGhG/jfW4PQ3dehpdXUq3JpNQ5fzcNPSdk4n1UKD3sBXojwx4RIf3g6NN/UVF5Zhbl7LuP07WLseDkSXb2b/5+nhNF+UcLQEiWM1pdeWIGVf9zEkev56OnniBVju2v0wfWw3bt3Y8KECQCAm3liLP3fDZxJL65XJszbHi/1D8DYPj5qzz7UUShrMGrdKQgtzfDr9Khmm7oMTVqtxJnbxdh7MRdHrudBrqzBwI6ueLGfP4Z19dDqKjGZTAZptRJTtiagUCzDT6/3h1szTX+UMNovShhaooTRegrEUnx5PA0/JNyBp70Q80aE4qme3jpfvVM3YdTKE0mRUVQJBoaObrbwsNe+g1ckEiGtrAbPfXMG/zcoEAtHdtEpPl1VyBRIzS9HUmYp4lMLcS6jBHJFDYLdbTG+jy/G9PaGl4OVTvuund68oFyK5785Aw97K+x4ObLJsy5KGO0XXSVFTE5aQQU2x6dj78VcCC34mD8iFFMGdIDQQvPmJ015Ogg1apppyrlz5/DYY49h4ROd8fGhZPg4WWFyVAf9BFhHbWJIza9AakE5buVXIDW/HHdFUgCAwJyPfkEumD8iFNGd3BDibqu36VDc7YRYN6EPXvruHNYevYX5j3fWy35J20IJg5iESpkCh67ew8+J2UjKKoWbnQCzH+uEif38YS+0MHZ4TSou5pq1XhkUiDyRFB/uv467ZVLMHt6p2f4PdZpLDDwe4OdkjRB3WzzVywedPGwR4m6HEA9bgyTVWt19HDBrWCd8eiQFkYHOiA3VrBOctB+UMIjRiCTV+PtWAY4lF+Bocj6qqpUYFOyKdRN647GuHgb98DMEHo+HRaO6wNVOgM+OpODP63l4LToII8I84WTT8Lal5dJqpBVUIDW/Arfyy5FaoFli6OhuA2tL47x1J0cFICGjBIv2XsOvb0bB0163pi7SNlHCIK1GIlfg0p0yJGSW4MztYiRllUJZwxDmbY/pMR0xro8PfJ3axliGxvB4PEyP6YjBIa74/K9bWLj3Khb8dhXeDkLYCS1gbsaDtFqJArEM5TLF/W24xNDJg0sMIe626ORhh2B3W62uAmsNPB4Py8d2w/gNpzF/zxVsmRph9E5+0nooYRCDkMgVuJlXjut3xbhxV4wbd0W4flcMRQ2DvdAckYHOWPpUGIZ2cde5Q9aUhXk74NspESgol+LftCKkFVRAIleiWlkDSzMzeNgL4OkgREc3W3R0M73E0BRHa0userYnpm5NxIaTt/FOXIixQyKthBIG0RljDIXlMtwurERGUSXSCyu430WVyCyuBGOAOZ+HYHdbdPWyxzN9/RDZwRkh7raPzDxF7nZCjO3ta+ww9K6PvxPeHhKMdcdT0TfAGVEdNR8JTtRLKyhHsLudscNoEiUM0iSJXIHc0irklFYhu1SCnNIq5JRKcKdEgozCSlTKlQAAMz4Pfk5WCHS1QVxnd4R62qGrlz1CPGw1Hs9A2pb/GxSIxMwSvPfrFfz6ZhTNOdUC353KwPAuHgY/TnGFDL9eyMFr0R112p4SxiOMMQaxVIF8sRS5ZVWqZJBTWoWcEu53caVcVd6cz4OPkxV8nawQ5uWAJ3t4I8jVBkFutvB3ttbpiiDSdvH5PKwY1x3PbDiNt3ZdxLapEbAW6P6RwhjDrfwKXMsV4XZhBTKLK1FcIUdJpRylEjnKpYp65QXmfNgJLWBvZQE7oTnshRZwsbGEh70AbvZCeNgJ4GEvhLu9AK62Ar1Pa68v8bcK4WJj2SpzkbnYChAZ6IIdZzJ1uvS7zSeMvXv3Yvny5bCysgKfz8f69esRFhbWaPmamhqsXbsWixYtwuHDhxEbG9t6wbYiZQ1DcYUMeWIp7omkyK/9LZIiTyxF3v3fkvtnCACXELwduYQQ6mmHoV084OtkBV8na/g6WcHDXgizR6QpiWjG1VaADZPCMXVrIl7feR5fv9gHbhoO3GOMIatYgtO3i3H6dhHOphejqIL7guLtIESgmw28HITo6m0PZ2tL2ArNwb8/roQxBpmiBmJpNcqlCoirqiGWKnAzT4z4VBkKymVQ1jwYk8zjAS42lnCzE8LdTsD92AvgZiuAuz23zM1OAHc7Yav3J207nYnNk/u22vF6+Tlix5lMPNlDDmc1V+81pU0njISEBEyePBlJSUkIDQ3Fjh07MGLECCQnJ8POrmFbYGlpKZ555hl07NgRUqnUCBG3DGMM5TIFisplKKqQo6hCxv2Uy1BUKUdRuQyFFTLki6QoKJdBUecNY2HGg7udEF4OQng4CNHVyx6eDkJ42HPLvByt4EkJgeigi5c9Nk8Ox/TvL+D5TWfw8fjeiApyUTtoME8kxenbRTh9uxhnbhcjt6wKfB7Qw9cRz/X1w4COrujl7wjbFpypAEBNDUNxpRwF5VIUiGUoKJciXyxDvliKwnIZUgsqcPp2MQrLZZAra+ptaycwx4COLvimFT7Ek++J4enQ+u+74V088Mv5bK2bptp0wli5ciVGjhyJ0NBQAMCkSZMwf/58bN++HW+//XaD8pWVlVi5ciVcXV2xefPm1g5XrSq5EqUS7rS7TFKNEon8fkKo/eESQ3GFHIUVMsgV9f+5Lcx4cLERwMXWEq62AgS52mJgR1d4OAjhZS9UJQUXG8tHpqOZtL4evo746bX+mP/LFUzcfA6dPe0Q0cEZzjaWqKpWIr2wAtdyxcgTc1/UOnvaYUSYJwZ0dEFkkLPeB2fy+Ty43T9rCPNuvBxjDKKqahSWc2clBeVcQuGj6feKsobh+7NZuJIjwuSoAPT0c8Q9URXe/fESfno9SuM4/00rQs+HJqw8fjMfKw+nYEQ3T/g5cVcQ/nUjHzOGhuDGPTHAgPNZpVgxrjv+vlWgcdm67/9+QS7YsSvr0UoYx44dwwcffKB6zOfzER4ejqNHj6pNGL6+vvD19UVmZqbGx5DJZKr5dABuLil1GGOokCm4D/37ba61f5dJ5CiRyFEqqeb+rqz9LYfsoQQAcG2zrrYCuNoJ4GZria5e9txjW0u42HLtsW52XIJwsLLQ2/QPhLSEn7M1dv1fP5zJEuHg5Xs4l1EMUVU1rCzM4OdsjXF9fNDdxwGRgc5wsTWN+aZ4PB4crS3haG2JEA/Nr1D660Y+Rvf0RkJmCbJLJejp54h/UovgpeU0M3kiKTq41L/CLK6zBy5kleFqThlmD+8EADhyPQ8/JWbjozHdAABb/s1AakGFVmVDPR/Uz9nGEndKJFrFCrThhFFcXAyRSARPT896yz09PZGYmKi346xYsQJLly5tsPzdHy+iklmitE4iqFY2nMdRYM6Hsw33D+lsYwFHa0sEudrCydri/jJLOFpbwNnGEk7WlnCysYSNpRklAdIm8fk8xHX2QFxnw1/xY0wDg7kP+TO3i7Hq/n1QzqYXY1CIG6rkSqz/Ow39g1yQlFmKmcMaH6dSKVeqndHAjM9DN58HZx4OVpbo5mNf57EFSu5fkKJN2ZZqswlDIuGy48MzYwoEAtU6fVi4cCFmz56teiwWi+Hn54dKuRKerkJ08bK//0F/PwFY108AbWlAFiFEM3ZCC/zv8l1EdnBWTdNyLr0E80d0xtbTGQh2t8XAYFecTS/GufRi9AtSP07F2cYCoqpqtev4D31pfPixrmVrmZtp/6W0zSYMa2vuErS6zUW1j2vX6YNAIFA7XfPmyX1penNCHmH3yqoQ4Mp91qTklXP9ibaWWHcsFTtf6QcA8Ha0QvI9caMJI9jdFnfLqlot5lrVyhrY6DAfWZtNGC4uLnBwcEBeXl695Xl5eQgKCjJSVISQR8UT3bzwyR/JOHjlLgCgm48Dtp/OxLPhfqqrnpQ1DGZNjP+I6eSOBb9ewavRDz6z/k4pwPGbBQC4S2BFVdU4n1WCPHEVgtxscC1XjLSCCuw4k4nbhRUal3WzEyDYnbv96pWcMgzQYXR+m00YABAXF4ekpCTVY8YYLly4gEWLFhkxKkLIo8DfxRrrXwxXPX6yB3c51q5zWSi4fzXYnRIJYpu457yzjSVcbC1RUC6F+/07GcaGujeYOn5Mbx/V3+EBzpgyoIPq8aT+ARqXrXXiZiGe7NnE5WONMM2hjxpasGABfv/9d9y6dQsAsGvXLpiZmWHKlCkAgGnTpuGll14yZoiEkEfMmF4+uH5XjNO3i8AYQ/9GmqNqzRgagh2ns1opOm5a/eJKOXr5OWq9bZs+w4iMjMT27dsxceJE1UjvI0eOqAbtSaVSVFfX71AaN24c7t7lTiHfffddODo64tixYzAzo85pQkjL2QjMMecxbmzYgI6uzZb3crDCiDBPnLhZgCGdDXtTKsYYvjuVgbmPddJp+zadMABg7NixGDt2rNp1u3fvbrDst99+M3RIhBCile4PDd4zlFJJNSb1D9B5HIzeEgZjjMYOEEKICdN27qiH6aUPo7q6GmPHjkVNTcNRy4QQQtoHvSSM2bNn48CBA3R1EiGEtGMtThjr16/HwIEDYWtri27duuG7777TR1yEEEJMTIsSRnl5OYYNG4YXXngBNjY2ePHFFxEREdEmpw4nhBDStBZ1etvZ2TW470SPHj1aFBAhhBDT1KYH7hFCCGk9lDAIIeQRV1FRgT59+qCioqLJcpQwCCHkEVdTU4OLFy82OzSCEgYhhBCNUMIghBCiEUoYhBBCNEIJgxBCiEYoYRBCCNEIJQxCCCEaoYRBCCFEI5QwCCGEaIQSBiGEEI1QwiCEEKIRShiEEEI0oreEwRjT164IIYSYIL0ljN9++01fuyKEEGKC9JYwoqKi9LUrQgghJoj6MAghhGiEEgYhhBCNUMIghBCiEUoYhBBCNEIJgxBCiEYoYRBCCNGI3hJGeXk59u7di2vXrulrl4QQQkyIzglj0aJFcHV1xZkzZ1BVVYXIyEi89NJLiIqKwo4dO/QZIyGEEBOgc8I4fvw4bty4gaioKHz//fcoLi5GZmYm0tLSsH79en3GSAghxASY67qhtbU13N3dAQC7du3CtGnT4OrqqlpHCCGkfdE5YZSXlyMrKwuZmZk4deoUNmzYAABQKpWorKzUW4CEEEJMg85NUu+++y6Cg4MRFxeHSZMmoUuXLjh79izi4uLQrVs3fcZICGlDGGOorK6EVCE1digGlV6WbuwQWp3OZxgTJ07EkCFDkJ+fj169egEA/P39sWzZMnTu3Flf8TVr7969WL58OaysrMDn87F+/XqEhYU1Wv7UqVOYO3cuBAIBZDIZVq1ahcGDB7davIS0R9XKavye8TuOZB3B1dKrqFJUAQDcrdwR6BCIMNcwDPAegN7uvWFpZmnkaFtu542diPWLrbfs9/TfIVFIEGAfgAjPiHrrSqQl+F/a/zC129TWC9IAdE4YMpkMXl5e8PLyUi1zd3fH5cuX4ezsrJfgmpOQkIDJkycjKSkJoaGh2LFjB0aMGIHk5GTY2dk1KJ+VlYVRo0Zh//79iI2NxcmTJ/Hkk0/iypUrCAgIaJWYyaOhXF6Oa0XXkFeZB5lSBkWNAk5CJ3hYe8DPzg/u1u7g8XjGDlMvLhdcxtIzS3Gv8h76efXDmz3fhLu1O6prqnGn/A4yRBnYl7YPW65tgZW5FaK8ohDrF4to32i4WLkYO/x69qXtw5jgMU2WOZ17Gk5CJ/jZ+amWnbhzAhGeEXCzdsPRrKPIr8yHh42Har2z0BnhHuHYfXM3JnSeYKjwDU7nhPHEE0/g+PHj9ZYplUocPHgQ69evx4EDB1ocXHNWrlyJkSNHIjQ0FAAwadIkzJ8/H9u3b8fbb7/doPy6devQuXNnxMbGAgBiYmIQGhqKL7/8Ep999pnB4yXtE5//oGX3etF1bLqyCfG58VDUKAAAFnwLmPPNVd+6Ae4DJNQpFJ1dOqOrc1d0dekKXztf8HltZyytokaBTVc2YeeNnejh1gOrY1cj0CEQAoGgQdkaVoPU0lT8k/sPTmafxOLTiwEAPd16IsYvBkP8hiDIIcioSbRcXg5r8+Yv2Nl1cxfWDVnXYHlt7JZmlmrr0d2tO35M+RGl0lI4CZ1aHrAR6Jww1BEIBPj6668RHR2tz9026tixY/jggw9Uj/l8PsLDw3H06FG1CePo0aMNmp8iIiJw9OhRg8dKTFft3SJ1/bAaNGgQ5Eo5Pj//Ob5P/h6BDoGY23cuBngPgL+dP8z4ZgAASbUEeZI8ZIgykFKSguSSZBzOOIyt17YCAGwtbNHFpQu6OHdBV5eu6OLSBR3sO5hkEqmQV+CDfz9AUl4SpvecjkldJqnqqQ6fx0eocyhCnUPxf93/D8VVxYjPicfJnJPYdGUTvrjwBfzs/BDpGYmebj3Rw60HAh0CW7XuiXmJ6OvZt8kyKSUp8LD2aFDXIf5D8EfGH5ApZfC29Ya7tbva7WP9YrE/bX+bbZrSKmFs374d27dvBwBcunQJcXFxDcqUlpaq/Yahb8XFxRCJRPD09Ky33NPTE4mJiWq3SU9Px7PPPtugfHp6451XMpkMMplM9VgsFnPLlTLIlLLGNiNNMOOZwZyv1+8qGrGwsFD9nZSXhD239uB8/nkUVhWCDz48bTzR2703IjwjMMhnENys3TTar7OHM9469hbO55/HexHvYULnCWo/PK0trBHkEIQghyAM9R+qWl4iLUFycTKSS5Jxo/gGjt05hh03uMGvVuZWCHIIQohTCIIdgxHiFIIQxxC4Wrka7dv4vcp7mPP3HBRICvD5kM8btNdrwsXKBWNDxmJsyFjIlDKcu3cO8TnxuFBwAb+l/gYGBlsLW3Sw74AAhwAE2AfA19YXLkIXOFs5w0ngBDtLOwjMBE0mqsZUK6ux59YeXCm6gle7v4qOjh1RKi2Fs9AZe27twbWia1g6YGmD7c7dO4duruov6nk88PFmj9vXoy9+vPmjRglDrpSDoXVufa3pZ5lW79oOHTogJiYGAJCRkaH6uxafz4ebmxvGjx+vzW51IpFIAKBBchIIBKp16rbRpjwArFixAkuXNvzHifkpBmZW2v+jEo6VuRVsLWxha2kLOws7OAod4WHtAQ9rD3jaeCLAPgAdHTvCzpLri5JKpSgqKkJRUREKCwtRUlKCmpoajY9naWmJQYMGQSQT4aOzH+FI5hEEOgRiZNBI+Nr6QsmUuCO+g/P553Ew/SAAoI9HH4zoMALDA4bD1coVFRUVyM3NhVgsRk1NDQIDA+Hi6oLZf8/G5cLL+Gb4N+jj1geXL11Gampqs/FZWVnByckJTk5OCHAOQO+OvWHdnWsSEclEuFF8A7dKbyG1NBWppan4I+MPSJXclUeOAkcEOwY/SCL3E0rt8yWXy1FSUoK8vDzk5+ejtLRUdSaljdo6eHh4oH///kgVp2Lu33MhMBfg2xHfwkvghRMnTqC4uFi1Td0muubY2trCx8cHnbw7YVDkIPD5fFTIK3C9+DquFl1FljgLWeIsnLl7BiXSErX7MOebw8rMCgJzAcx43Hsy2DEYG4dvbPS4f2X9haeDn8ap3FPIr8xHR8eOqnWDvAfhzN0zarfLl+TD395f4/o9zEnohOzybI3KTvp9EpJLknU+ljaUVUqNymmVMGJiYlRJwt7eHrNmzdI+Mj2pHRxY99t/7ePGBg5aW1trVR4AFi5ciNmzZ6sei8Vi+Pn5YXH/xbC2owGKulDUKFBRXYEKeQXKq8tRWV2JkqoSXCu6hmOSY/U+GDxtPBHsGIwebj3Qy60XeoT1QC+LXjodt6iqCFP/mIoCSQE+GfwJRgaOVPstvUxahhPZJ3Ak6wg+TfgUK86tQLhHOEZ0GIEo7ygEhwSDx+MhtyIX/z33X5y+exobhm5QfdPu06cP+vTpo1OMtRwEDojyjkKU94NbHytrlMityOUSSFkq0srSkJCXgD239kDJuDe8p40nQhxDEOwUjHD3cPQN66u6ilEXdd8vJ3NO4sN/P0SwUzA+i/5M1Q4/ZMiQetu0tIXB1tIW/bz6oZ9Xv3rLqxRVKJWWokRaghJpCSrkFZApZZAqpZApuN81jEtwrlauTR5jsO9gVCmqkFKSgkivSOSU58DHzgcA9xz29+qvdjuJQgKBWcvqx4NmZ4Zv93obIrmoRcfSlKRcghfwQrPldG4XaCpZrF69GnPmzNF11xpxcXGBg4MD8vLy6i3Py8tDUFCQ2m2CgoK0Kg9w//zq3gBPBD0Be3t7HSInzZEqpMgSZ3EfiqVpSClNwc4bO7Fevp5rC3cKRYRnBCI8I9DHow/sLZt/HWRKGd48+iZEMhF2PrETQY6Nv+aOQkdVc4lIJsLxO8dxJOsIViashIJxHdl8Hh81rAbmfHPM6zsPA3wG6K3+jTHjm8Hf3h/+9v4YGvCgSUuulCNDlIHUMu5MJK0sDYfSD2Hrta0w55mju1t3RHlFYZDPIIS5hmndL6CsUeL75O+x8fJGxPrFYnHUYgjNhfquXrOszK1gZWsFb1vvFu/LztIOf976EwN8BsCcb46LBRcxosMIAFxiHOI3RO12TgIniOXiFh1b0ya0aL/W6QsGHjS1N6dFDcknT57EpUuXIBaL653ubtu2zeAJAwDi4uKQlJSkeswYw4ULF7Bo0SK15YcOHYrTp0/XW5aUlIRhw4YZNE6iHaG5UNVBWquG1SBDlIGLBRdxIf8C/sz6Eztu7ACfx0dn586I8IhAuEc4gp2C4W3jrXpTKmoUSClNwabLm5AuSsf3I79vMlk8zEHgUC953Ci+gXuV96CoUaj6PKzNjHumaWlm2eD5YowhuzwbZ++dxZm7Z7iEe3k9nIXOGOg9EIN8BmGgz0A4CBya3HduRS6WnVmGK4VXMCVsCl7r8ZpJdsLrQl4jV10VJVPKYGlmieTiZPB5/Eb7rwIdApFXmad2nSaqa6phY2Gj8/bGxmO6NGwCmDFjBjZv3oyuXbvCzs6u3qn95cuXUVKivr1RnxISEjBs2DAkJSWhU6dO+P7777FgwQLVOIxp06ZBoVBg586dALhxGD169MCBAwcQHR2Nf/75B6NGjcLVq1c1HochFovh4OAAkUhEZxhGxBhDTkUOkvKSkJiXiIS8BORL8gEAlnxLOFs5gwceSqQlkCllcBY6Y2G/hXi8Q/Mdk9o6cOAARo8erff96pOiRoHLhZdxKvcU/sn5BymlKeDz+Ojh2gODfAahi0sX+Nv5w8XKBTKlDKmlqfgr6y8cvHUQLkIXLI5ajN4evTU6Vmtc9KIPUoUUX138Cl62XkgvS0e4RzichE71mgEfViotxZLTS/BF3Bc6HfNSwSX8lfUX5kXM0zVsg9D0c03nM4w//vgDd+7cgZtbw0z88ssv67pbrURGRmL79u2YOHGiaqT3kSNHVIP2pFIpqqurVeUDAgJw8OBBzJs3D5aWlpDJZDh06BAN2muDeDwe/Oz84Gfnh7EhY8EYQ14ld8lqhjgDpdJS1LAaOAmd0Nm5M3q59wJTGOaKk4qKCoPsV5/M+eYI9whHuEc4ZvaZifzKfJzKPYVTuaew9fpWVFY3nP/N3dodU8OmYkLnCbC2aH/9dUJzIeZGzEVKSQq6u3ZHD7cezW7jJHSCk9AJRVVFzfaTqBOfE2+QLy2tReczjKeffhr79+9Xu66srAyOjo4tictk0RlG2/Xrr78a5Aq+3bt3Y8KEtjt6t4bVoEBSgCxxFkqlpbA0s4S/nT+CHINQLa9ufgcPaStnGLX2pu7Fk0FPwsLMovnCAPIq8/Bzys+Y0WeGVsepkFdg9fnVWBy1WJcwDUrTzzWdGyNfe+01fPbZZ7h7926Dy/XGjRun624JMRi5XG7sEEwSn8eNQenn1Q+PBz6OOP84BDsFt5u+iuZU11RrnCwA7iqqoQFDEZ8Tr/E2jDHsvLET7/R+R5cQTYbOTVK1bbbvvfee3oIhhJDW9lzoc1pvE+bS+ASn6pTJyvBc6HNwFrbOPHuGonPC6NmzJ9auXdtgOWPMqOMzCCHE1LTVuaMepnPC+OCDDxqM9K71ySef6BwQIYQQ06RzI+X48eNRWVmJrVu3Ys2aNQC4e02UlpZixIgReguQEEKIadA5YVy/fh1BQUGYOXMmNm7k5my5fPky+vfvj4sXL+otQEIIIaZB54QxZ84cfP755xCLxfDx4eZgeeutt3Dw4EEsWLBAbwESQggxDTonDKlUiokTJwKofx+BkJAQunyREELaIZ0ThkgkgkKhaLC8rKwM+fn5LQqKEEKI6dE5YQwbNgzDhw/Hb7/9hvLycsTHx2PTpk2Ijo7G2LFj9RkjIYQQE6DzZbUrVqzAokWL8OKLL0ImkyE2NhZCoRCzZs3CsmXL9BkjIYQQE6BzwjA3N8fKlSuxZMkSpKWlAeD6L4TC1p8nnxBCiOG1eLIYKysrdO/eHd27d1cli9rOcEIIIe2HzmcYIpEI69atw8WLFyESiepNQHjp0iV9xEYIIcSE6Jwwnn/+eVRUVGDAgAGwsal/B6nMzMyWxkUIIcTE6JwwCgsLcf78ebXr6D4RhBDS/ujch9G7d29IpVK167y8vHQOiBBCiGnS+QxjzZo1mD9/Pjw9PeHl5QUzMzPVuk8++QQvvPCCXgIkhBBiGnROGF999RW+/vpruLq6wtq6/v1+aaQ3IYS0PzonjO+++w43b95ESEhIg3U0vTkhhLQ/OvdhhIWFqU0WAPDTTz/pHBAhhBDTpHPCeO2117B27VrcvXu33hgMABg3blyLAyOEEGJadG6SeuqppwBw98UghBDS/umcMHr27Im1a9c2WM4Yw6xZs1oSEyGEEBOkc8L44IMPEBMTo3bdJ598onNAhBBCTJPOfRjjx49HZWUltm7dijVr1gAATp06hdLSUrpKihBC2iGdE8b169cRFBSEmTNnYuPGjQCAy5cvo3///rh48aLeAiSEEGIadE4Yc+bMweeffw6xWAwfHx8AwFtvvYWDBw9iwYIFeguQEEKIadA5YUilUtV9L3g8nmp5SEgI5HJ5yyMjhBBiUnROGCKRCAqFosHysrIymhqEEELaIZ0TxrBhwzB8+HD89ttvKC8vR3x8PDZt2oTo6GiMHTtWnzESQggxATpfVrtixQosWrQIL774ImQyGWJjYyEUCjFr1iwsW7ZMnzESQggxATonDHNzc6xcuRJLlixBWloaAK7/ova+3oQQQtoXnRNGLSsrK3Tv3h0AGr2hEiGEkLZP5z6ML774Aq6urli8eLFq2ddff43BgwcjNzdXL8ERQggxHTqfYezatQv79u3DoEGDVMvmzJmDsLAwvPXWW9i3b58+4iOEkLavMAVwCzV2FC2m8xmGtbV1vWRR6/HHH4dIJGpRUJqQy+WYOXMmwsPDER4ejhkzZmg0/iMvLw+jR49Ghw4dDB4jIXrHGFBRCNy7AuRdBSQlxo6INOfMesDM0vDHqSwC/l1n0EPofIZRXFyMqqoqWFlZ1VsukUhQWFjY4sCaM3fuXNy4cQMJCQkAuEQ1b948fPHFF41u8+eff2LhwoXw8PAweHyE6NW9y0DSVuDWH0D5vfrrnDsCXZ8GIv4PcPAxTnxEvbRjgI0r4Bxo+GPZuAIBA4GEzUDkqwY5hM4JY9SoURg8eDDefvttdOzYEQCQlpaG9evXY/To0XoLUJ3i4mJs3LgR+/fvh5mZGQBg1qxZGDNmDBYvXgxnZ2e125mbm+Pvv//G6tWrcePGDYPGSO6TSwDxXUCcw/0W5QKVhYC8EqiuBMwEgKUN98/u2gkIGADYexs7atNRlg0cWQgkHwDsfYBu4wG/SMDeFwADyrKAjHgg8Vvg7Hpg8Bxg0GzArMXXs5iO0izg9jEg7xpQkc/9gAeYCwChA/f/Yu8DOPgCjv6AUwfAxg2oMwOF0Zz7Bpiwu/WO5xsOJG4GKscBNi56373O/1XLly8Hn8/Hm2++CZlMBsZYq43DiI+PR3V1NSIiIlTLIiIiUF1djfj4eIwZM0btdnFxcQaN65GhkAMyMSAVcT+VhVwyKL93/3fe/b9zgarS+ttauwK2HoDAFrCw4vYlr6jzQQDApy/3bbn7s+3rg09bN/4H7H+bS6hjvwG6PdPw+fDtyyWRxz4G4j8D/l4BZP4DPLcTsHI0Sth6k3kKOLmSS4g8M8CtM5ccXDsB4AEKKSAtAzL+4f7XZOIH21pYAyGPAc9tN1b0XIKz9wb4Zq173NAngEu7gIEz9L5rnd+NZmZm+O9//4sPP/wQaWlpYIy12jiM9PR0mJubw9XVVbXMzc0NZmZmSE9P1+uxZDIZZDKZ6rFYfP+f8uAcwNqCa1MG0/E39Ld9i/aF5suxGu6sQCoCFFUNnygen0sEdl7cm8S///1vfr7cbwcfwM4bsGji/6OyCEj/G7j8I7BvOnDqc+Dpr7hv1I+aM18DR97nmppGr2v+w19gBwxfCgQPA36aBOx4Gpi8D7Byao1o9UtWDvyxALj4PeDVExi7Ceg8kqtjU6Qi7oysNJP7UVa3PBalAkjaAuQkAP3fAHzCgbSjQOpfwBMrgYOzuETW7/WG22acBHz61F926whwdAnQZTTgGMAtS/kdiJ4H5F/j3mvZ57jXPO0vzcvy63RHBwzimqWaSxgnVwKiHG4/Es3m/2vx1zehUIhu3brVWzZ8+HD89ddfLd11oyQSCSwtG3YiWVpaQiKR6PVYK1aswNKlSxuuKE4FJBb3T3t5jfxGM+vV/ObzW7Z9g99o4fZ14rC0A4T2XDOA4P5voT13+m/j3vKzARtXoPsz3M/dS8Ch2cCWx4HHVwCRr5lGE0NrOLuBSxYD3wWGLdGu3oGDgakHge2jgZ8nA5N+A8wsDBWp/lUUAN+PB0rSgae+BHq/pHn9hQ6ApwPg2a35spq6eQDo8Sz34V92h0sYKYcBlxBufego4G4jt3MQ3wU6PHRhUKcRQHYCt82Q97llyQeAizuBUau5x+c2AoU3tSvr0fXBMWxcuITZnKLbQAk36BpVyubLowUJo7q6GitXrsThw4eRl5cHVvuNF9yVSLpYsmSJ+g/nOhITE2Ftba32iii5XA5ra2udjt2YhQsXYvbs2arHYrEYfn5+wJT/Afb2ej0WqcO7F/Dyn8BfHwKH53NNW7GPwLT5yQe4b9cDZmifLGp5dueapHaO4b6hjliu5yANpKoU2P4U9/vlI/r94Ffn7Aauf6QxHQYCQUOAGiWQdRoY/y23POMfrskUANw6Nb69vAIwV3NGzTfnzpxqWTnVfyx0BCTF2petR4P/m/GbHvwtFgMzHZrdROeEsWDBAiQnJ2PKlCn4/PPPsWDBAsjlcuzfv1/nvoK5c+di+vTpTZZxdXVFdnY2FAoFioqKVM1ShYWFUCqVCAoK0unYjREIBBAIBHrdJ9GQmTnw+H+5b0zHlnFvFnWn/u1F4S1g73SuGWr4spadUQUO5hLOn/8BQkdyH36mrEYJ/PQSUJEHvPIX4Bpi+GP2f0Ozcpd2A0GxXJ+bpASoKgHcu3DrchK551cdaxeuj0UdnlnTj3UtW8tA/SY6J4x///0X//77L8zMzPDjjz9iypQpAICXX34Zzz33nE77tLW1ha2tbbPloqOjYWFhgaSkJDz++OMAgKSkJFhYWCA6OlqnYxMTNngOUFkM/LEQcO/KfRi2N8pqYO9rXH/P0+v10/zW/03g5u/A/94G3jzLXVVkqv5ZDWT9C0z+X+skC21IigBHP+7vwpQHV/HV1HD9LRZW6rdzDeX6CFqbspq7qMQAdB64Z2Njo7qktW7zkJmZGe7evdvyyJrg4uKC6dOnY82aNVAqlaipqcHatWsxffp01SW1hYWF8PPzw6FDhwwaC2klw5dxl9z+9hrXudnenFrLDcYb+43+3ux8M+DJNVyzS8Km5ssby70rwN+fcF8MTPHLQPdnuf6Lyz8BomzAP4rrkD+/Beg6pvHtgocBd87WX5Z6lBtLc+sP4NafwJWfgeyzwJWfgDvngHObuD6JhE1A4nealy289eAYuReAwBiDPBU6n2FIpVIcOnQII0eOhL+/P2bNmoVnnnkGR48eRVlZmR5DVG/VqlWYN28eIiO5K2gGDBiAVatWqdbX1NSgqqoK1dUPrpRISEjA/PnzkZmZiby8PMTGxmL48OFYtGiRweMlLWRmDozZAKyPAo4s4q6eai9KM4F/PgMGvNPwqpqWcu8C9J0GnPwU6PUiYK1+jJLRMMb1UbkEAzHvGTsa9ew8gWe3PXjcQ8MWFBsXrlmqPB+wuz9YOGQY91NX3f359wP6vfbgccQrmpetlfonEDZOsxi1xXT0888/s2eeeYZlZWWx69evMw8PD8bj8ZiNjQ3bv3+/rrs1eSKRiAFgIpHI2KE8mhI2M7bYnrHsJK03/eGHHwwQkB72++OLjK3uwpi0XD8BPaw8n7GPPBg7sULrTaVSqdY/Wrn6C/d6ph3XOrY2oSyHsaPLWu94VSLG/jdD6800/VzTuUnq2WefxZ49e+Dv74+uXbvi9u3bSExMRHZ2Np566in9ZTRC6gqfBriHAX8uejAWpS3LSeKujBr6ocHanWHrDoRP5UaCS8XNFm81NUrg75Vc003HIcaOxjAcfIAuT3JNSobGGPcax/3HYIfQOWE8zMbGBuHh4XByctL7WAhCVPhmwGMfAXfOcIOn2rpjywC3Llw7uSENeIcbeHnpB8MeRxs39gFFKUBMO79c2rs30Okxwx9HUgL0fYUbz2QgeksYdT355JOG2C0hnI5xgG8k1+7fls8yshO4AWFDFhp++ggHH27EcOJm7uoeY2MMOP0ld7mqX0SzxYkGbFwAWzeDHkKrTm9NxzjoOnCPEI3weED0XOCH57j5hkzxyhpNnFrLjRjubNjJOlUiXgW2jQQy/uaSrjHlnudGME/4ybhxEK1olTAEAgEWLGj69JExhpUrV7YoKEKaFfIYNybj3Ma2mTCKUoGUQ8BTX9WfB8iQAgZw8x5d2Gn8hJGwiZtVNmS4ceMgWtEqYbzxxhuqAXpNUU3QR4ih8Hjc9Ay/z+UmnKsdWNVWnN8GWDlrfommPvB4QM8J3Iy2UhE395IxVJUB1/dx8yO19kyupEW0+mozY0bD2Q+VSiUyMjKQmZmJmvtto+rKEaJ3PZ4HLG2B81uNHYl2FDKu87nXxNYffd3jOe74N/a37nHrurEfqKnmXj/Spuh8LiyTyTB//nw4OjoiODgYHTt2hIODA957771604ETYjACW+4D8NIP3CWabUXyAW4+oj7Nn63rnb03EBTDjRo2lss/cp3d9l7Gi4HoROeR3q+//jouXLiA//73v+jYsSMYY7h9+za+++47FBYWYsuWLfqMkxD1ek7k7jaXcdL47fKaOr+Nu5VmUzOdGlLXMdzU8ZXFBrkrW5PKsoE7p7kpUEibo3PCOHnyJK5fv95gOvGXX34ZPXr0aHFghGjEpw93B7ZLu9tGwii+zd0Rb9xm48XQ+Unuxj8ph4A+k1v32DcPAmaWjc/wSkyazk1SwcHBau89YWtri06dHnxzouYpYlA8HtcWfvMgd/9wU3dhB3cPgy5GnA3B1o27Yir5QOsf+8b/uHtMCOleMm2Rzglj5MiRWLNmTb2ZauVyOdatW1dvevMnnniiZRES0pywsUC1hJt0zZTV1ABXf+HuKNjUrWpbQ5fR3O1wZRWtd8yKAm6EfpdWGndC9E7nJql169YhJycHCxcuhIeHBxhjKCgogLm5OTw8PPDxxx8DoEF8pBW4dOTuMndjHxA2xtjRNC43CRDnGG4mUW2EPMbd2S8jnrtfdmu49Qf3O5S+RLZVOicMoVCIb7/9tskyNIiPtJqwsUD8Z1yzlKV+b9OrN9f3AraegH9/Y0fCJVnnjkDqkdZLGKl/Ar4RBp3riBiWzgmDBvERk9J5NDeRX0Y8EPq4saNpqKaGG6zW9WnTGawW8hiQ/D9uXid93OGvKcpqIP0kNwkiabN07sN4eHBeeXk59u7di2vXrjVZjhCDcA3hppow1X6M7HNA+V3uTMhUhAwDxLlAQbLhj5V9DpCJuanMSZulc8JYtGgRXF1dcebMGVRVVSEyMhIvvfQSoqKisGPHDn3GSEjzeDwgZASXMExxBtvrewE7b8Cvn7EjecB/AMC34CZwNLS0o4C1K+DVy/DHIgajc8I4fvw4bty4gaioKHz//fcoLi5GZmYm0tLSsH79en3GSIhmQh7j7rlceNPYkdRXo+Smwwgb03oTDWrC0hrw7Qtkxhv+WOknudHdplR/ojWdXz1ra2u4u7sDAHbt2oVp06bB1dUVHh4easdnEGJwHQYB5lbArSPGjqS+nCSgIo/rvzA1HQYBmf8a9h4ZVWXAvUtAYLThjkFahc4Jo7y8HFlZWTh58iROnTqFqVOnAuAmI6ysrNRXfIRozkLIzZNkav0YKb9zzTG+JnijoA6DuXmtCm4Y7hhZpwFWw702pE3TOWG8++67CA4ORlxcHCZNmoQuXbrg7NmziIuLQ7du3fQZIyGaC3kMuHOW+1ZrKlIOA51GmM7VUXX5RXJTdRiyHyMjHnD05y5KIG2azglj4sSJyMrKwvnz57Ft2zYAgL+/P5YtW4ZXXnlFX/ERop2QxwCmBG4fN3YknOLb3H2rTXWwmoUVd+aT+Y/hjpF5ijuTIW1ei3qgvL290atXr3qPY2Ji8MEHH7Q0LkJ04+jH3Ykv7ZixI+Hc+oP7Bh80xNiRNK7DIO5D3RD9GLIKoOA6dyZD2jytEsa4ceMwZ84cbkM+H2ZmZmp/Tp48aZBgCdFIYAzXDGIKUg5z8QhsjR1J4zoMBqRlQP61Zotq7d4lrv/CFPtviNa0GukdExMDDw8PAEDPnj2xdu3aBmUYY5g1a5ZegiNEJ4HRwLkNQGmmcdvNq0q5Dt+RnxovBk34RgBmAu4sw0vPtybISeTuiujWWb/7JUahVcKYOXOm6u/58+cjJkb9VQ/z589vWVSEtETAAIDH584yjJkw0o5x/SmdTLT/opaFkBuPkfUvEPWmfvedkwR49zbNDn+iNZ37MF544QXcvHkTZ8+eRUpKClid0bUTJkzQS3CE6MTKEfDqafxmqZTfuTgcfIwbhyZ8I7gPd32OkmeM2yc1R7UbWicMuVyOBQsWwNnZGWFhYRg4cCC6du0KFxcXfPDBB6iurjZEnIRoJzCaSxi6fgAy1rIPT2U1kHrU9M8uavlFcoMLRdn626c4l9unb1/97ZMYlVZNUgqFAiNGjEBKSgreeOMNREREwN7eHiKRCAkJCdiyZQsSEhLwxx9/gE9TABBjCowG/v0CKErV7t7Z1VXA8Y+Ba79yU6UHxQBPrATsvbU7ftZpQCYy3ctpH1Z7FpCTyI2Z0IecRO63DyWM9kKrhLFp0yYoFArcvHkT9vb1b7E4btw4LFy4EKNHj8bmzZvx+uuv6zVQQrTiHwXwzYGMk5onjMpiYMdT3NiJvi8DVk5A0nfAhoHA1EOAR1fNj59ymJts0KunbvG3Nlt3wDEAyE4Euo3Xzz5zkgAHf8DOQz/7I0an1WnAjz/+iJ07dzZIFrUcHBywbds2fP/993oJjhCdWdpw32w17ceolgI/TgQq8oFXjwGP/xeImQdM/5c7u/hxAiAp0WxfjHH9F6GPG/4+E/rkFwnkJOhvfzlJ1BzVzmiVMBQKBTp06NBkmaCgICiVypbERIh+BEZrPiAt/lPg7gVgwo+AR9iD5TYuwAs/cFON/PkfzY6bdxUoywI6P6lT2EbjGwncu8Ilz5ZSVnNjMChhtCtaJQyhULMb12tajhCDCoy+P7He9abLFd4C/l0HDJqt/gPOKQAYthi49D3XZNOc5AOA0KHtTYfh2xeoqQbuXW75vvKvAQopXSHVzmjVh3Hv3j3s3Lmz3iW06uTl5bUoKEL0onZAWkY84NldfRnGgN/nAA6+wKAmBpz2mQIkbQWOLgam/d70cZMPcFdHmVvqHrsxeHbnpofPSQD8W3ijp5wk7uZMnnoeCEiMSquEkZKSotF9vHltqd2WtF8WQu6DL+MfIOot2NjYNCxz7Vcuobz4K1e+MXwzIHYB18+RdZobHKhOURpQmAzELdJPHVqTmQU3yC5Hg7Oo5uQkcQmoqeeUtDlaNUnFxMSgpqam2Z/oaLpRCjERgdHcCGalQjWtjYpUBBx5n7uxUYgG95ru9ATgHgb8s7rxMjcPcN/SOw5tWdzG4ttXs2a35uRSh3d7pFXC+PRTzebE0bRcS8jlcsycORPh4eEIDw/HjBkzIJfLGy0vkUiwZs0aREdHY8iQIejTpw9mz56NiooKg8dKjCgwBpCJgXuXGyaME//lZlMdsUKzffH5wIB3uPtTF99WXyb5AJd8LNvoXSf9IoHyu4AoV/d9SEqA4jTqv2iHtEoYERGa/QNoWq4l5s6di+vXryMhIQEJCQlITk7GvHnzGi1/4cIFrFy5Ej/88ANOnDiBEydO4K+//sKbb+p57hxiWrx7AxY2QGa86pbCALiO3YRNwJCF2k3dETaGG59xflvDdaJcIPc80Hl0S6M2ntpBdrlJuu8j98L9fYW3PB5iUtrkcOzi4mJs3LgRc+bMUU2pPmvWLGzYsAElJeqvlbezs8OMGTPg6+sLgBszMmXKFOzZs4cuA27PzCy4/oaM+Af3mq+pAQ7O5mZQ7Tddu/1ZWAG9XgQufg8oZADwYFaDKz8B5kJu/EVbZe8F2PtyfRC6ykkErJwB5yD9xUVMQptMGPHx8aiurq53JhMREYHq6mrEx6sfqNWzZ08sWlS/I1IoFEKpVKLGEDeOIaYjMJq7bavifpPlqTXcmcCo1VxC0Vb4VO5y3Rv7AYD7EsIYcGkX0OUp7pLatsw3vGUJo7b/gi5+aXfaZMJIT0+Hubk5XF1dVcvc3NxgZmaG9PR0jfdz5swZPP3007CwaPxDQyaTQSwW1/shbUxgNFAt4ZLEtV+BE8uB6HmNX+nUHNcQbp9JWwAAAwcOBLITuHb73i/qMXAj8enLDbpTKrTflmaobdfaZMKQSCSwtGx4jbulpSUkEolG+7h58yaOHDmCVatWNVluxYoVcHBwUP34+fnpFDMxIs/ugNAR2P088MvLQNcx3CWyLdH3ZeDOGSD/Bvf49DrAKRDo0A6uEPSN4BJswQ3tty3J4O7eR/0X7ZJJJYwlS5aAx+M1+ZOUlARra2u1V0TJ5fIH7dRNKC8vx4QJE7Bjx45mpzpZuHAhRCKR6ic7W4/TP5PWwTcDJuwG+r8JjPsWeGZLy2/oEzoKsHEDLuwA8q4BNw8C0XO5K6naOq+eAM9Mt45v6vBu17QauGdoc+fOxfTpTXdCurq6Ijs7GwqFAkVFRapmqcLCQiiVSgQFNd3RJpVKMWbMGLz77rsYOXJkszEJBAIIBALNK0FMU8AASNx6afSFQiPmlkDPCcDFnUDeFW6m1x7P62ffxmZpzc2nlZMEdNeyie3eBcA1lLuJFWl3TOrrkK2tLTw9PZv8MTc3R3R0NCwsLJCU9OAbUFJSEiwsLJocNKhQKPDcc89h3LhxqhHre/bsQWlpqcHrRoxv//79+t1hnyncfbtzEoGxG3XrQDdVtXfg01buBRqw146ZVMLQlIuLC6ZPn441a9aornJau3Ytpk+fDmdnZwDcGYefnx8OHToEAKipqcGUKVNgY2ODfv36ISkpCUlJSdixYwdEIpExq0PaKtdgIGYB8Ox23TvQTZVvX6AoBajS4r0hrwIKkilhtGMm1SSljVWrVmHevHmIjIwEAAwYMKBeB3ZNTQ2qqqpUt4w9fPgwfvjhBwDcfT3q+vLLL1spatLuDFkImUyGdtdoWTuAL+8SN1peE/lXAaagO+y1Y202YQgEAqxbt67R9R4eHigqKlI9HjVqVLOz7BKii7179+KFF14wdhj65RLMjSfJvaR5wrh7ETC3Bty1uDMhaVPaZJMUIaakXX4R4fO5K53uXdR8m9zzgFcPwKzNfg8lzaCEQQhRz6cv14mtSUJkjEsYPn0MHxcxGkoYhBD1fCOAqmKg7E7zZcuygIo8wK+/4eMiRkMJgxCiXu3gu7saNEtlnwPAow7vdo4SBiFEPRsXbrqT3PPNl71zjuvstmrjEy+SJlHCIIQ0zj8KyPyn+XJ3zgD+1BzV3lHCIIQ0LjAaKE4FxHcbL1OSAYjuAAGDWi8uYhSUMAghjeswCACv6bOMtKMAX3C/LGnPKGEQQhpn5QR49gRun2i8zO3jQEBU272POdEYJQxCSNNCHwfSjgFyNfeaqRJxdzPsGNf6cZFWRwmDENK0Lk8BCgmQ+mfDdcn7AaYEujzZ+nGRVkcJgxDSNKcAwKs3cP23huuu/AwEDQFsPVo/LtLqKGEQQprX5yXg9rEHt6QFuGlD7l0EejxnvLhIq6KEQQhpXtg4wMEfiF/FzRvFGHB0KeAeBnR63NjRkVZC00oSQppnZgEMWQTsex344z2gWgbcTQIm/tzy+6OTNoMSBiFEM12eBCqWAceXAzwe8OQ6IGCgsaMirYgSBiFEcxGvAOHTAKUcsBAaOxrSyihhEEK0w+cDfEoWjyLq9CaEEKIRShiEEEI0QgmDEEKIRihhEEII0QglDEIIIRqhhEEIIUQjdFmtlhhjAACxWGzkSIi2JBKJQV43Q+3XFMjlcq23kclkBoiEGFLt/2/t51tjeKy5EqSe9PR0dOzY0dhhEEKI3mVnZ8PX17fR9XSGoSVnZ2cAwJ07d+Dg4GDkaPRLLBbDz88P2dnZsLe3N3Y4ekV1a5uobq2DMYby8nJ4e3s3WY4Shpb4fK7bx8HBwegvsqHY29tT3dogqlvbZCp10+QLMHV6E0II0QglDEIIIRqhhKElgUCAxYsXQyAQGDsUvaO6tU1Ut7apLdaNrpIihBCiETrDIIQQohFKGIQQQjRCCYMQQohGaByGFvbu3Yvly5fDysoKfD4f69evR1hYmLHDatLPP/+Mb7/9FkqlEmKxGP7+/li1ahWCgoIAAFOnTsXNmzchFD64g1poaCi++eYb1WPGGD766CPs27cP5ubm6NSpE77++mujD1xcsmQJ9u3bB0dHR9UyBwcH7N+/X/X4m2++wTfffAMrKys4Ojpi06ZN8PHxUa031bp17twZnp6e9Zbl5OTA29sb8fHxbe51k8vlWLx4MVatWoW0tDR06NCh3np9vE5yuRzz5s3DqVOnAAADBw7EZ599BktLS6PUTaFQYNu2bdi1axd4PB5EIhF69uyJTz75BO7u7qrtY2NjG+wzJiYGS5cuNXrdGmBEI+fOnWO2trbs5s2bjDHGtm/fznx8fJhYLDZyZE2zsLBgR44cYYwxplQq2ZQpU1hISAirqqpijDE2ZcoUlpGR0eQ+Vq9ezcLCwlhlZSVjjLFp06axp556yqBxa2Lx4sXsxIkTja7/9ddfmYeHB8vPz2eMMbZ06VLWq1cvplQqVWVMtW4xMTENlo0fP5599dVXjLG29bplZGSw/v37s8mTJzMADeLW1+v0zjvvsKFDhzKFQsEUCgUbNmwYmzFjhtHqlp2dzYRCIbt8+TJjjDGpVMqGDRvGBg8eXG8f6l7rhxmjbupQwtDQuHHj2HPPPad6rFQqmYeHB/vyyy+NGFXznnnmmXqPExMTGQD277//Msaa/+BRKBTMzc2NrV+/XrXs+vXrDAC7evWqQWLWVHMJo0+fPmz+/Pmqx2VlZczc3JwdOHCAMWbadUtPT6/3uLi4mNnb27OSkhLGWNt63a5evcpSU1PZiRMn1CYMfbxORUVFzMLCgv3++++qMocOHWIWFhasuLjYKHXLz89nb775Zr3ye/bsYQBYbm6uallzCcNYdVOH+jA0dOzYMURERKge8/l8hIeH4+jRo0aMqnl79uyp97i2CUPTWUivXLmCwsLCenXv0qULbGxsTLrupaWluHDhQr24HRwc0KlTJ1Xcply3wMDAeo93796NJ554Ak5OThptb0p169atG4KDg9Wu09frFB8fj+rq6nplIiIiUF1djfj4eENUC0DTdXN3d8fXX39db5m27z/AeHVThxKGBoqLiyESiRq0KXt6eiI9Pd1IUenmzJkz8Pb2xsCBA1XLVqxYgdjYWAwaNAhvvfUW8vPzVetq61e37jweDx4eHiZR9y1btiA2NhYDBw7ElClTcPv2bQDq4659XLvO1OtW17Zt2zBt2rR6y9ry61ZLX69Teno6zM3N4erqqirj5uYGMzMzk6rvmTNn0Ldv3wZ9ODNnzkRMTAyio6OxYMEClJeXq9aZUt0oYWhAIpEAQIMRmQKBQLWuLZDJZFi1ahXWrVsHCwsLAECnTp0QHR2N48eP4/jx45DJZOjfvz8qKioAmHbd/f390bt3bxw9ehT//PMPAgMDER4ejtzcXI3iNuW61XXjxg3k5eVh+PDhqmVt+XWrS1+vk0QiUdsBbGlpaTL1LSoqwrfffouvvvqq3vJevXph1KhROHnyJA4dOoSrV69i2LBhUCqVAEyrbpQwNGBtbQ2g4Y1hZDKZal1b8Prrr+OZZ57B+PHjVcvef/99vPjii+Dz+bC0tMSaNWtw584d7N69G4Bp1/3ll1/GrFmzYG5uDj6fj//85z8QCoVYv369RnGbct3q2rZtGyZPnqyaKRlo269bXfp6naytrdU288jlcpOor0KhwAsvvIBly5ahX79+9datXbsWjz32GADAzs4On376KRISEnD8+HEAplU3ShgacHFxgYODA/Ly8uotz8vLU12eauoWLFgAc3NzLF++vMly9vb2cHNzUzXt1Navbt0ZY8jPzze5upuZmaFDhw64ffu22rhrH9euawt1UyqV2LVrV4PmqIe11ddNX69TUFAQFAoFioqKVGUKCwuhVCqNXt+amhpMmTIFMTExeP3115stX3uDtrqvpanUjRKGhuLi4pCUlKR6zBjDhQsXMGzYMCNGpZmVK1ciMzMTmzZtAo/Hw/nz53H+/HkAXNtpXTKZDMXFxfDz8wMA9OjRA25ubvXqfvPmTVRWVhq97g/HDgB3796Fn58fnJyc0Lt373pxi8Vi3Lp1SxW3Kdet1p9//omOHTs26Fhty69bXfp6naKjo2FhYVGvTFJSEiwsLBAdHd1KtVHvrbfego+PD/7zn/8AAI4eParqeygoKGjwJS43NxcAVK+lSdWtVa/JasPOnTvH7OzsWEpKCmOMsZ07d7aJcRgbNmxgYWFh7PTp0ywxMZElJiayxYsXs61btzLGGLO0tGSJiYmq8h988AFzcXFRXRPPGHcNfLdu3VTXwL/yyits9OjRrVoPdTp06MD279+verx582YmEAjYjRs3GGPc9f2enp6soKCAMcbYRx99pPb6flOsW63nnnuObdmypcHytvi6NXZZrb5ep3feeYcNHz6cKRQKplQq2WOPPcbeeecdw1bqvsbq9t5777GYmBjVey8xMZG9+uqrqsvBMzIymLOzs2o7hULRYKyUsetWFyUMLfz2228sPDycDRo0iEVHR7Nr164ZO6QmicVixufzGYAGP7UJY926dWzQoEEsNjaWRUZGspEjR7IrV67U209NTY1qMFVERASbOHEiKy0tbf0KPWTXrl1syJAhLDY2lkVFRbGYmBgWHx9fr8yGDRtY7969WVRUFBs5ciTLzs6ut95U68YYY6WlpczFxYWVl5c3WNeWXjeZTMZiYmJYz549GQDWr1+/BuOD9PE6SaVS9s4777A+ffqwPn36sLfffptJpVKj1e3atWtq33sAVAmjqqqKLV++nPXv35/Fxsayvn37sueff55lZmYavW7q0PTmhBBCNEJ9GIQQQjRCCYMQQohGKGEQQgjRCCUMQgghGqGEQQghRCOUMAghhGiEEgYhhBCNUMIghBCiEUoYhBBCNEIJgxBCiEYoYRBCDIYxppp91RDkcjkKCgoMtn9SHyWMR1RCQgJiY2PB4/HQuXNnLF68WLVu2bJl6Ny5M3g8HmJjY3HmzJkWH2/t2rUYO3Zsi/ejjb///hvbtm3TapsvvvgCnTt3bnALzdb28PPVWF2M8bxqqqKiAk8//bRBbyPK4/EwadIk/PvvvwY7BnmAEsYjKjIyEn///TcA7uZKS5cuVa378MMPsWDBAgDcB1VUVFSLj+fu7t7qH8K6JIyZM2eq6m5MDz9fjdXFGM+rpmbNmoXY2FgMHjzYYMewsLDA1q1bMWXKFJSWlhrsOIRjbuwAyKNh4sSJmDhxorHDaDM0fb5M9XlNTk7Gzz//jHv37hn8WD4+PoiNjcXq1avx8ccfG/x4jzI6wyAaUygUWLBgAbp164aIiAgMGTIEly9fBgD88ssv6NWrF3g8Hg4dOoTRo0fD29sbY8aMwQ8//KBaB3Dfljt06IDY2FjExsZi0KBB4PF4mDFjRrPHefhYBw8exFNPPYWQkBC88847qjJr1qzBtm3bcOnSJdVxqqqqsGfPHgwYMABDhgxBZGQkZs+e3eBe0U2p22S1Zs0aDBs2DB06dMCUKVNQVVWl0XNV64cfflCt69+/P95//33V8rrPV2N1ebicvp47ffj111/Rv3//BvecrhtfdHQ0IiIisHbt2gaxHThwAKNHj0ZgYCCWL18OkUiEV155BX369MGIESManE3ExcXhl19+0WsdiBqtfgcOYlJQ52ZKdW3dupU9/O+xcOFC1qtXL9UNfb755hvm5ubGysrKGGMP7jq2ePFixhhjaWlpbOLEifXW1f5dW4YxxpYsWcKcnZ3ZvXv3NDpO3f2tXLmSMcZYfn4+EwgE7Pjx46oyixcvZjExMfXqMH78eNVd+uRyOXv88cfZ0qVLG9Q9ICCg0eds69atzMzMjK1atYoxxlh5eTnr1q0bmzNnjsbPVW5uLjMzM2O3b99mjDGWl5fHnJycGtSvqbqoK6ev566lRo0axaZPn95g+cKFC1nv3r1V8cXHx6ut9+rVqxljjKWkpDAej8feeustVllZyZRKJRswYABbsmRJvf2ePXuWAWDFxcV6q0NjRCKRwY9hqihhPOIAsNDQUBYTE1PvJzQ0tN4HkUQiYUKhkG3evFm1TKFQMBcXF/bpp58yxh682R++W1jddbX7qn1jJyUlMXNzc7Z7926Nj1N3f3XvzNa7d2+2Zs0a1WN1H7IZGRn1bv25ceNG1r9//3plNEkY5ubm9W6h+cUXXzBra2sml8s1qsOFCxfq3XmNMcZOnTql9vlqrC4Pl9Pnc/ew06dPsy1btrDp06ezffv2sW+++YY9+eSTqiT/sL59+7L333+/3rLa+L799tt6yz/44IMmY3Nzc2MfffSR6vHcuXPZ008/XW8fN2/eZABUt+c1pJs3b7Ivv/zS4McxRdSHQbBgwQJMnTq13rJt27Zh2rRpqsdpaWmQSqUICQlRLTMzM0OHDh1w7dq1etv6+vo2eTwrKytYWVlBJpNh8uTJGDNmDF544QWtjwMAXl5eqr/t7OwgFoubPHZlZSVefPFFZGVlwdLSEnl5eVo1SdXy8PCAUChUPe7YsSMkEgnu3LkDiUTSbB169eqFl156CXFxcRg8eDBefPFFTJo0Ses46jLUcycSiZCamopp06bB1tYWn3/+OY4dO4bjx4/Xew4e3sbcvP7HS218wcHB9ZZ/9NFHTcZmbW1d77GNjQ1EIlG98hYWFgCAsrIytfHoU2hoKC5cuIC3334ba9asgaWlpcGPaSooYRCNsCbu5Fu3DR3gPqQ0sWjRIhQVFWHDhg06HefhY/F4vCa3r6ioQFxcHJ5//nns2rULfD4f27Ztw5IlSzSKt66Hj1P7uLkYauvA4/GwY8cOvPfee9i2bRsWLVqE1atXIyEhAQ4ODlrHoy4mdcetS9PnzsLCAhMmTADAXY49ZswYmJmZ4ccff2z0eI6OjqiurtY4vqZiU/f44X3VHsvJyanJ/Z4+fRrjxo3TOI7GSCQSlJeX486dO9i7d6/G//NtHXV6E42EhIRAKBQiNTVVtUypVCIzMxPdunXTen///PMPPv/8c2zcuBGurq4AgEuXLun1OHz+g39vqVSK5ORkFBQU4Nlnn1Wtk8vlWscOAAUFBZBKparH6enpsLa2hr+/v0Z1yM3NxZkzZxAWFoZVq1bh+vXryMnJwdGjRzWqy8MfxoD+X6Na1tbWqm/wf/31F4YOHQoADb7l1+Xp6YmSkhK18aWlpdVb/tlnn0EikegcHwDVsTw8PJosN2DAAOTl5bX4Z/369Zg/fz5+++23RyZZAJQwiIasrKwwa9YsrF+/HpWVlQCA7777Dnw+H6+++qpW+6qoqMDUqVMxceLEeoPO3n33Xb0ex83NTXU1zezZs3Hr1i1YWVmpPpSVSiX279+v1T5rmZubY+PGjar6fPvtt3jjjTdgbm6uUR1SU1Px3nvvQaFQAHjwjbluc1JTdfnzzz8blNHnc1fX4cOH8fnnn+P27dtITU1Ft27dUFNTgx07djS6zcCBAxskBnXx/fHHH9i7d2+Dq6m0lZaWhrCwsGbPMPTh8uXLqKqqwsqVKxs0u7V7Ruo7IUZ27tw5FhMTo+r0/vDDD1Xrli5dqur0jomJYadPn2aMMVZdXc3ee+89FhYWxvr27ctiYmLYxYsXGWOMHT58mPXs2VO1zZ49e1T727VrV711q1atYgBYWFgY69evn+qntlO3qeOoO1ZxcTGbOnUqc3BwYAEBAaoO3vz8fBYREcEGDhzIRo4cyaRSKdu7dy/r1KkTi4yMZGPGjGHTpk1jAoGAxcXFMcYYW7t2LQsNDWUCgYDFxMSoruapq7ZTfPPmzeyxxx5jAQEBbPLkyUwikajKNFeHe/fusalTp7K+ffuy2NhYFhERwbZs2aL2+UpNTVVbF3Xl9PXc1bVlyxb29ttvs6+//pp9/PHHbO3ateyrr75q8oqkW7duMTs7uwbPX3V1NZs/fz7r2rUri46OZqNHj2Z37txpNLbhw4czgUDAQkND2a5du9jq1atZQEAAc3BwYM8//7xqv5MnT6535Z0hVVZWtspxTBGPMS0aFgkhqn6PzMxMY4di0mbOnAl3d3csWrTIoMdJT0/HE088gcTERNjb2xv0WI86apIihBjEypUrcfXqVRw7dsxgx5DL5Zg+fTp2795NyaIV0BkGIVr44osvsGHDBmRmZqJ///44fPgwrKysjB2WSSssLISbm5tB9l1dXQ2JRKLzlWVEO5QwCCGEaISapAghhGiEEgYhhBCNUMIghBCiEUoYhBBCNEIJgxBCiEYoYRBCCNEIJQxCCCEaoYRBCCFEI5QwCCGEaIQSBiGEEI38PzmagiYOIdODAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -752,7 +918,7 @@ } ], "source": [ - "weac.plot.displacements(skiers_on_B, x=xsl_skiers, z=z_skiers, **seg_skiers)" + "skiers_on_B_plotter.plot_displacements(skiers_on_B_analyzer, x=xsl_skiers, z=z_skiers)" ] }, { @@ -765,13 +931,13 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 62, "id": "c1179d9f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -781,7 +947,8 @@ } ], "source": [ - "weac.plot.stresses(skiers_on_B, x=xwl_skiers, z=z_skiers, **seg_skiers)" + "skiers_on_B_plotter.plot_stresses(skiers_on_B_analyzer, x=xwl_skiers, z=z_skiers)\n", + "# skiers_on_B_analyzer.print_call_stats()" ] }, { @@ -794,15 +961,26 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "id": "17c7061b", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "0.0\n", + "0.0\n", + "0.0\n", + "0.0\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -816,24 +994,29 @@ "\n", "# Use only x-coordinates of bedded segments (xb)\n", "x, z = xwl_skiers, z_skiers\n", + "xwl_cm = x / 10\n", "\n", "# Compute stresses in kPa\n", - "xwl_cm, tau = skiers_on_B.get_weaklayer_shearstress(x=x, z=z, unit=\"kPa\")\n", - "_, sig = skiers_on_B.get_weaklayer_normalstress(x=x, z=z, unit=\"kPa\")\n", + "tau = skiers_on_B_analyzer.sm.fq.tau(Z=z, unit=\"kPa\")\n", + "tau = np.where(~np.isnan(x), tau, np.nan)\n", + "sig = skiers_on_B_analyzer.sm.fq.sig(Z=z, unit=\"kPa\")\n", + "sig = np.where(~np.isnan(x), sig, np.nan)\n", "\n", - "# === SLAB OUTPUTS ==========================================================\n", + "# Compute deformations in um and degrees\n", + "top = skiers_on_B_analyzer.sm.slab.H\n", + "mid = skiers_on_B_analyzer.sm.slab.H / 2\n", + "bot = 0\n", "\n", - "# Use x-coordinates of bedded and unsupported segments (xq)\n", "x, z = xsl_skiers, z_skiers\n", + "xsl_cm = x / 10\n", "\n", - "# Compute deformations in um and degrees\n", - "xsl_cm, w = skiers_on_B.get_slab_deflection(x=x, z=z, unit=\"um\")\n", - "_, u_top = skiers_on_B.get_slab_displacement(x=x, z=z, unit=\"um\", loc=\"top\")\n", - "_, u_mid = skiers_on_B.get_slab_displacement(x=x, z=z, unit=\"um\", loc=\"mid\")\n", - "_, u_bot = skiers_on_B.get_slab_displacement(x=x, z=z, unit=\"um\", loc=\"bot\")\n", - "_, psi = skiers_on_B.get_slab_rotation(x=x, z=z, unit=\"degrees\")\n", + "w = skiers_on_B.fq.w(Z=z, unit=\"um\")\n", + "u_top = skiers_on_B.fq.u(Z=z, h0=top, unit=\"um\")\n", + "u_mid = skiers_on_B.fq.u(Z=z, h0=mid, unit=\"um\")\n", + "u_bot = skiers_on_B.fq.u(Z=z, h0=bot, unit=\"um\")\n", + "psi = skiers_on_B.fq.psi(Z=z, unit=\"deg\")\n", "\n", - "# === ASSEMBLE ALL OUTPUTS INTO LISTS =======================================\n", + "# # === ASSEMBLE ALL OUTPUTS INTO LISTS =======================================\n", "\n", "outputs = [u_top, u_mid, u_bot, tau, psi, -w, sig]\n", "\n", @@ -868,29 +1051,133 @@ }, { "cell_type": "code", - "execution_count": 53, - "id": "2e8e95e5", + "execution_count": 26, + "id": "d488aea1", "metadata": {}, "outputs": [], "source": [ - "import sys\n", + "from weac.components.criteria_config import CriteriaConfig\n", + "from weac.analysis.criteria_evaluator import (\n", + " CriteriaEvaluator,\n", + " CoupledCriterionResult,\n", + " FindMinimumForceResult,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "1ac86135", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Minimum force: True\n", + "Skier weight: 490.61566658208375\n", + "Distance to failure: 0.9999999999303159\n", + "Min Distance to failure: 0.03412762568741824\n", + "Minimum force iterations: None\n" + ] + } + ], + "source": [ + "# Define test parameters\n", + "layers = [\n", + " Layer(rho=170, h=100),\n", + " Layer(rho=190, h=40),\n", + " Layer(rho=230, h=130),\n", + " Layer(rho=250, h=20),\n", + " Layer(rho=210, h=70),\n", + " Layer(rho=380, h=20),\n", + " Layer(rho=280, h=100),\n", + "]\n", + "scenario_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=30,\n", + ")\n", + "segments = [\n", + " Segment(length=240000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=75),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=240000, has_foundation=False, m=0),\n", + "]\n", + "weak_layer = WeakLayer(\n", + " rho=150,\n", + " h=30,\n", + " E=0.25,\n", + ")\n", + "criteria_config = CriteriaConfig(\n", + " stress_envelope_method=\"adam_unpublished\",\n", + " scaling_factor=1,\n", + " order_of_magnitude=1,\n", + ")\n", + "model_input = ModelInput(\n", + " scenario_config=scenario_config,\n", + " layers=layers,\n", + " segments=segments,\n", + " weak_layer=weak_layer,\n", + " criteria_config=criteria_config,\n", + ")\n", + "\n", + "sys_model = SystemModel(\n", + " model_input=model_input,\n", + ")\n", + "\n", + "criteria_evaluator = CriteriaEvaluator(\n", + " criteria_config=criteria_config,\n", + ")\n", "\n", - "sys.path.append(\"../weac\") # Adds the 'weac' folder to the Python path" + "results: FindMinimumForceResult = criteria_evaluator.find_minimum_force(\n", + " system=sys_model\n", + ")\n", + "\n", + "print(\"Minimum force:\", results.success)\n", + "print(\"Skier weight:\", results.critical_skier_weight)\n", + "print(\"Distance to failure:\", results.max_dist_stress)\n", + "print(\"Min Distance to failure:\", results.min_dist_stress)\n", + "print(\"Minimum force iterations:\", results.iterations)" ] }, { "cell_type": "code", - "execution_count": 54, - "id": "d488aea1", + "execution_count": 28, + "id": "ae8a0f24", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating stress envelope...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "from criterion_check import *" + "print(\" - Generating stress envelope...\")\n", + "plotter = Plotter()\n", + "fig = plotter.plot_stress_envelope(\n", + " system_model=sys_model,\n", + " criteria_evaluator=criteria_evaluator,\n", + " all_envelopes=False,\n", + " filename=\"stress_envelope\",\n", + ")" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 29, "id": "876e0dda", "metadata": {}, "outputs": [ @@ -899,77 +1186,142 @@ "output_type": "stream", "text": [ "Algorithm convergence: True\n", - "Anticrack nucleation governed by a pure stress criterion: True\n", - "Critical Skier Weight: 493.96969093916425 kg\n", - "Crack Length: 1 mm\n", - "Fracture toughness envelope function: 775.8710825052028\n", - "Stress failure envelope function: 1.0038504429239823\n" + "Message: Fracture governed by pure stress criterion.\n", + "Critical skier weight: 493.0683850240784\n", + "Crack length: 1.0\n", + "Stress failure envelope: 1.012272470764964\n", + "G delta: 760.8448858659796\n", + "Iterations: 1\n" ] } ], "source": [ "# Define test parameters\n", - "snow_profile = [\n", - " [170, 100], # (1) surface layer\n", - " [190, 40], # (2) 2nd layer\n", - " [230, 130], # :\n", - " [250, 20], # :\n", - " [210, 70], # (i) i-th layer\n", - " [380, 20], # :\n", - " [280, 100],\n", - "] # (N) last slab layer above weak layer\n", - "\n", - "phi = 30 # Slope angle in degrees\n", - "skier_weight = 75 # Skier weight in kg\n", - "envelope = \"adam_unpublished\"\n", - "scaling_factor = 1\n", - "E = 0.25 # Elastic modulus in MPa\n", - "order_of_magnitude = 1\n", - "density = 150 # Weak layer density in kg/mΒ³\n", - "t = 30 # Weak layer thickness in mm\n", - "\n", - "# Call the method\n", - "(\n", - " result,\n", - " crack_length,\n", - " skier_weight,\n", - " skier,\n", - " C,\n", - " segments,\n", - " x_cm,\n", - " sigma_kPa,\n", - " tau_kPa,\n", - " iteration_count,\n", - " elapsed_times,\n", - " skier_weights,\n", - " crack_lengths,\n", - " self_collapse,\n", - " pure_stress_criteria,\n", - " critical_skier_weight,\n", - " g_delta_last,\n", - " dist_max,\n", - " g_delta_values,\n", - " dist_max_values,\n", - ") = check_coupled_criterion_anticrack_nucleation(\n", - " snow_profile=snow_profile,\n", - " phi=phi,\n", - " skier_weight=skier_weight,\n", - " envelope=envelope,\n", - " scaling_factor=scaling_factor,\n", - " E=E,\n", - " order_of_magnitude=order_of_magnitude,\n", - " density=density,\n", - " t=t,\n", + "layers = [\n", + " Layer(rho=170, h=100),\n", + " Layer(rho=190, h=40),\n", + " Layer(rho=230, h=130),\n", + " Layer(rho=250, h=20),\n", + " Layer(rho=210, h=70),\n", + " Layer(rho=380, h=20),\n", + " Layer(rho=280, h=100),\n", + "]\n", + "scenario_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=30,\n", + ")\n", + "segments = [\n", + " Segment(length=240000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=75),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=240000, has_foundation=False, m=0),\n", + "]\n", + "weak_layer = WeakLayer(\n", + " rho=150,\n", + " h=30,\n", + " E=0.25,\n", + ")\n", + "criteria_config = CriteriaConfig(\n", + " stress_envelope_method=\"adam_unpublished\",\n", + " scaling_factor=1,\n", + " order_of_magnitude=1,\n", + ")\n", + "model_input = ModelInput(\n", + " scenario_config=scenario_config,\n", + " layers=layers,\n", + " segments=segments,\n", + " weak_layer=weak_layer,\n", + " criteria_config=criteria_config,\n", + ")\n", + "\n", + "sys_model = SystemModel(\n", + " model_input=model_input,\n", ")\n", "\n", - "# Print the results\n", - "print(\"Algorithm convergence:\", result)\n", - "print(\"Anticrack nucleation governed by a pure stress criterion:\", pure_stress_criteria)\n", + "criteria_evaluator = CriteriaEvaluator(\n", + " criteria_config=criteria_config,\n", + ")\n", "\n", - "print(\"Critical Skier Weight:\", skier_weight, \"kg\")\n", - "print(\"Crack Length:\", crack_length, \"mm\")\n", - "print(\"Fracture toughness envelope function:\", g_delta_values[-1])\n", - "print(\"Stress failure envelope function:\", dist_max_values[-1])" + "results: CoupledCriterionResult = criteria_evaluator.evaluate_coupled_criterion(\n", + " system=sys_model\n", + ")\n", + "\n", + "print(\"Algorithm convergence:\", results.converged)\n", + "print(\"Message:\", results.message)\n", + "print(\"Critical skier weight:\", results.critical_skier_weight)\n", + "print(\"Crack length:\", results.crack_length)\n", + "print(\"Stress failure envelope:\", results.max_dist_stress)\n", + "print(\"G delta:\", results.g_delta)\n", + "print(\"Iterations:\", results.iterations)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5f010fc1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating stress envelope...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\" - Generating stress envelope...\")\n", + "plotter = Plotter()\n", + "fig = plotter.plot_stress_envelope(\n", + " system_model=sys_model,\n", + " criteria_evaluator=criteria_evaluator,\n", + " all_envelopes=False,\n", + " filename=\"stress_envelope\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "9e31f673", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating fracture toughness envelope...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\" - Generating fracture toughness envelope...\")\n", + "plotter = Plotter()\n", + "fig = plotter.plot_err_envelope(\n", + " system_model=sys_model,\n", + " criteria_evaluator=criteria_evaluator,\n", + " filename=\"err_envelope\",\n", + ")" ] }, { @@ -982,7 +1334,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 32, "id": "b387afcd", "metadata": {}, "outputs": [ @@ -991,72 +1343,73 @@ "output_type": "stream", "text": [ "Algorithm convergence: True\n", - "Anticrack nucleation governed by a pure stress criterion: False\n", - "Critical Skier Weight: 346.65085429332703 kg\n", - "Crack Length: 29.020273891394027 mm\n", - "Fracture toughness envelope function: 1.0002587893165604\n", - "Stress failure envelope function: 1.0306218152961808\n" + "Message: No Exception encountered - Converged successfully.\n", + "Self-collapse: False\n", + "Pure stress criteria: False\n", + "Critical skier weight: 346.8349191568037\n", + "Initial critical skier weight: 341.108488248429\n", + "Crack length: 29.136286292286968\n", + "G delta: 1.0013647813490758\n", + "Final error: 0.0013647813490758054\n", + "Max distance to failure: 1.0290148348280694\n", + "Iterations: 8\n" ] } ], "source": [ "# Define thinner snow profile (standard snow profile A), with higher weak layer Young's Modulus\n", - "snow_profile = [\n", - " [350, 120], # (1) surface layer\n", - " [270, 120], # (2) 2nd layer\n", - " [180, 120],\n", - "] # (N) last slab layer above weak layer\n", - "\n", - "phi = 30 # Slope angle in degrees\n", - "skier_weight = 75 # Skier weight in kg\n", - "envelope = \"adam_unpublished\"\n", - "scaling_factor = 1\n", - "E = 1 # Elastic modulus in MPa\n", - "order_of_magnitude = 1\n", - "density = 150 # Weak layer density in kg/mΒ³\n", - "t = 30 # Weak layer thickness in mm\n", - "\n", - "(\n", - " result,\n", - " crack_length,\n", - " skier_weight,\n", - " skier,\n", - " C,\n", - " segments,\n", - " x_cm,\n", - " sigma_kPa,\n", - " tau_kPa,\n", - " iteration_count,\n", - " elapsed_times,\n", - " skier_weights,\n", - " crack_lengths,\n", - " self_collapse,\n", - " pure_stress_criteria,\n", - " critical_skier_weight,\n", - " g_delta_last,\n", - " dist_max,\n", - " g_delta_values,\n", - " dist_max_values,\n", - ") = check_coupled_criterion_anticrack_nucleation(\n", - " snow_profile=snow_profile,\n", - " phi=phi,\n", - " skier_weight=skier_weight,\n", - " envelope=envelope,\n", - " scaling_factor=scaling_factor,\n", - " E=E,\n", - " order_of_magnitude=order_of_magnitude,\n", - " density=density,\n", - " t=t,\n", + "layers = [\n", + " Layer(rho=350, h=120),\n", + " Layer(rho=270, h=120),\n", + " Layer(rho=180, h=120),\n", + "]\n", + "scenario_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=30,\n", + ")\n", + "segments = [\n", + " Segment(length=18000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=75),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=18000, has_foundation=False, m=0),\n", + "]\n", + "weak_layer = WeakLayer(\n", + " rho=150,\n", + " h=30,\n", + " E=1,\n", + ")\n", + "criteria_config = CriteriaConfig(\n", + " stress_envelope_method=\"adam_unpublished\",\n", + " scaling_factor=1,\n", + " order_of_magnitude=1,\n", + ")\n", + "model_input = ModelInput(\n", + " scenario_config=scenario_config,\n", + " layers=layers,\n", + " segments=segments,\n", + " weak_layer=weak_layer,\n", + " criteria_config=criteria_config,\n", + ")\n", + "\n", + "sys_model = SystemModel(\n", + " model_input=model_input,\n", ")\n", "\n", - "# Print the results\n", - "print(\"Algorithm convergence:\", result)\n", - "print(\"Anticrack nucleation governed by a pure stress criterion:\", pure_stress_criteria)\n", + "results: CoupledCriterionResult = criteria_evaluator.evaluate_coupled_criterion(\n", + " system=sys_model\n", + ")\n", "\n", - "print(\"Critical Skier Weight:\", skier_weight, \"kg\")\n", - "print(\"Crack Length:\", crack_length, \"mm\")\n", - "print(\"Fracture toughness envelope function:\", g_delta_values[-1])\n", - "print(\"Stress failure envelope function:\", dist_max_values[-1])" + "print(\"Algorithm convergence:\", results.converged)\n", + "print(\"Message:\", results.message)\n", + "print(\"Self-collapse:\", results.self_collapse)\n", + "print(\"Pure stress criteria:\", results.pure_stress_criteria)\n", + "print(\"Critical skier weight:\", results.critical_skier_weight)\n", + "print(\"Initial critical skier weight:\", results.initial_critical_skier_weight)\n", + "print(\"Crack length:\", results.crack_length)\n", + "print(\"G delta:\", results.g_delta)\n", + "print(\"Final error:\", results.dist_ERR_envelope)\n", + "print(\"Max distance to failure:\", results.max_dist_stress)\n", + "print(\"Iterations:\", results.iterations)" ] }, { @@ -1069,7 +1422,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 33, "id": "9b2682c8", "metadata": {}, "outputs": [ @@ -1077,25 +1430,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "Fracture toughness envelope function: 4.7166366294665635e-05\n", - "Crack Propagation Criterion Met: False\n" + "Results of crack propagation criterion: (np.float64(1.2036206367817859), True)\n" ] } ], "source": [ - "# Evaluate crack propagation criterion for the found anticrack\n", - "g_delta_diff, crack_propagation_criterion_check = check_crack_propagation_criterion(\n", - " snow_profile=snow_profile, phi=phi, segments=segments, skier_weight=0, E=E, t=t\n", - ")\n", - "\n", - "# Print the results\n", - "print(\"Fracture toughness envelope function:\", g_delta_diff)\n", - "print(\"Crack Propagation Criterion Met:\", crack_propagation_criterion_check)" + "system = results.final_system\n", + "results = criteria_evaluator.check_crack_self_propagation(system)\n", + "print(\"Results of crack propagation criterion: \", results)" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 34, "id": "b5a7ebe9", "metadata": {}, "outputs": [ @@ -1103,7 +1450,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Minimum Crack Length for Self-Propagation: 1706.390802276992 mm\n" + "Minimum Crack Length for Self-Propagation: 1706.9272437952422 mm\n" ] } ], @@ -1111,12 +1458,12 @@ "# As the crack propagation criterion is not met --> investigate minimum self propagation crack boundary\n", "initial_interval = (1, 3000) # Interval for the crack length search (mm)\n", "\n", - "min_crack_length = find_min_crack_length_self_propagation(\n", - " snow_profile=snow_profile, phi=phi, E=E, t=t, initial_interval=initial_interval\n", + "min_crack_length = criteria_evaluator.find_minimum_crack_length(\n", + " system, search_interval=initial_interval\n", ")\n", "\n", "if min_crack_length is not None:\n", - " print(f\"Minimum Crack Length for Self-Propagation: {min_crack_length} mm\")\n", + " print(f\"Minimum Crack Length for Self-Propagation: {min_crack_length[0]} mm\")\n", "else:\n", " print(\"The search for the minimum crack length did not converge.\")" ] @@ -1126,12 +1473,12 @@ "id": "f669dbbf", "metadata": {}, "source": [ - "The anticrack of 29.0 mm is not sufficiently long to surpass the self crack propagation boundary of 1706.4 mm. The propensity of the generated anticrack to proagate, is low." + "The anticrack of 29.0 mm is not sufficiently long to surpass the self crack propagation boundary of 1706.9 mm. The propensity of the generated anticrack to proagate, is low." ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 35, "id": "e47b6959", "metadata": {}, "outputs": [ @@ -1140,80 +1487,68 @@ "output_type": "stream", "text": [ "Algorithm convergence: True\n", - "Anticrack nucleation governed by a pure stress criterion: False\n", - "Critical Skier Weight: 22.554150952829684 kg\n", - "Crack Length: 2343.7337508472374 mm\n", - "Fracture toughness envelope function: 1.0001387368634147\n", - "Stress failure envelope function: 1.5945729403688182\n" + "Message: No Exception encountered - Converged successfully.\n", + "Critical skier weight: 22.567736031400667\n", + "Crack length: 2344.706943056721\n", + "G delta: 1.0013453103325187\n", + "Iterations: 17\n", + "dist_ERR_envelope: 0.0013453103325187232\n", + "History: [ 0.52139802 0.56001384 -0.03861582]\n" ] } ], "source": [ - "# So far, stress envelope boundary has not scaled with weak layer density\n", - "# --> Update scaling factor using density baseline of 250 kg/m^3 and order of magnitude of 3,\n", - "# as this has shown closest resemblance to previously published failure envelopes\n", - "\n", - "snow_profile = [\n", - " [350, 120], # (1) surface layer\n", - " [270, 120], # (2) 2nd layer\n", - " [180, 120],\n", - "] # (N) last slab layer above weak layer\n", - "\n", - "phi = 35 # Slope angle in degrees\n", - "skier_weight = 75 # Skier weight in kg\n", - "envelope = \"adam_unpublished\"\n", - "E = 1 # Elastic modulus in MPa\n", - "order_of_magnitude = 3\n", - "density = 125 # Weak layer density in kg/mΒ³\n", - "t = 30 # Weak layer thickness in mm\n", - "density_baseline = 250\n", - "scaling_factor = density / density_baseline\n", - "\n", - "(\n", - " result,\n", - " crack_length,\n", - " skier_weight,\n", - " skier,\n", - " C,\n", - " segments,\n", - " x_cm,\n", - " sigma_kPa,\n", - " tau_kPa,\n", - " iteration_count,\n", - " elapsed_times,\n", - " skier_weights,\n", - " crack_lengths,\n", - " self_collapse,\n", - " pure_stress_criteria,\n", - " critical_skier_weight,\n", - " g_delta_last,\n", - " dist_max,\n", - " g_delta_values,\n", - " dist_max_values,\n", - ") = check_coupled_criterion_anticrack_nucleation(\n", - " snow_profile=snow_profile,\n", - " phi=phi,\n", - " skier_weight=skier_weight,\n", - " envelope=envelope,\n", - " scaling_factor=scaling_factor,\n", - " E=E,\n", - " order_of_magnitude=order_of_magnitude,\n", - " density=density,\n", - " t=t,\n", + "layers = [\n", + " Layer(rho=350, h=120),\n", + " Layer(rho=270, h=120),\n", + " Layer(rho=180, h=120),\n", + "]\n", + "scenario_config = ScenarioConfig(\n", + " system_type=\"skier\",\n", + " phi=-35,\n", + ")\n", + "segments = [\n", + " Segment(length=180000, has_foundation=True, m=0),\n", + " Segment(length=0, has_foundation=False, m=75),\n", + " Segment(length=0, has_foundation=False, m=0),\n", + " Segment(length=180000, has_foundation=False, m=0),\n", + "]\n", + "weak_layer = WeakLayer(\n", + " rho=125,\n", + " h=30,\n", + " E=1,\n", ")\n", + "criteria_config = CriteriaConfig(\n", + " stress_envelope_method=\"adam_unpublished\",\n", + " scaling_factor=125 / 250,\n", + " order_of_magnitude=3,\n", + ")\n", + "model_input = ModelInput(\n", + " scenario_config=scenario_config,\n", + " layers=layers,\n", + " segments=segments,\n", + " weak_layer=weak_layer,\n", + " criteria_config=criteria_config,\n", + ")\n", + "\n", + "system = SystemModel(model_input=model_input)\n", + "criteria_evaluator = CriteriaEvaluator(criteria_config=criteria_config)\n", + "results: CoupledCriterionResult = criteria_evaluator.evaluate_coupled_criterion(system)\n", "\n", "\n", - "print(\"Algorithm convergence:\", result)\n", - "print(\"Anticrack nucleation governed by a pure stress criterion:\", pure_stress_criteria)\n", - "print(\"Critical Skier Weight:\", skier_weight, \"kg\")\n", - "print(\"Crack Length:\", crack_length, \"mm\")\n", - "print(\"Fracture toughness envelope function:\", g_delta_values[-1])\n", - "print(\"Stress failure envelope function:\", dist_max_values[-1])" + "print(\"Algorithm convergence:\", results.converged)\n", + "print(\"Message:\", results.message)\n", + "print(\"Critical skier weight:\", results.critical_skier_weight)\n", + "print(\"Crack length:\", results.crack_length)\n", + "print(\"G delta:\", results.g_delta)\n", + "print(\"Iterations:\", results.iterations)\n", + "print(\"dist_ERR_envelope:\", results.dist_ERR_envelope)\n", + "print(\"History:\", results.history.incr_energies[-1])" ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 36, "id": "6d124842", "metadata": {}, "outputs": [ @@ -1221,20 +1556,85 @@ "name": "stdout", "output_type": "stream", "text": [ - "Fracture toughness envelope function: 43.354331761371924\n", - "Crack Propagation Criterion Met: True\n" + "Results of crack propagation criterion: True\n", + "G delta: 125.93403485816587\n" ] } ], "source": [ - "# Evaluate crack propagation criterion for the found anticrack\n", - "\n", - "g_delta_diff, crack_propagation_criterion_check = check_crack_propagation_criterion(\n", - " snow_profile=snow_profile, phi=phi, segments=segments, skier_weight=0, E=E, t=t\n", - ")\n", - "\n", - "print(\"Fracture toughness envelope function:\", g_delta_diff)\n", - "print(\"Crack Propagation Criterion Met:\", crack_propagation_criterion_check)" + "system = results.final_system\n", + "g_delta, propagation_status = criteria_evaluator.check_crack_self_propagation(system)\n", + "print(\"Results of crack propagation criterion: \", propagation_status)\n", + "print(\"G delta: \", g_delta)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "d529db13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating stress envelope...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\" - Generating stress envelope...\")\n", + "plotter = Plotter()\n", + "fig = plotter.plot_stress_envelope(\n", + " system_model=system,\n", + " criteria_evaluator=criteria_evaluator,\n", + " all_envelopes=False,\n", + " filename=\"stress_envelope\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "6baab9a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " - Generating fracture toughness envelope...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\" - Generating fracture toughness envelope...\")\n", + "plotter = Plotter()\n", + "fig = plotter.plot_err_envelope(\n", + " system_model=system,\n", + " criteria_evaluator=criteria_evaluator,\n", + " filename=\"err_envelope\",\n", + ")" ] }, { @@ -1247,11 +1647,8 @@ } ], "metadata": { - "interpreter": { - "hash": "943ca5ce27d47f17d7fdbf42b1d343cce4da2205808a959f03612a3db1a4d932" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "weac-dev", "language": "python", "name": "python3" }, @@ -1265,7 +1662,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/docs/sphinx/Makefile b/docs/sphinx/Makefile index d4bb2cb..3c79305 100644 --- a/docs/sphinx/Makefile +++ b/docs/sphinx/Makefile @@ -1,20 +1,17 @@ -# Minimal makefile for Sphinx documentation -# +# Minimal Sphinx Makefile -# You can set these variables from the command line, and also -# from the environment for the first two. -SPHINXOPTS ?= -SPHINXBUILD ?= sphinx-build +SPHINXOPTS = +SPHINXBUILD = sphinx-build SOURCEDIR = . BUILDDIR = _build -# Put it first so that "make" without argument is like "make help". +.PHONY: help clean html + help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) -.PHONY: help Makefile +clean: + rm -rf $(BUILDDIR) -# Catch-all target: route all unknown targets to Sphinx using the new -# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). -%: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) +html: + @$(SPHINXBUILD) -M html "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/sphinx/conf.py b/docs/sphinx/conf.py index acae4bc..9eae8f0 100644 --- a/docs/sphinx/conf.py +++ b/docs/sphinx/conf.py @@ -1,45 +1,51 @@ -# Configuration file for the Sphinx documentation builder. -# -# For the full list of built-in configuration values, see the documentation: -# https://www.sphinx-doc.org/en/master/usage/configuration.html +""" +Sphinx configuration for WEAC documentation. +This configuration avoids deprecated extensions and ensures that +`version` and `release` are strings (not callables) as required by Sphinx. +""" + +from __future__ import annotations + +from importlib.metadata import version as get_version # -- Project information ----------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = "WEAC" -copyright = "2024, 2phi GbR" -author = "P.L. Rosendahl, P. Weissgraeber, F. Rheinschmidt, J. Schneider" -release = "2.6.4" -github_url = "https://github.com/2phi/weac" +author = "2phi GbR" + +# Ensure these are strings. Do not shadow the imported function name. +release = get_version("weac") +version = ".".join(release.split(".")[:2]) # -- General configuration --------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ "sphinx.ext.autodoc", + "sphinx.ext.autodoc.typehints", "sphinx.ext.napoleon", "sphinx.ext.viewcode", - "sphinxawesome_theme.highlighting", + "sphinx.ext.mathjax", ] -pygments_style = "perldoc" +# Do NOT include 'sphinxawesome_theme.highlighting' (deprecated and unnecessary) + templates_path = ["_templates"] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # -- Options for HTML output ------------------------------------------------- -# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output -html_static_path = ["_static"] html_theme = "sphinxawesome_theme" -html_theme_options = { - "logo_light": "_static/logo-light.png", - "logo_dark": "_static/logo-dark.png", - "awesome_external_links": True, - "awesome_headerlinks": True, - "show_scrolltop": True, -} -html_favicon = "_static/favicon.ico" -html_show_sphinx = False +html_static_path = ["_static"] +html_title = f"{project} {release}" + + +# -- Autodoc options --------------------------------------------------------- + +autodoc_typehints = "description" +autodoc_typehints_format = "short" +autodoc_preserve_defaults = True +napoleon_google_docstring = True +napoleon_numpy_docstring = True diff --git a/docs/sphinx/index.rst b/docs/sphinx/index.rst index 36cdcd8..801e662 100644 --- a/docs/sphinx/index.rst +++ b/docs/sphinx/index.rst @@ -1,43 +1,15 @@ -.. WEAC documentation master file. - WEAC documentation ================== -WEAC implements closed-form analytical models for the `mechanical analysis of dry-snow slabs on compliant weak layers `_, the `prediction of anticrack onset `_, and, in particular, allows for the `analysis of stratified snow covers `_. Follow the project on `Github `_. - - -Quickstart ----------- - -Install globally using the `pip` Package Installer for Python:: - - pip install -U weac - -or clone the repo:: - - git clone https://github.com/2phi/weac - -for local use. - - -Package contents ----------------- - .. toctree:: - :maxdepth: 3 - - weac + :maxdepth: 2 + :caption: Contents: + modules Indices and tables ------------------- +================== * :ref:`genindex` * :ref:`modindex` - - -Contact -------- - -mail@2phi.de Β· `E-mail `_ Β· `GitHub `_ Β· `Zenodo `_ - +* :ref:`search` diff --git a/examples/criterion_check.py b/examples/criterion_check.py deleted file mode 100644 index f945930..0000000 --- a/examples/criterion_check.py +++ /dev/null @@ -1,2495 +0,0 @@ -import time - -import numpy as np -from scipy.optimize import root_scalar - -import weac - - -def check_crack_propagation_criterion( - snow_profile, phi, segments, skier_weight=0, E=0.25, t=30 -): - """ - Evaluate the crack propagation criterion. - - Parameters - ---------- - snow_profile : object - Layered representation of snowpack. - phi : float - Slope angle (degrees). - segments : dict - Segment-specific data required for the calculation, containing: - - 'li' : ndarray - List of segment lengths. - - 'ki' : ndarray - List of booleans indicating whether a segment lies on - a foundation or not in the cracked configuration. - skier_weight : float, optional - Weight of the skier (kg). Default is 0, indicating no skier weight. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - g_delta_diff : float - Evaluation of fracture toughness envelope for differential energy release - rates at crack tips of system. - crack_propagation_criterion_check : bool - True if the crack propagation criterion is met (g_delta_diff >= 1), - otherwise False. - - Notes - ----- - - gdif function returns differential ERR in kJ, while fracture toughness - criterion is evaluated in J. - - Crack propagation is by default evaluated - - - """ - - li = segments["li"] - ki = segments["ki"] - - skier_no_weight, C_no_weight, segments_no_weight, _, _, _ = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="crack", E=E, t=t - ) - - diff_energy = skier_no_weight.gdif(C=C_no_weight, phi=phi, **segments_no_weight) - g_delta_diff = fracture_toughness_criterion( - 1000 * diff_energy[1], 1000 * diff_energy[2] - ) - crack_propagation_criterion_check = g_delta_diff >= 1 - - return g_delta_diff, crack_propagation_criterion_check - - -def check_coupled_criterion_anticrack_nucleation( - snow_profile, - phi, - skier_weight, - envelope="adam_unpublished", - scaling_factor=1, - E=0.25, - order_of_magnitude=1, - density=250, - t=30, -): - """ - Evaluate coupled criterion for anticrack nucleation. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack containing density and - layer-specific properties. - phi : float - Slope angle (degrees). - skier_weight : float - Weight of the skier (kg). - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - order_of_magnitude : int, optional - Order of magnitude for scaling law used for 'adam_unpublished'. - Default is 1. - density : float, optional - Weak layer density (kg/mΒ³). Default is 250 kg/mΒ³. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - result : bool - True if the criteria for coupled criterion for anticrack nucleation - are met, otherwise False. - crack_length : float - Length of the anticrack (mm) at the found minimum critical solution. - skier_weight : float - Skier weight (kg) at the found minimum critical solution. - skier : object - Skier object representing the state of the system. - C : ndarray - Free constants of the solution for the skier's loading state. - segments : dict - Segment-specific data for the cracked solution: - - 'li': ndarray of segment lengths (mm). - - 'ki': ndarray of booleans indicating whether a segment lies on - a foundation (True) or not (False) in the cracked configuration. - x_cm : ndarray - Discretized horizontal positions (cm) of the snowpack. - sigma_kPa : ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - iteration_count : int - Number of iterations performed in the optimization algorithm. - elapsed_times : list of float - Elapsed times for each iteration (seconds). - skier_weights : list of float - Skier weights for each iteration (kg). - crack_lengths : list of float - Crack lengths for each iteration (mm). - self_collapse : bool - True if the system is fully cracked without any additional load, - otherwise False. - pure_stress_criteria : bool - True if the fracture toughness criteria is met at the found minimum - critical skier weight, otherwise False. - critical_skier_weight : float - Minimum skier weight (kg) required to surpass stress failure envelope - in one point. - g_delta_last : float - Fracture toughness envelope evaluation of incremental ERR at solution. - dist_max : float - Maximum distance to the stress envelope (non-dimensional). - g_delta_values : list of float - Fracture toughness envelope evaluations of incremental ERR for each - iteration. - dist_max_values : list of float - History of maximum distances to the stress envelope over iterations. - - Notes - ----- - - This algorithm finds the minimum critical soltuion for which both the stress - failure, and fracture toughness envelope boundary conditions. are fulfilled. - - The algorithm begins by finding the minimum critical skier weight for which the - stress failure envelope is suprassed in at least one point. It then sets a - maximum skier weight of five times the initalised weight, and employs a binary - search algorithm to narrow down intervals and find the solution of critical - skier weight and associated anticrack nucleation length. - - The setup is robust and well functioning in most cases, but will fail to handle - critical skier weights which are very low, or which are higher than the - initialised maximum, or cetrain special cases where highly localized stresses - results in multiple cracked segments (separated by an uncracked segment). In - these instances, the dampened version of this method is called. - - The fracture toughness criterion is evaluated in J, while ERR differentials - are calculated in kJ. - - - """ - - start_time = time.time() - elapsed_times = [] - - # Trackers for algorithm - skier_weights = [] - crack_lengths = [] - dist_max_values = [] - dist_min_values = [] - g_delta_values = [] - iteration_count = 0 - max_iterations = 25 - - # Initialize parameters - length = 1000 * sum(layer[1] for layer in snow_profile) # Total length (mm) - k0 = [True, True, True, True] # Support boolean for uncracked solution - li = [length / 2, 0, 0, length / 2] # Length segments - ki = [True, False, False, True] # Length of segments with foundations - - # Find minimum critical force to initialize algorithm - ( - critical_skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) = find_minimum_force( - snow_profile, - phi, - li, - k0, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - density=density, - t=t, - ) - - # Exception: the entire solution is cracked - if dist_min > 1: - crack_length = length - skier_weight = 0 - - # Create a longer profile to enable a derivation of the incremental - # ERR of the completely cracked solution - li_complete_crack = [50000] + li + [50000] - ki_complete_crack = [False] * len(ki) - ki_complete_crack = [True] + ki_complete_crack + [True] - k0 = [True] * len(ki_complete_crack) - - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, - skier_weight, - phi, - li_complete_crack, - k0, - crack_case="nocrack", - E=E, - t=t, - ) - - # Solving a cracked solution, to calculate incremental ERR - c_skier, c_C, c_segments, c_x_cm, c_sigma_kPa, c_tau_kPa = create_skier_object( - snow_profile, - skier_weight, - phi, - li_complete_crack, - ki_complete_crack, - crack_case="crack", - E=E, - t=t, - ) - - # Calculate incremental energy released compared to uncracked solution - incr_energy = c_skier.ginc(C0=C, C1=c_C, phi=phi, **c_segments, k0=k0) - g_delta = fracture_toughness_criterion( - 1000 * incr_energy[1], 1000 * incr_energy[2] - ) - - self_collapse = True - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - 0, - elapsed_times, - skier_weights, - crack_lengths, - self_collapse, - False, - critical_skier_weight, - g_delta, - dist_min, - g_delta_values, - dist_min_values, - ) - - elif (dist_min <= 1) and (critical_skier_weight >= 1): - # Set max skier weight as 5x, and minimum weight slightly above the - # found minimum to ensure being outside the stress envelope - skier_weight = critical_skier_weight * 1.005 - max_skier_weight = 5 * skier_weight - min_skier_weight = critical_skier_weight - - # Set initial crack length and error margin - crack_length = 1 - err = 1000 - li = [ - length / 2 - crack_length / 2, - crack_length / 2, - crack_length / 2, - length / 2 - crack_length / 2, - ] - ki = [True, False, False, True] - - while np.abs(err) > 0.002 and iteration_count < max_iterations and any(ki): - # Track skier weight, crack length, dist_max, g_delta, and time for each iteration - iteration_count += 1 - skier_weights.append(skier_weight) - crack_lengths.append(crack_length) - dist_max_values.append(dist_max) - dist_min_values.append(dist_min) - elapsed_times.append(time.time() - start_time) - - # Create base_case with the correct number of segments - k0 = [True] * len(ki) - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, k0, crack_case="nocrack", E=E, t=t - ) - - # Check distance to failure for uncracked solution - distance_to_failure = stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - dist_max = np.max(distance_to_failure) - dist_min = np.min(distance_to_failure) - - # Solving a cracked solution, to calculate incremental ERR - c_skier, c_C, c_segments, c_x_cm, c_sigma_kPa, c_tau_kPa = ( - create_skier_object( - snow_profile, - skier_weight, - phi, - li, - ki, - crack_case="crack", - E=E, - t=t, - ) - ) - - # Calculate incremental energy released compared to uncracked solution - incr_energy = c_skier.ginc(C0=C, C1=c_C, phi=phi, **c_segments, k0=k0) - g_delta = fracture_toughness_criterion( - 1000 * incr_energy[1], 1000 * incr_energy[2] - ) - g_delta_values.append(g_delta) - - # Update error margin - err = np.abs(g_delta - 1) - - if iteration_count == 1 and (g_delta > 1 or err < 0.02): - # Exception: the fracture is governed by a pure stress criterion - # as the fracture toughess envelope is superseded for minmum - # critical skier weight - pure_stress_criteria = True - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - pure_stress_criteria, - critical_skier_weight, - g_delta, - dist_max, - g_delta_values, - dist_max_values, - ) - - # Update of skier weight boundaries - if g_delta < 1: - min_skier_weight = skier_weight - else: - max_skier_weight = skier_weight - - new_skier_weight = (min_skier_weight + max_skier_weight) / 2 - - if np.abs(err) > 0.002: - skier_weight = new_skier_weight - # g_delta_last = g_delta - new_crack_length, li, ki = find_new_anticrack_length( - snow_profile, - skier_weight, - phi, - li, - ki, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - density=density, - t=t, - ) - crack_length = new_crack_length - - # End of loop: convergence or max iterations reached - if iteration_count < max_iterations and any(ki): - if crack_length > 0: - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - g_delta, - dist_max, - g_delta_values, - dist_max_values, - ) - else: - # Call dampened version to attempt to solve certain convergence issues - return check_coupled_criterion_anticrack_nucleation_dampened( - snow_profile, - phi, - skier_weight, - dampening=1, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - t=t, - ) - - elif not any(ki): - # Exception: Entire solution is cracked - should in general not - # happen and is indication of poor assumptions - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - g_delta, - dist_min, - g_delta_values, - dist_min_values, - ) - - else: - return check_coupled_criterion_anticrack_nucleation_dampened( - snow_profile, - phi, - skier_weight, - dampening=1, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - density=density, - ) - - else: - # Rarely occurs - often caused by a skier weight below one kilo - return ( - False, - 0, - critical_skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - 0, - dist_max, - g_delta_values, - dist_max_values, - ) - - -def check_coupled_criterion_anticrack_nucleation_dampened( - snow_profile, - phi, - skier_weight, - dampening=1, - envelope="adam_unpublished", - scaling_factor=1, - E=0.25, - order_of_magnitude=1, - density=250, - t=30, -): - """ - Evaluate coupled criterion for anticrack nucleation using dampened algorithm. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack containing density and - layer-specific properties. - phi : float - Slope angle (degrees). - skier_weight : float - Weight of the skier (kg). - dampening : float, optional - Dampening factor applied to adjust convergence. Default is 1. - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - order_of_magnitude : int, optional - Order of magnitude for scaling law used for 'adam_unpublished'. - Default is 1. - density : float, optional - Weak layer density (kg/mΒ³). Default is 250 kg/mΒ³. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - result : bool - True if the criteria for coupled criterion for anticrack nucleation are - met, otherwise False. - crack_length : float - Length of the anticrack (mm) at the found minimum critical solution. - skier_weight : float - Skier weight (kg) at the found minimum critical solution. - skier : object - Skier object representing the state of the system. - C : ndarray - Free constants of the solution for the skier's loading state. - segments : dict - Segment-specific data for the cracked solution: - - 'li': ndarray of segment lengths (mm). - - 'ki': ndarray of booleans indicating whether a segment lies on - a foundation (True) or not (False) in the cracked configuration. - x_cm : ndarray - Discretized horizontal positions (cm) of the snowpack. - sigma_kPa : ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - iteration_count : int - Number of iterations performed in the optimization algorithm. - elapsed_times : list of float - Elapsed times for each iteration (seconds). - skier_weights : list of float - Skier weights for each iteration (kg). - crack_lengths : list of float - Crack lengths for each iteration (mm). - self_collapse : bool - True if the system is fully cracked without any additional load, - otherwise False. - pure_stress_criteria : bool - True if the fracture toughness criteria is met at the found minimum - critical skier weight, otherwise False. - critical_skier_weight : float - Minimum skier weight (kg) required to surpass stress failure envelope - in one point. - g_delta_last : float - Fracture toughness envelope evaluation of incremental ERR at solution. - dist_max : float - Maximum distance to the stress envelope (non-dimensional). - g_delta_values : list of float - Fracture toughness envelope evaluations of incremental ERR for each - iteration. - dist_max_values : list of float - History of maximum distances to the stress envelope over iterations. - - Notes - ----- - - This algorithm is a dampened version of the coupled criterion algorithm, - intended to improve convergence for challenging cases. - - It begins by finding the minimum critical skier weight and incrementally - adjusts the crack length and skier weight while ensuring stability - through dampened scaling. - - The method is designed to handle instances where rapid oscillations or - multiple cracked segments hinder convergence. - - The fracture toughness criterion is evaluated in J, while ERR differentials - are calculated in kJ. - - """ - - # Trackers - start_time = time.time() - elapsed_times = [] - skier_weights = [] - crack_lengths = [] - dist_max_values = [] - dist_min_values = [] - g_delta_values = [] - - # Initialize parameters - length = 100 * sum(layer[1] for layer in snow_profile) # Total length (mm) - li = [length / 2, 0, 0, length / 2] # Length segments - ki = [True, False, False, True] # Initial crack configuration - k0 = [True] * len(ki) - - # Find minimum critical force to initialize - ( - critical_skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) = find_minimum_force( - snow_profile, - phi, - li, - k0, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - density=density, - t=t, - ) - - if dist_min > 1: - self_collapse = True - crack_length = length - skier_weight = 0 - - # Add 1000 to the start and end of `li` - li_complete_crack = [50000] + li + [50000] - - # Create `ki_complete_crack` with False and add True at start and end - ki_complete_crack = [False] * len(ki) # Matches length of `ki` - ki_complete_crack = [True] + ki_complete_crack + [True] - - # Create `k0` with all True - k0 = [True] * len(ki_complete_crack) - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, - skier_weight, - phi, - li_complete_crack, - k0, - crack_case="nocrack", - E=E, - t=t, - ) - - # Solving a cracked solution, to calculate incremental ERR - c_skier, c_C, c_segments, c_x_cm, c_sigma_kPa, c_tau_kPa = create_skier_object( - snow_profile, - skier_weight, - phi, - li_complete_crack, - ki_complete_crack, - crack_case="crack", - E=E, - t=t, - ) - - # Calculate incremental energy released compared to uncracked solution - incr_energy = c_skier.ginc(C0=C, C1=c_C, phi=phi, **c_segments, k0=k0) - g_delta = fracture_toughness_criterion( - 1000 * incr_energy[1], 1000 * incr_energy[2] - ) - - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - 0, - elapsed_times, - skier_weights, - crack_lengths, - self_collapse, - False, - critical_skier_weight, - g_delta, - dist_min, - g_delta_values, - dist_min_values, - ) - - elif (dist_min <= 1) and (critical_skier_weight >= 1): - crack_length = 1 - err = 1000 - li = [ - length / 2 - crack_length / 2, - crack_length / 2, - crack_length / 2, - length / 2 - crack_length / 2, - ] - ki = [True, False, False, True] - - # Allow 50 iterations in the dampened version - iteration_count = 0 - max_iterations = 50 - - # Need to initialise - skier_weight = critical_skier_weight * 1.005 - min_skier_weight = critical_skier_weight - max_skier_weight = 3 * critical_skier_weight - g_delta_max_weight = 0 - - # New method to ensure that the set max weight will surpass the - # fracture toughness criterion - while g_delta_max_weight < 1: - max_skier_weight = max_skier_weight * 2 - - # Create base_case with the correct number of segments - k0 = [True] * len(ki) - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, - max_skier_weight, - phi, - li, - k0, - crack_case="nocrack", - E=E, - t=t, - ) - - # Solving a cracked solution, to calculate incremental ERR - c_skier, c_C, c_segments, c_x_cm, c_sigma_kPa, c_tau_kPa = ( - create_skier_object( - snow_profile, - max_skier_weight, - phi, - li, - ki, - crack_case="crack", - E=E, - t=t, - ) - ) - - # Calculate incremental energy released compared to uncracked solution - k0 = [True] * len(ki) - incr_energy = c_skier.ginc(C0=C, C1=c_C, phi=phi, **c_segments, k0=k0) - g_delta_max_weight = fracture_toughness_criterion( - 1000 * incr_energy[1], 1000 * incr_energy[2] - ) - - while abs(err) > 0.002 and iteration_count < max_iterations and any(ki): - iteration_count += 1 - skier_weights.append(skier_weight) - crack_lengths.append(crack_length) - elapsed_times.append(time.time() - start_time) - - # Create skier object for uncracked case - k0 = [True] * len(ki) - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - # Check distance to failure - distance_to_failure = stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - dist_max = np.max(distance_to_failure) - dist_min = np.min(distance_to_failure) - dist_max_values.append(dist_max) - dist_min_values.append(dist_min) - - # Cracked solution for energy release - c_skier, c_C, c_segments, c_x_cm, c_sigma_kPa, c_tau_kPa = ( - create_skier_object( - snow_profile, - skier_weight, - phi, - li, - ki, - crack_case="crack", - E=E, - t=t, - ) - ) - - # Incremental energy - incr_energy = c_skier.ginc(C0=C, C1=c_C, phi=phi, **c_segments, k0=k0) - g_delta = fracture_toughness_criterion( - 1000 * incr_energy[1], 1000 * incr_energy[2] - ) - g_delta_values.append(g_delta) - - err = abs(g_delta - 1) - - if iteration_count == 1 and g_delta > 1: - pure_stress_criteria = True - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - pure_stress_criteria, - critical_skier_weight, - g_delta, - dist_max, - g_delta_values, - dist_max_values, - ) - - # Adjust skier boundary weights - if g_delta < 1: - min_skier_weight = skier_weight - else: - max_skier_weight = skier_weight - - new_skier_weight = (min_skier_weight + max_skier_weight) / 2 - - # Apply dampening of algorithm if we are sufficiently close to the - # goal, to avoid non convergence due to oscillation, but ensure we - # do close in on the target - if np.abs(err) < 0.5: - scaling = (dampening + 1 + (new_skier_weight / skier_weight)) / ( - dampening + 1 + 1 - ) # Dampened scaling - else: - scaling = 1 - - if np.abs(err) > 0.002: - # old_skier_weight = skier_weight - skier_weight = scaling * new_skier_weight - # g_delta_last = g_delta - new_crack_length, li, ki = find_new_anticrack_length( - snow_profile, - skier_weight, - phi, - li, - ki, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - density=density, - t=t, - ) - crack_length = new_crack_length - - # Check final convergence - if iteration_count < max_iterations and any(ki): - return ( - True, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - g_delta, - dist_max, - g_delta_values, - dist_max_values, - ) - else: - return ( - False, - crack_length, - skier_weight, - c_skier, - c_C, - c_segments, - c_x_cm, - c_sigma_kPa, - c_tau_kPa, - iteration_count, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - g_delta, - dist_max, - g_delta_values, - dist_max_values, - ) - else: - return ( - False, - 0, - critical_skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - 0, - elapsed_times, - skier_weights, - crack_lengths, - False, - False, - critical_skier_weight, - 0, - dist_max, - g_delta_values, - dist_max_values, - ) - - -def stress_envelope( - sigma, - tau, - envelope="adam_unpublished", - scaling_factor=1, - order_of_magnitude=1, - density=250, -): - """ - Evaluate the stress envelope for given stress components. - - Parameters - ---------- - sigma : array-like - Normal stress components (kPa). Must be non-negative. - tau : array-like - Shear stress components (kPa). Must be non-negative. - envelope : str, optional - Type of stress envelope to evaluate. Options include: - - 'adam_unpublished' (default): Adam unpublished results . - - 'schottner': Schottner's envelope. - - 'mede_s-RG1', 'mede_s-RG2', 'mede_s-FCDH': Mede's criterion with - different parameterizations for specific snow types. - scaling_factor : float, optional - Scaling factor applied to the envelope equations. Default is 1. - order_of_magnitude : float, optional - Exponent used for scaling in certain envelopes. Default is 1. - density : float, optional - Snow density (kg/mΒ³). Used in certain envelope calculations. - Default is 250 kg/mΒ³. - - Returns - ------- - results : ndarray - Non-dimensional stress evaluation values. For most envelopes, - values greater than 1 indicate failure, while values less than 1 - indicate stability. - - Notes - ----- - - Mede's envelopes ('mede_s-RG1', 'mede_s-RG2', 'mede_s-FCDH') are derived - from the work of Mede et al. (2018), "Snow Failure Modes Under Mixed - Loading," published in Geophysical Research Letters. - - SchΓΆttner's envelope ('schottner') is based on the preprint by SchΓΆttner - et al. (2025), "On the Compressive Strength of Weak Snow Layers of - Depth Hoar". - - The 'adam_unpublished' envelope scales with weak layer density linearly - (compared to density baseline) by a 'scaling_factor' - (weak layer density / density baseline), unless modified by - 'order_of_magnitude'. - - Mede's criteria ('mede_s-RG1', 'mede_s-RG2', 'mede_s-FCDH') define - failure based on a piecewise function of stress ranges. - - Raises - ------ - ValueError - If an invalid `envelope` type is provided. - - """ - - sigma = np.abs(np.asarray(sigma)) - tau = np.abs(np.asarray(tau)) - results = np.zeros_like(sigma) - - if envelope == "adam_unpublished": - # Case for 'adam_unpublished' - # Rescaling emulates previous literature best using a density baseline - # of 250 kg/m^3 and order of magnitude 3 - - # Ensuring sublinear scaling for weak layer densities above 250 kg/m^3 - if scaling_factor > 1: - order_of_magnitude = 0.7 - - if scaling_factor < 0.55: - scaling_factor = 0.55 - - sigma_c = 6.16 * (scaling_factor**order_of_magnitude) # (kPa) 6.16 / 2.6 - tau_c = 5.09 * (scaling_factor**order_of_magnitude) # (kPa) 5.09 / 0.7 - - return (sigma / sigma_c) ** 2 + (tau / tau_c) ** 2 - - elif envelope == "schottner": - rho_ice = 916.7 - sigma_y = 2000 - sigma_c_adam = 6.16 - tau_c_adam = 5.09 - - sigma_c = sigma_y * 13 * (density / rho_ice) ** order_of_magnitude - tau_c = tau_c_adam * (sigma_c / sigma_c_adam) - - return (sigma / sigma_c) ** 2 + (tau / tau_c) ** 2 - - # Case for 'mede_s-RG1' - elif envelope == "mede_s-RG1": - p0 = 7.00 - tau_T = 3.53 - p_T = 1.49 - - # Condition for sigma within range of p_T-p0 to p_T - in_first_range = (sigma >= (p_T - p0)) & (sigma <= p_T) - - # Condition for sigma in second range: p_T to p_T + p0 - in_second_range = sigma > p_T - - # Apply the calculation for values in the first range - results[in_first_range] = ( - -tau[in_first_range] * (p0 / (tau_T * p_T)) - + sigma[in_first_range] * (1 / p_T) - + p0 / p_T - ) - - # Apply the calculation for values in the second range - results[in_second_range] = (tau[in_second_range] ** 2) + ((tau_T / p0) ** 2) * ( - (sigma[in_second_range] - p_T) ** 2 - ) - return results - - elif envelope == "mede_s-RG2": - p0 = 2.33 - tau_T = 1.22 - p_T = 0.19 - - # Condition for sigma within range of p_T-p0 to p_T - in_first_range = (sigma >= (p_T - p0)) & (sigma <= p_T) - - # Condition for sigma in second range: p_T to p_T + p0 - in_second_range = sigma > p_T - - # Apply the calculation for values in the first range - results[in_first_range] = ( - -tau[in_first_range] * (p0 / (tau_T * p_T)) - + sigma[in_first_range] * (1 / p_T) - + p0 / p_T - ) - - # Apply the calculation for values in the second range - results[in_second_range] = (tau[in_second_range] ** 2) + ((tau_T / p0) ** 2) * ( - (sigma[in_second_range] - p_T) ** 2 - ) - return results - - elif envelope == "mede_s-FCDH": - p0 = 1.45 - tau_T = 0.61 - p_T = 0.17 - - # Condition for sigma within range of p_T-p0 to p_T - in_first_range = (sigma >= (p_T - p0)) & (sigma <= p_T) - - # Condition for sigma in second range: p_T to p_T + p0 - in_second_range = sigma > p_T - - # Apply the calculation for values in the first range - results[in_first_range] = ( - -tau[in_first_range] * (p0 / (tau_T * p_T)) - + sigma[in_first_range] * (1 / p_T) - + p0 / p_T - ) - - # Apply the calculation for values in the second range - results[in_second_range] = (tau[in_second_range] ** 2) + ((tau_T / p0) ** 2) * ( - (sigma[in_second_range] - p_T) ** 2 - ) - return results - - else: - raise ValueError("Invalid envelope type. Choose 'adam_unpublished' ") - - -# Kill x_value? -def find_roots_around_x( - skier, - C, - li, - phi, - sigma_kPa, - tau_kPa, - x_cm, - envelope="adam_unpublished", - scaling_factor=1, - order_of_magnitude=1, - density=250, -): - """ - Exact solution of position where stresses surpass failure envelope boundary. - - Parameters - ---------- - x_value : float - The initial x-value to search for roots around (mm). - skier : object - Skier object representing the state of the system. - C : ndarray - Free constants of the solution for the skier's loading state. - li : ndarray - Segment lengths (mm). - phi : float - Slope angle (degrees). - sigma_kPa : ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - x_cm : ndarray - Discretized horizontal positions (cm) of the snowpack. - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - order_of_magnitude : float, optional - Exponent used for scaling in certain envelopes. Default is 1. - density : float, optional - Weak layer density (kg/mΒ³). Default is 250 kg/mΒ³. - - Returns - ------- - roots : list of float - The x-coordinates (mm) of the roots found around the given x-value. - - Notes - ----- - - The function finds the root search intervals based on stress evaluations of - the discretized positions, and then finds the exact solution. - - - Raises - ------ - ValueError - If no root can be found within the identified bracket. - """ - - # Define the function for the root function - def func(x): - return root_function( - x, - skier, - C, - li, - phi, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - - # Calculate the discrete distance to failure using the envelope function - discrete_dist_to_fail = ( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - - 1 - ) - - # Find indices where the envelope function transitions from positive to negative - transition_indices = np.where(np.diff(np.sign(discrete_dist_to_fail)))[0] - - # Lists to store indices and values of local minima and maxima - local_minima_indices = [] - local_maxima_indices = [] - local_minima_values = [] - local_maxima_values = [] - - # Loop through the list (ignoring the first and last elements) - for i in range(1, len(discrete_dist_to_fail) - 1): - # Check for local maximum - if ( - discrete_dist_to_fail[i] > discrete_dist_to_fail[i - 1] - and discrete_dist_to_fail[i] > discrete_dist_to_fail[i + 1] - ): - local_maxima_indices.append(i) - local_maxima_values.append(discrete_dist_to_fail[i]) - - # Check for local minimum - elif ( - discrete_dist_to_fail[i] < discrete_dist_to_fail[i - 1] - and discrete_dist_to_fail[i] < discrete_dist_to_fail[i + 1] - ): - local_minima_indices.append(i) - local_minima_values.append(discrete_dist_to_fail[i]) - - # Extract the corresponding x_cm values at those transition indices - root_candidates = [] - for idx in transition_indices: - # Get the x_cm values surrounding the transition - x_left = x_cm[idx] - x_right = x_cm[idx + 1] - root_candidates.append((10 * x_left, 10 * x_right)) - # Adding one millimetre on each side - - # Search for roots within the identified candidates - roots = [] - for x_left, x_right in root_candidates: - try: - root_result = root_scalar(func, bracket=[x_left, x_right], method="brentq") - if root_result.converged: - roots.append(root_result.root) - except ValueError: - print(f"No root found between x = {x_left} and x = {x_right}.") - - return roots - - -# The root function we seek to minimize -def root_function( - x_value, - skier, - C, - li, - phi, - envelope="adam_unpublished", - scaling_factor=1, - order_of_magnitude=1, - density=250, -): - """ - Compute the root function value at a given x-coordinate. - - Returns - ------- - float - The result of the stress envelope evaluation minus 1. A value of 0 - indicates the system is on the stability boundary, values < 0 indicate - stability, and values > 0 indicate failure. - - """ - - sigma, tau = calculate_sigma_tau(x_value, skier, C, li, phi) - return ( - stress_envelope( - sigma, - tau, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - - 1 - ) - - -def calculate_sigma_tau(x_value, skier, C, li, phi): - """ - Calculate normal and shear stresses at a given horizontal x-coordinate. - - Parameters - ---------- - x_value : float - The x-coordinate (mm) where stresses are calculated. - skier : object - Skier object representing the state of the system. - C : ndarray - Free constants of the solution for the skier's loading state. - li : list or ndarray - Segment lengths (mm). - phi : float - Slope angle (degrees). - - Returns - ------- - sigma : float - Normal stress (kPa) at the given x-coordinate. - tau : float - Shear stress (kPa) at the given x-coordinate. - - Notes - ----- - - Shear stress ('tau') is returned with a switched sign to match - the system's convention. - - - """ - segment_index, coordinate_in_segment = find_segment_index(li, x_value) - Z = skier.z(coordinate_in_segment, C, li[segment_index], phi, bed=True) - t = skier.tau(Z, unit="kPa") - s = skier.sig(Z, unit="kPa") - - tau = -t[segment_index] # Remember to switch sign - sigma = s[segment_index] - return sigma, tau - - -# segment_lengths should be li -def find_segment_index(segment_lengths, coordinate): - """ - Determine the index of the segment containing a given coordinate. Help method - to place skier point mass in centered position. - - Parameters - ---------- - segment_lengths : list, ndarray, or float - Lengths of the segments (mm). - coordinate : float - The coordinate (mm) to locate within the segments. - - Returns - ------- - index : int - Index of the segment containing the coordinate. Returns -1 if the - coordinate exceeds all segments. - relative_value : float or None - Coordinate value relative to the start of the identified segment. - Returns None if the coordinate exceeds all segments. - - """ - - # Handle the case where segment_lengths is a single integer - if isinstance(segment_lengths, (int, float)): - return 0, coordinate # Return index 0 and the coordinate as the relative value - - # Convert segment_lengths to an array if it's a list - segment_lengths = np.asarray(segment_lengths) - - # Check for singular segment - if len(segment_lengths) == 1: - return 0, coordinate # Return index 0 and the coordinate as the relative value - - cumulative_length = 0 - - for index, length in enumerate(segment_lengths): - cumulative_length += length - if coordinate <= cumulative_length: - # Calculate the relative value within the segment - relative_value = coordinate - (cumulative_length - length) - return index, relative_value - - return -1, None # Return -1 if coordinate exceeds all segments - - -def find_new_anticrack_length( - snow_profile, - skier_weight, - phi, - li, - ki, - envelope="adam_unpublished", - scaling_factor=1, - E=0.25, - order_of_magnitude=1, - density=250, - t=30, -): - """ - Find the resulting anticrack length and updated segment configurations, - for a given skier weight. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack. - skier_weight : float - Weight of the skier (kg). - phi : float - Slope angle (degrees). - li : list or ndarray - Current segment lengths (mm). - ki : list of bool - Boolean flags indicating whether each segment lies on a foundation - (True) or is cracked (False). - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - order_of_magnitude : float, optional - Exponent used for scaling in certain envelopes. Default is 1. - density : float, optional - Snow density (kg/mΒ³). Default is 250 kg/mΒ³. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - new_crack_length : float - Length of the skier weight implied anticrack (mm). - li : list of float - Updated segment lengths (mm). - ki : list of bool - Updated boolean flags indicating the foundation state of segments. - - Notes - ----- - - The segment lengths and foundations are split at the center, assuming point - load mass from the skier is centered. - - """ - - # Initialize object - total_length = np.sum(li) - midpoint = total_length / 2 - li = [midpoint, midpoint] - ki = [True, True] - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - all_points_are_outside = ( - np.min( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - > 1 - ) - - # Finding all horizontal positions (roots) where the stress envelope - # function crosses the boundary - roots_x = find_roots_around_x( - skier, - C, - li, - phi, - sigma_kPa, - tau_kPa, - x_cm, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - - if len(roots_x) > 0: - # Method to reconstruct li and ki - segment_boundaries = [0] + roots_x + [total_length] - li_temp = np.diff(segment_boundaries).tolist() # Convert to a list - ki_temp = [True] * (len(segment_boundaries) - 1) - - # Create a boolean list indicating root positions - is_root = [False] * len(segment_boundaries) - for root in roots_x: - is_root[segment_boundaries.index(root)] = True - - # Iterate over the roots to determine cracked segments - cracked_segment = True - - for i in range(1, len(is_root)): # Start from the second root - # Check if the current and previous boundaries are both roots - if is_root[i] and (is_root[i - 1]) and cracked_segment: - ki_temp[i - 1] = False # Mark the segment as cracked - cracked_segment = not cracked_segment - # A cracked segment, if there exists more than one, will always - # switch between cracked and uncracked - - elif is_root[i] and (is_root[i - 1]) and (not cracked_segment): - # These are uncracked segments, i.e. they have support - ki_temp[i - 1] = True - cracked_segment = not cracked_segment - - # Proceed to split li and ki at the midpoint - li, ki = split_segments_at_midpoint(li_temp, ki_temp) - - elif all_points_are_outside: - ki = [False] * len(ki) - else: - # No changes to li and ki - li = li - ki = [True] * len(ki) - - # Calculate new crack length - new_crack_length = sum( - length for length, foundation in zip(li, ki) if not foundation - ) - - return new_crack_length, li, ki - - -def split_segments_at_midpoint(segment_lengths, segment_support): - """ - Split segments at the midpoint of the total length. - - Parameters - ---------- - segment_lengths : list of float - Lengths of the segments (mm). - segment_support : list of bool - Boolean flags indicating whether each segment is supported (True) - or not (False). - - Returns - ------- - new_segments : list of float - Updated segment lengths after splitting at the midpoint. - new_support : list of bool - Updated support flags for the new segments. - - """ - - # Calculate the cumulative lengths of segments to find the midpoint - cumulative_lengths = np.cumsum(segment_lengths) - total_length = cumulative_lengths[-1] - midpoint = total_length / 2 - - # Find the segment that contains the midpoint - for i, length in enumerate(segment_lengths): - if cumulative_lengths[i] >= midpoint: - # Split the segment at the exact midpoint - if i == 0: - # If the midpoint is in the first segment - new_segments = [midpoint] + segment_lengths[ - i: - ] # split before the first segment - new_support = [segment_support[0]] + segment_support[ - i: - ] # retain support value - else: - # Split the found segment at the midpoint - segment_start = cumulative_lengths[i - 1] if i > 0 else 0 - new_segments = ( - segment_lengths[:i] - + [midpoint - segment_start] - + [cumulative_lengths[i] - midpoint] - + segment_lengths[i + 1 :] - ) - # Split support for the two new segments - new_support = ( - segment_support[:i] - + [segment_support[i]] - + [segment_support[i]] - + segment_support[i + 1 :] - ) - break - else: - # If no segment contains the midpoint, return the original segments and support - return segment_lengths, segment_support - - return new_segments, new_support - - -def find_minimum_force( - snow_profile, - phi, - li, - ki, - envelope="adam_unpublished", - scaling_factor=1, - E=0.25, - order_of_magnitude=1, - density=250, - t=30, -): - """ - Find the minimum skier weight at which the stress failure envelope is surpassed - in one point. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack. - phi : float - Slope angle (degrees). - li : list or ndarray - Segment lengths (mm). - ki : list of bool - Boolean flags indicating whether each segment lies on a foundation (True) - or is cracked (False). - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - order_of_magnitude : float, optional - Exponent used for scaling in certain envelopes. Default is 1. - density : float, optional - Weak layer density (kg/mΒ³). Default is 250 kg/mΒ³. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - skier_weight : float - Critical skier weight (kg) required to surpass the stress failure envelope. - skier : object - Skier object representing the system at the critical state. - C : ndarray - Free constants of the solution for the skier's loading state. - segments : dict - Segment-specific data of the cracked configuration. - x_cm : ndarray - Discretized horizontal positions (cm) of the snowpack. - sigma_kPa : ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - dist_max : float - Maximum distance to the stress envelope (non-dimensional). - dist_min : float - Minimum distance to the stress envelope (non-dimensional). - - Notes - ----- - - The algorithm iteratively adjusts the skier weight until the maximum - distance to the stress envelope converges to 1 (indicating critical state). - - If convergence is not achieved within 50 iterations, the dampened version - of the method ('find_minimum_force_dampened') is called. - - """ - - # Initial parameters - skier_weight = 1 # Starting weight of skier - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - # Calculate the distance to failure - dist_max = np.max( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - dist_min = np.min( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - - if dist_min >= 1: - # We are outside the stress envelope without any additional skier weight - return ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) - - iteration_count = 0 - - # While the stress envelope boundary is not superseeded in any point - while np.abs(dist_max - 1) > 0.005 and iteration_count < 50: - # Scale with the inverse of the distance to stress failure envelope - skier_weight = skier_weight / dist_max - - # Recreate the skier object with the updated weight - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - # Recalculate the distance to failure (stress envelope) - dist_max = np.max( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - dist_min = np.min( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - iteration_count = iteration_count + 1 - - if iteration_count == 50: - ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) = find_minimum_force_dampened( - snow_profile, - phi, - li, - ki, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - dampening=1, - density=density, - t=t, - ) - - # Once the loop exits, the critical skier weight has been found - return ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) - - -def find_minimum_force_dampened( - snow_profile, - phi, - li, - ki, - envelope="adam_unpublished", - scaling_factor=1, - E=0.25, - order_of_magnitude=1, - dampening=1, - density=250, - t=30, -): - """ - Dampened version of algorithm to find the minimum skier weight at which the - stress failure envelope is surpassed in one point. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack. - phi : float - Slope angle (degrees). - li : list or ndarray - Segment lengths (mm). - ki : list of bool - Boolean flags indicating whether each segment lies on a foundation (True) - or is cracked (False). - envelope : str, optional - Type of stress failure envelope. Default is 'adam_unpublished'. - scaling_factor : float, optional - Scaling factor applied to the stress envelope. Default is 1. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - order_of_magnitude : float, optional - Exponent used for scaling in certain envelopes. Default is 1. - dampening : float, optional - Dampening factor for the adjustment of skier weight. Default is 1. - density : float, optional - Weak layer density (kg/mΒ³). Default is 250 kg/mΒ³. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - skier_weight : float - Critical skier weight (kg) required to surpass the stress failure envelope. - skier : object - Skier object representing the system at the critical state. - C : ndarray - Free constants of the solution for the skier's loading state. - segments : dict - Segment-specific data of the cracked configuration. - x_cm : ndarray - Discretized horizontal positions (cm) of the snowpack. - sigma_kPa : ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - dist_max : float - Maximum distance to the stress envelope (non-dimensional). - dist_min : float - Minimum distance to the stress envelope (non-dimensional). - - Notes - ----- - - If convergence is not achieved within 50 iterations, the dampening factor - is incremented recursively up to a limit of 5. - - """ - - skier_weight = 1 # Starting weight of skier - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - # Calculate the distance to failure - dist_max = np.max( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - dist_min = np.min( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - - if dist_min >= 1: - # We are outside the stress envelope without any additional skier weight - return ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) - - iteration_count = 0 - - # If the regular version did not work, it might be because error margin was too small - while np.abs(dist_max - 1) > 0.01 and iteration_count < 50: - # Weighted scaling factor to reduce large oscillations - skier_weight = (dampening + 1) * skier_weight / (dampening + dist_max) - - # Recreate the skier object with the updated weight - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, skier_weight, phi, li, ki, crack_case="nocrack", E=E, t=t - ) - - # Recalculate the distance to failure - dist_max = np.max( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - dist_min = np.min( - stress_envelope( - sigma_kPa, - tau_kPa, - envelope=envelope, - scaling_factor=scaling_factor, - order_of_magnitude=order_of_magnitude, - density=density, - ) - ) - iteration_count = iteration_count + 1 - - if iteration_count == 50: - if dampening < 5: - ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) = find_minimum_force_dampened( - snow_profile, - phi, - li, - ki, - envelope=envelope, - scaling_factor=scaling_factor, - E=E, - order_of_magnitude=order_of_magnitude, - dampening=dampening + 1, - density=density, - t=t, - ) - - else: - return 0, skier, C, segments, x_cm, sigma_kPa, tau_kPa, dist_max, dist_min - - return ( - skier_weight, - skier, - C, - segments, - x_cm, - sigma_kPa, - tau_kPa, - dist_max, - dist_min, - ) - - -def find_min_crack_length_self_propagation( - snow_profile, phi, E, t, initial_interval=(1, 3000) -): - """ - Find the minimum crack length required for self-propagation. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack. - phi : float - Slope angle (degrees). - E : float - Elastic modulus (MPa) of the snow layers. - t : float - Weak layer thickness (mm). - initial_interval : tuple of float, optional - Interval (in mm) within which to search for the minimum crack length. - Default is (1, 3000). - - Returns - ------- - crack_length : float or None - The minimum crack length (mm) required for self-propagation if found, - or None if the search did not converge. - - Notes - ----- - - The crack propagation criterion evaluates the fracture toughness of the - differential ERR of an existing crack, without any additional skier - weight (self propagation). - """ - - # Define the interval for crack_length search - a, b = initial_interval - - # Use root_scalar to find the root - result = root_scalar( - g_delta_diff_objective, - args=(snow_profile, phi, E, t), - bracket=[a, b], # Interval where the root is expected - method="brentq", # Brent's method - ) - - if result.converged: - return result.root - else: - print("Root search did not converge.") - return None - - -def g_delta_diff_objective(crack_length, snow_profile, phi, E, t, target=1): - """ - Objective function to evaluate the fracture toughness function. - - Parameters - ---------- - crack_length : float - Length of the crack (mm). - snow_profile : object - Layered representation of the snowpack. - phi : float - Slope angle (degrees). - E : float - Elastic modulus (MPa) of the snow layers. - t : float - Weak layer thickness (mm). - target : float, optional - Target value for the fracture toughness function. Default is 1. - - Returns - ------- - difference : float - Difference between fracture toughness envelope function and the boundary - (value equal to one). Positive values indicate the energy release rate - exceeds the target. - - """ - # Initialize parameters - length = 1000 * sum(layer[1] for layer in snow_profile) # Total length (mm) - li = [ - (length / 2 - crack_length / 2), - (crack_length / 2), - (crack_length / 2), - (length / 2 - crack_length / 2), - ] # Length segments - ki = [True, False, False, True] # Length of segments with foundations - - # Create skier object - skier, C, segments, x_cm, sigma_kPa, tau_kPa = create_skier_object( - snow_profile, 0, phi, li, ki, crack_case="crack", E=E, t=t - ) - - # Calculate differential ERR - diff_energy = skier.gdif(C=C, phi=phi, **segments) - - # Evaluate the fracture toughness function (boundary is equal to 1) - g_delta_diff = fracture_toughness_criterion( - 1000 * diff_energy[1], 1000 * diff_energy[2] - ) - - # Return the difference from the target - return g_delta_diff - target - - -def failure_envelope_mede(sigma, sample_type="s-RG1"): - """ - Compute the shear stress (Ο„) for a given compression strength (Οƒ) based on the - failure envelope parameters. Used for plots. - - Parameters - ---------- - sigma : array-like - Array of compression strengths (Οƒ) (kPa). - sample_type : str, optional - Type of snow sample for failure envelope calculation. Options are: - - 's-RG1': Represents rounded grains (type 1). - - 's-RG2': Represents rounded grains (type 2). - - 's-FCDH': Represents facets with depth hoar. - Default is 's-RG1'. - - Returns - ------- - tau : np.ndarray - Shear stresses (Ο„) (kPa) calculated for the given compression strengths (Οƒ). - - Raises - ------ - ValueError - If an invalid `sample_type` is provided. - - Notes - ----- - - The failure envelope is defined by two intervals of Οƒ: - 1. For Οƒ in [p_T - p_0, p_T], Ο„ is calculated linearly. - 2. For Οƒ in (p_T, p_T + p_0], Ο„ is calculated using a parabolic relationship. - - The parameters (p_0, Ο„_T, p_T) are specific to each sample type and - are derived from the study by Mede et al. (2018). - - References - ---------- - Mede, T., Chambon, G., Hagenmuller, P., & Nicot, F. (2018). "Snow Failure - Modes Under Mixed Loading." Geophysical Research Letters, 45(24), - 13351-13358. https://doi.org/10.1029/2018GL080637 - - """ - - # Failure envelope parameters for different sample types - if sample_type == "s-RG1": - p0 = 7.00 - tau_T = 3.53 - p_T = 1.49 - elif sample_type == "s-RG2": - p0 = 2.33 - tau_T = 1.22 - p_T = 0.19 - elif sample_type == "s-FCDH": - p0 = 1.45 - tau_T = 0.61 - p_T = 0.17 - else: - raise ValueError("Invalid sample type. Choose 's-RG1', 's-RG2', or 's-FCDH'.") - - # Ensure sigma is a numpy array for element-wise operations - sigma = np.asarray(sigma) - - # Initialize tau array to store the shear stresses - tau = np.zeros_like(sigma) - - # First interval: pT - p0 <= p <= pT - condition_1 = (sigma >= p_T - p0) & (sigma <= p_T) - tau[condition_1] = (tau_T / p0) * sigma[condition_1] + (tau_T - (tau_T * p_T / p0)) - - # Second interval: pT < p <= pT + p0 - condition_2 = (sigma > p_T) & (sigma <= p_T + p0) - tau[condition_2] = np.sqrt( - tau_T**2 - (tau_T**2) / (p0**2) * ((sigma[condition_2] - p_T) ** 2) - ) - - return tau - - -def failure_envelope_adam_unpublished(x, scaling_factor=1, order_of_magnitude=1): - """ - Compute the shear stress (Ο„) for a given normal stress (Οƒ) based on the - unpublished failure envelope model by Adam. Used for plots. - - Parameters - ---------- - x : array-like or float - Normal stress values (Οƒ) (kPa). - scaling_factor : float, optional - Scaling factor applied to the failure envelope. Default is 1. - order_of_magnitude : float, optional - Exponent used for scaling the critical parameters. Default is 1. - - Returns - ------- - tau : np.ndarray - Shear stress (Ο„) (kPa) calculated based on the failure envelope model. - Values are zero outside the bounds of Β±Οƒ_c. - - """ - - # Ensure x is a numpy array for element-wise operations - x = np.asarray(x) - - # Define critical parameters for failure envelope calculation - sigma_c = 6.16 * (scaling_factor**order_of_magnitude) # (kPa) - tau_c = 5.09 * (scaling_factor**order_of_magnitude) # (kPa) - - # Calculate shear stress based on the failure envelope equation - return np.where( - (x >= -sigma_c) & (x <= sigma_c), # condition: sigma_c bounds - np.sqrt(1 - (x**2 / sigma_c**2)) * tau_c, # equation for valid range - 0, # otherwise, return 0 - ) - - -def failure_envelope_schottner(x, order_of_magnitude=1, density=250): - """ - Compute the shear stress (Ο„) for a given normal stress (Οƒ) based on - the failure envelope model by SchΓΆttner et al. - - Parameters - ---------- - x : array-like or float - Normal stress values (Οƒ) (kPa). - order_of_magnitude : float, optional - Exponent used for scaling the critical parameters. Default is 1. - density : float, optional - Snow density (kg/mΒ³). Default is 250 kg/mΒ³. - - Returns - ------- - tau : np.ndarray - Shear stress (Ο„) (kPa) calculated based on the failure envelope model. - Values are zero outside the bounds of Β±Οƒ_c. - - References - ---------- - SchΓΆttner, J., Walet, M., Rosendahl, P., Weißgraeber, P., Adam, V., Walter, B., - Rheinschmidt, F., LΓΆwe, H., Schweizer, J., & van Herwijnen, A. (2025). "On the - Compressive Strength of Weak Snow Layers of Depth Hoar." Preprint, WSL Institute - for Snow and Avalanche Research SLF, TU Darmstadt, University of Rostock. - - """ - # Ensure x is a numpy array for element-wise operations - x = np.asarray(x) - - rho_ice = 916.7 - sigma_y = 2000 - sigma_c_adam = 6.16 - tau_c_adam = 5.09 - - sigma_c = sigma_y * 13 * (density / rho_ice) ** order_of_magnitude - tau_c = tau_c_adam * (sigma_c / sigma_c_adam) - - # Calculate shear stress based on the failure envelope equation - return np.where( - (x >= -sigma_c) & (x <= sigma_c), # condition: sigma_c bounds - np.sqrt(1 - (x**2 / sigma_c**2)) * tau_c, # equation for valid range - 0, # otherwise, return 0 - ) - - -def failure_envelope_chandel(sigma, sample_type="FCsf"): - """ - Compute the shear stress (Ο„) for a given normal stress (Οƒ) based on the - Chandel failure envelope model. Used for plots. - - Parameters - ---------- - sigma : array-like - Normal stress values (Οƒ) (kPa). - sample_type : str, optional - Type of snow sample for failure envelope calculation. Options are: - - 'FCsf': Represents near-surface faceted particles. - - 'FCso': Represents faceted snow. - Default is 'FCsf'. - - Returns - ------- - tau : np.ndarray - Shear stress (Ο„) (kPa) calculated for the given normal stress (Οƒ). - - Raises - ------ - ValueError - If an invalid `sample_type` is provided. - - References - ---------- - Chandel, C., Srivastava, P., Mahajan, P., & Kumar, V. (2014). "The behaviour - of snow under the effect of combined compressive and shear loading." - Current Science, 107(5), 888-894. - - """ - # Ensure sigma is an array - sigma = np.asarray(sigma) - tau = np.zeros_like(sigma) - - # Define parameters based on sample type - if sample_type == "FCso": # FCsf model - sigma_C = 7.5 # Compressive strength (kPa) - sigma_Tmax = 2.5 # Threshold stress (kPa) - c = 7.3 # Cohesion (kPa) - phi = 22 # Friction angle (degrees) - - tau_max = c + sigma_Tmax * np.tan(np.radians(phi)) # Maximum shear stress (kPa) - - condition_1 = (sigma <= sigma_Tmax) & (sigma >= 0) - tau[condition_1] = c + sigma[condition_1] * np.tan(np.radians(phi)) - - condition_2 = (sigma > sigma_Tmax) & (sigma <= sigma_C) - tau[condition_2] = tau_max * np.sqrt( - 1 - ((sigma[condition_2] - sigma_Tmax) / (sigma_C - sigma_Tmax)) ** 2 - ) - - elif sample_type == "FCsf": # FCso model - tau0 = 4.1 # Maximum shear stress (kPa) - sigma0 = 6.05 - - condition_1 = (sigma <= sigma0) & (sigma >= 0) - tau[condition_1] = tau0 * np.sqrt(1 - ((sigma[condition_1] / sigma0) ** 2)) - - else: - raise ValueError("Unknown sample type. Choose from ['FCsf', 'FCso']") - - return tau - - -def fracture_toughness_envelope(G_I): - """ - Compute the Mode II energy release rate (G_II) as a function of the Mode I - energy release rate (G_I), given Adam fracture toughness envelope. Used for plots. - - Parameters - ---------- - G_I : array-like or float - Mode I energy release rate (ERR) values (J/mΒ²). - - Returns - ------- - G_II : np.ndarray - Corresponding Mode II energy release rate (ERR) values (J/mΒ²). - Values are zero for G_I outside the range [0, G_Ic]. - - """ - # Ensure G_I is a numpy array - G_I_values = np.array(G_I) - - # Define the critical values and parameters - G_Ic = 0.56 # Critical value of G_I in J/m^2 - G_IIc = 0.79 # Critical value of G_II in J/m^2 - n = 5.0 # Exponent for G_I - m = 2.2 # Exponent for G_II - - # Mask for valid G_I values (between 0 and G_Ic) - valid_mask = (G_I_values >= 0) & (G_I_values <= G_Ic) - - # Initialize G_II_values with zeros - G_II_values = np.zeros_like(G_I_values) - - # Calculate G_II for valid G_I values - G_II_values[valid_mask] = G_IIc * (1 - (G_I_values[valid_mask] / G_Ic) ** n) ** ( - 1 / m - ) - - return G_II_values - - -# This is latest: keep -def create_skier_object( - snow_profile, skier_weight_x, phi, li_x, ki_x, crack_case="nocrack", E=0.25, t=30 -): - """ - Create and configure a skier object to represent the layered snowpack system. - - Parameters - ---------- - snow_profile : object - Layered representation of the snowpack. - skier_weight_x : float - Weight of the skier (kg) applied to the snowpack. - phi : float - Slope angle (degrees). - li_x : list of float - Segment lengths (mm). - ki_x : list of bool - Boolean flags indicating whether each segment lies on a foundation (True) - or is cracked (False). - crack_case : str, optional - Configuration of the snowpack. Options are: - - 'nocrack': Represents an uncracked snowpack (default). - - 'crack': Represents a cracked snowpack. - E : float, optional - Elastic modulus (MPa) of the snow layers. Default is 0.25 MPa. - t : float, optional - Weak layer thickness (mm). Default is 30 mm. - - Returns - ------- - skier : object - Configured skier object representing the snowpack. - C : ndarray - Solution constants for the skier's loading state. - segments : dict - Segment-specific data based on the crack configuration: - - 'li': Segment lengths (mm). - - 'ki': Foundation flags. - - 'mi': Distributed skier weight (kg). - - 'k0': Uncracked solution flags. - x_cm : np.ndarray - Discretized horizontal positions (cm) of the snowpack. - sigma_kPa : np.ndarray - Weak-layer normal stresses (kPa) at discretized horizontal positions. - tau_kPa : np.ndarray - Weak-layer shear stresses (kPa) at discretized horizontal positions. - - """ - - # Define a skier object - skiers is used to allow for multiple cracked segments - skier = weac.Layered(system="skiers", layers=snow_profile) - skier.set_foundation_properties(E=E, t=t, update=True) - - n = len(ki_x) - 1 - - # Calculate the total sum of the array - mi_x = np.zeros(n) - - # Initialize cumulative sum and find median index of where to apply skier force - cumulative_sum = 0 - median_index = -1 # Initialize median_index - - total_length = sum(li_x) - half_sum = total_length / 2 # Half of the total sum (median point) - - for i, value in enumerate(li_x): - cumulative_sum += value - - if cumulative_sum >= half_sum: - if li_x[i + 1] == 0: - median_index = i + 1 - else: - median_index = i - break - - mi_x[median_index] = skier_weight_x # Assign skier_weight to the median index - k0 = np.full(len(ki_x), True) - - # Calculate segments based on crack case: 'nocrack' or 'crack' - segments = skier.calc_segments( - li=li_x, # Use the lengths of the segments - ki=ki_x, - mi=mi_x, - k0=k0, # Use the boolean flags - )[crack_case] # Switch between 'crack' or 'nocrack' - - # Solve and rasterize the solution - C = skier.assemble_and_solve(phi=phi, **segments) - xsl_skier, z_skier, xwl_skier = skier.rasterize_solution( - C=C, phi=(phi), num=800, **segments - ) - - # Calculate compressions and shear stress - x_cm, tau_kPa = skier.get_weaklayer_shearstress(x=xwl_skier, z=z_skier, unit="kPa") - x_cm, sigma_kPa = skier.get_weaklayer_normalstress( - x=xwl_skier, z=z_skier, unit="kPa" - ) - - return skier, C, segments, x_cm, sigma_kPa, tau_kPa - - -def fracture_toughness_criterion(G_sigma, G_tau): - """ - Evaluate the fracture toughness criterion for a given combination of - compression (G_sigma) and shear (G_tau) energy release rates (ERR). - - Parameters - ---------- - G_sigma : float or np.ndarray - Mode I energy release rate (ERR) (J/mΒ²). - G_tau : float or np.ndarray - Mode II energy release rate (ERR) (J/mΒ²). - - Returns - ------- - g_delta : float or np.ndarray - Non-dimensional evaluation of the fracture toughness envelope function. A value - of 1 indicates that the boundary of the fracture toughness envelope is reached. - - Notes - ----- - - The fracture toughness criterion is defined as: - g_delta = (|G_sigma| / G_Ic)^n + (|G_tau| / G_IIc)^m - where: - G_Ic = 0.56 J/mΒ² (critical Mode I ERR) - G_IIc = 0.79 J/mΒ² (critical Mode II ERR) - n = 1 / 0.2 = 5.0 (exponent for G_sigma) - m = 1 / 0.45 β‰ˆ 2.22 (exponent for G_tau) - - The criterion is based on the parametrization from Valentin Adam et al. (2024). - - References - ---------- - Adam, V., Bergfeld, B., & Weißgraeber, P. (2024). "Fracture toughness of mixed-mode - anticracks in highly porous materials." Nature Communications. - - """ - - compression_toughness = 0.56 - n = 1 / 0.2 - shear_toughness = 0.79 - m = 1 / 0.45 - - g_delta = (np.abs(G_sigma) / compression_toughness) ** n + ( - np.abs(G_tau) / shear_toughness - ) ** m - - return g_delta diff --git a/misc/Screenshot 2025-07-14 at 17.39.26.png b/misc/Screenshot 2025-07-14 at 17.39.26.png new file mode 100644 index 0000000..e046f6e Binary files /dev/null and b/misc/Screenshot 2025-07-14 at 17.39.26.png differ diff --git a/misc/visualization.drawio.png b/misc/visualization.drawio.png new file mode 100644 index 0000000..8a7b07f Binary files /dev/null and b/misc/visualization.drawio.png differ diff --git a/misc/visualization.svg b/misc/visualization.svg new file mode 100644 index 0000000..ba61a8f --- /dev/null +++ b/misc/visualization.svg @@ -0,0 +1 @@ +
Number of Segments
Number of Segments
PST
PST
a_current
a_current
Evaluate
Evaluate
GENERIC
GENERIC
SKIER
SKIER
- Slab Layering
- Weak Layer
- Slab Layering...
PST / Skier / Skiers
PST / Skier / Skiers
PST
PST
Skier
Skier
Generic
Generic
1. G_Ic + G_IIc (given crack)
or
1. crit_crack_length (DERR)
2. visual analysis (crack slider)
1. G_Ic + G_IIc (given cra...
1. crit_weight (CC)
2. Visual Analysis (weight + crack slider)
1. crit_weight (CC)...
Input:
Input:
Mode Choice:
Mode Choice:
Evaluation:
Evaluation:
1. crit_weight (CC)
2. Visual Analysis (weight slider + crack slider)
1. crit_weight (CC)...
Plots:
Plots:
1. Slab Deformed
2. DERR for crack (0-crit_crack_length)
1. Slab Deformed...
1. Slab Deformed
2. critical_weight + crack (CC)
3. Stress + DERR + IERR
4. Plot regarding self_propagation
1. Slab Deformed...
1. Slab Deformed
2. critical_weight + crack (CC)
3. Stress + DERR + IERR
4. Plot regarding self_propagation
1. Slab Deformed...
Back to Slab Configuration
Back to Slab Configuration
Analyzse
Analyzse
PST
PST
Options:

- Angle:


- Cut Direction
Β  Β  Β  Β  Β Down
Β Up

- Touchdown
Β Enabled

- Slab Length
Β Infinite

Options:...
5 m
5 m
Setup
Setup
Critical Length
Critical Length
DERR
DERR
ERR Envelope
ERR Envelope
a < 1e-6
a < 1e-6
a_critical
a_critical
G_Ic
G_Ic
G_IIc
G_IIc
GENERIC
GENERIC
Back to Slab Configuration
Back to Slab Configuration
Analyzse
Analyzse
Evaluate
Evaluate
SKIER
SKIER
PST
PST
Options:

- Angle:


- Cut Direction
Β  Β  Β  Β  Β Down
Β Up
- Slab Length

Options:...
5 m
5 m
5 degrees
5 degrees
Setup
Setup
????????????
Comparison with Database
Traffic Light Principle to disucss strength of the WeakLayerΒ 
Like in ORACLE
????????????Comparison with Database...
GENERIC
GENERIC
Back to Slab Configuration
Back to Slab Configuration
PST
PST
Setup
Setup
SKIER
SKIER
Crack Length
Crack Lengthweightweight poscrack lengthcrack pos
Left Boundary
Left Boundary
Infinite
Finite
Cut
Infinite...
Vertical
Normal
Vertical...
5 m
5 m
Left Boundary
Left Boundary
Infinite
Finite
Cut
Infinite...
Vertical
Normal
Vertical...
...
...
Options:

- Angle:


- Slab Length

Options:...
5 m
5 m
Crack Self Propagation
Crack Self Propagation
Criticial Length
Criticial Len...
Stress + DERR + IERR
Stress + DERR + IERRwindowresolution
Coupled Criterion
weight = m_critical
Coupled Criterion...
DERR + IERR
DERR + IERR
ERR Envelope
ERR Envelope
m_min-f
m_min-f
G_Ic
G_Ic
m_curr
m_curr
m_cc
m_cc
m_cc
m_cc
m_curr
m_curr
m_min-f
m_min-f
DERR
DERR
IERR
IERR
Strength of WL based on Measurement
Strength of W...
Analysis of Expected Cut Behaviour
Analysis of E...
Analysis of Expected Behaviour
Analysis of Expected Behavi...
Analysis of Expected Behaviour
Analysis of Expected Behavi...
Back to Slab Configuration
Back to Slab Configuration
SKIER
SKIER
Setup
Setup
Left Boundary
Left Boundary
Infinite
Finite
Cut
Infinite...
Vertical
Normal
Vertical...
...
...
Right Boundary
Right Boundary
Infinite
Finite
Cut
Infinite...
Vertical
Normal
Vertical...
...
...
Options:

- Angle:



Options:...
GENERIC
GENERIC
Variable Mass + CrackΒ 
Variable Mass + CrackΒ 
5
5Length: ...Foundation:Β Weight: ...Β (at right boundary)Length: ...Foundation:Β Weight: ...Β (at right boundary)Length: ...Foundation:Β Weight: ...Β (at right boundary)Length: ...Foundation:Β Weight: ...Β (at right boundary)Length: ...Foundation:Β Weight: ...Β (at right boundary)
Crack Self Propagation
Crack Self Propagation
Criticial Length
Criticial Len...
DERR + IERR
DERR + IERR
ERR Envelope
ERR Envelope
m_min-f
m_min-f
G_Ic
G_Ic
m_curr
m_curr
m_cc
m_cc
m_cc
m_cc
m_curr
m_curr
m_min-f
m_min-f
DERR
DERR
IERR
IERR
Stress + DERR + IERR
Stress + DERR + IERRwindowresolution
Coupled Criterion
weight = m_critical
Coupled Criterion...
Effect of mass on self-propagation crack length
Effect of mass on self-propagation crack leng...
G_II
G_II
G_I
G_I
G_IIc
G_IIc
m
m
a
a
crit_crack_length
crit_crack_length
Visualization / App Structure
Visualization / App StructureText is not SVG - cannot display \ No newline at end of file diff --git a/misc/weac_core.drawio.png b/misc/weac_core.drawio.png new file mode 100644 index 0000000..d0e4f90 Binary files /dev/null and b/misc/weac_core.drawio.png differ diff --git a/misc/weac_core.svg b/misc/weac_core.svg new file mode 100644 index 0000000..53dc831 --- /dev/null +++ b/misc/weac_core.svg @@ -0,0 +1 @@ +API Endpoint
JSON Schema
JSON Schema
SnowPilot
SnowPilotGUI
Populates
Populates
JSON Schema
JSON Schema
Control Object
Control Obj...CLI
Imports
Imports
siminput = SimulationInput(...)
siminput = SimulationInput(...)
sysmodel = SystemModel(siminput)
sysmodel = SystemModel(siminput)
sysmodel.discretize_and_solve()
sysmodel.discretize_and_solve()
fieldquantifier = FieldQuantifier(sysmodel.solution_vector, sysmodel.system_properties)
fieldquantifier = FieldQuantifier(sysmodel.solution_vector, sysmodel.system_prope...
fieldquantifier.compute_all_quantities()
fieldquantifier.compute_all_quantities()
criteria_evaluator = CriteriaEvaluator(fieldquantifier)
criteria_evaluator = CriteriaEvaluator(fieldquantifier)
plotter = Plotter()
plotter = Plotter()
plotter.plot_all()
plotter.plot_all()WEAC Core
Folder Structure
Folder Structure
weac/
inputs/
snowprofile_parser.py
simulation_input.py
core/
system_model.py
parameterization.py
eigensystem.py
analysis/
solver.py
criteria_evaluator.py
visualization/
plotter.py
api/
app.py
weac/ inputs/...
Β <<class>> SnowProfileParser
Β <<class>> SnowProfileParser
+ format: Literal["snowpilot", "snowpack", ...]
+ format: Literal["snowpilot", "snowpack", ...]
+ file: Optional[str]
+ file: Optional[str]
+ raw_data: Optional[str]
+ raw_data: Optional[str]
+ parse(format, file, raw_data) -> SimulationInput
+ parse(format, file, raw_data) -> SimulationInput
+ _parse_snowpilot(raw_data)
+ _parse_snowpilot(raw_data)
+ _parse_snowpack(raw_data)
+ _parse_snowpack(raw_data)
+ _parse_...(raw_data)
+ _parse_...(raw_data)
Β <<class>> SystemModel
Β <<class>> SystemModel
+ config: Config
+ config: Config
+ weak_layer: WeakLayer
+ weak_layer: WeakLayer
+ layers: List[Layer]
+ layers: List[Layer]
+ scenario_config: ScenarioConfig
+ scenario_config: ScenarioConfig
+ segments: List[Segment]
+ segments: List[Segment]
+ criteria_overrides: CriteriaOverrides
+ criteria_overrides: CriteriaOverrides
+ system_properties: SystemProperties
+ system_properties: SystemProperties
+ solution_vector: np.ndarray
+ solution_vector: np.ndarray
+ __init__(input_data: SimulationInput)
+ __init__(input_data: SimulationInput)
+ discretize_and_solve(num_points: float) -> np.ndarray
+ discretize_and_solve(num_points: float) -> np.ndarray
Β <<dataclass>> LayerProperties
Β <<dataclass>> LayerProperties
+ youngs_modulus: float
+ youngs_modulus: float
+ poisson_ratio: float
+ poisson_ratio: float
+ shear_modulus: float
+ shear_modulus: float
+ shear_correction_factor: float
+ shear_correction_factor: float
+ normal_stiffness: Optional[float]
+ normal_stiffness: Optional[float]
+ shear_stiffness: Optional[float]
+ shear_stiffness: Optional[float]
+ __init__(layer: Union[WeakLayer, Layer])
+ __init__(layer: Union[WeakLayer, Layer])
Β <<pydanticclass>> SimulationInput
Β <<pydanticclass>> SimulationInput
+ scenario_config: ScenarioConfig
+ scenario_config: ScenarioConfig
+ weak_layer: WeakLayer
+ weak_layer: WeakLayer
+ layers: List[Layer]
+ layers: List[Layer]
+ segments: List[Segment]
+ segments: List[Segment]
+ criteria_overrides: CriteriaOverrides
+ criteria_overrides: CriteriaOverrides
+ model_json_schema() -> JSON schema
+ model_json_schema() -> JSON schema
All classes are Pydantic Models, for automatic validation.
Pydantic Model have a validator which looks if required default fields were provided.
All classes are Pydantic Model...
Β <<dataclass>> SystemProperties
Β <<dataclass>> SystemProperties
+ A11: float
+ A11: float
+ B11: float
+ B11: float
+ D11: float
+ D11: float
+ kA55: float
+ kA55: float
+ K0: float
+ K0: float
+ ewC: float
+ ewC: float
+ ewR: float
+ ewR: float
+ evC: float
+ evC: float
+ evR: float
+ evR: float
+ sR: float
+ sR: float
+ sC: float
+ sC: float
+ C: np.darray[
+ C: np.darray[
+ __init__(layers: List[Layer], weak_layer: WeakLayer, segments: Segments)
+ __init__(layers: List[Layer], weak_layer: WeakLayer, segments: Segments)
+ _calc_laminate_stiffness_parameters(layers: List[Layers], weak_layer: WeakLayer) -> A11, B11, D11, kA55, K0
+ _calc_laminate_stiffness_parameters(layers: List[Layers], weak_layer: WeakLayer) -> A11, B11, D11,...
+ _calc_ev_ew_of_system_matrix() -> ewC, ewR, evC, evC, sR, sC
+ _calc_ev_ew_of_system_matrix() -> ewC, ewR, evC, evC, sR, sC
+ _solve_for_unknown_constants(segments: List[Segment]) -> C
+ _solve_for_unknown_constants(segments: List[Segment]) -> C
Β <<class>> FieldQuantitier
Β <<class>> FieldQuantitier
+ solution_vector: np.ndarray
+ solution_vector: np.ndarray
+ system_properties: SystemProperties
+ system_properties: SystemProperties
+ u / w / psi / du_dx / dw_dx / dpsi_dx
+ u / w / psi / du_dx / dw_dx / dpsi_dx
+ tau / sig / g_i / g_ii
+ tau / sig / g_i / g_ii
+ ....
+ ....
+ __init__(solution_vector: np.ndarray, system_properties: SystemProperties)
+ __init__(solution_vector: np.ndarray, system_properties: SystemPropert...
+ compute_all_quanities(solution_vector)
+ compute_all_quanities(solution_vector)
+ ...(solution_vector)
+ ...(solution_vector)
Β <<class>> Plotter
Β <<class>> Plotter
-
-
+ plot_stress_envelope()
+ plot_stress_envelope()
+ plot_energy_envelope()
+ plot_energy_envelope()
+ plot_deformations()
+ plot_deformations()
Β <<class>> CriteriaEvaluator
Β <<class>> CriteriaEvaluator
+ field_quantities: FieldQuantifier
+ field_quantities: FieldQuantifier
+ __init__(field_quantities: FieldQuantifier)
+ __init__(field_quantities: FieldQuantifier)
+ evaluate_coupled_criterion()
+ evaluate_coupled_criterion()
+ evaluate_stress()
+ evaluate_stress()
+ evaluate_energy_release_rate()
+ evaluate_energy_release_rate()
+ calculate_weight_min()
+ calculate_weight_min()
Β <<class>> App (FastAPI)
Β <<class>> App (FastAPI)
-
-
+ run_from_json(raw_data)
+ run_from_json(raw_data)
+ run_from_file(format, raw_data)
+ run_from_file(format, raw_data)
Β <<dataclass>> Config
Β <<dataclass>> Config
+ method: str
+ method: str
Β Folder Structure
Β Folder Structure
weac/
inputs/
snowprofile_parser.py
simulation_input.py
core/
system_model.py
parameterization.py
eigensystem.py
analysis/
solver.py
criteria_evaluator.py
visualization/
plotter.py
api/
app.py
weac/ inputs/...
Β <<pydanticclass>> SimulationInput
Β <<pydanticclass>> SimulationInput
+ scenario_config: ScenarioConfig
+ scenario_config: ScenarioConfig
+ weak_layer: WeakLayer
+ weak_layer: WeakLayer
+ layers: List[Layer]
+ layers: List[Layer]
+ segments: List[Segment]
+ segments: List[Segment]
+ criteria_overrides: CriteriaOverrides
+ criteria_overrides: CriteriaOverrides
Setup Input Object
Setup Input Object
Setup System
-> Execute Parameterizations
-> Find Unknown Constants
Setup System...
Extract FieldQuantities
Extract FieldQuantities
Run Discretization
Run Discretization
Evaluate Criteria
Evaluate Criteria
Additional Analyses
(Find Minimal Weight)
Additional Analyses...
Plot
PlotText is not SVG - cannot display \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 8e77504..c405666 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,10 +10,12 @@ authors = [ ] description = "Weak layer anticrack nucleation model" readme = "README.md" -requires-python = ">=3.10" -license = {text = "Proprietary"} +requires-python = ">=3.12" +license = { text = "Proprietary" } classifiers = [ "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", "License :: Other/Proprietary License", "Operating System :: OS Independent", "Topic :: Scientific/Engineering", @@ -22,6 +24,8 @@ dependencies = [ "matplotlib>=3.9.1", "numpy>=2.0.1", "scipy>=1.14.0", + "pydantic>=2.11.7", + "snowpylot>=1.1.3", ] [project.urls] @@ -33,29 +37,49 @@ Documentation = "https://2phi.github.io/weac" [project.optional-dependencies] interactive = [ "jupyter", - "ipython>=8.12.3", - "notebook>=7.0.0", - "ipywidgets>=8.0.0" + "ipython>=8.37.0", + "ipykernel>=6.30.1", + "jupyter_client>=8.6.3", + "jupyter_core>=5.8.1", + "matplotlib-inline>=0.1.7", + "nest-asyncio>=1.6.0", + "pyzmq>=27.0.1", + "tornado>=6.5.2", + "traitlets>=5.14.3", ] docs = ["sphinx", "sphinxawesome-theme"] -test = [ - "pytest>=7.0.0", - "pytest-cov>=4.0.0" -] dev = [ - "black>=23.0.0", - "mypy>=1.0.0", - "pytest>=7.0.0", - "pytest-cov>=4.0.0" + # Notebook execution (to run demo.ipynb non-interactively) + "nbclient>=0.10.0", + "nbconvert>=7.16.4", + "nbformat>=5.10.0", + + # Jupyter stack for interactive development + "jupyter", + "ipython>=8.37.0", + "ipykernel>=6.30.1", + "jupyter_client>=8.6.3", + "jupyter_core>=5.8.1", + "matplotlib-inline>=0.1.7", + "nest-asyncio>=1.6.0", + "pyzmq>=27.0.1", + "tornado>=6.5.2", + "traitlets>=5.14.3", + + # Linters/formatters aligned with configured tools + "ruff>=0.4.0", + "pylint>=3.2.0", + "pycodestyle>=2.11.1", + "black>=24.4.0", + "isort>=5.13.0", + + # Versioning helper matching [tool.bumpversion] + "bump2version>=1.0.1", ] [tool.setuptools] packages = ["weac"] -package-data = {"*" = ["CITATION.cff"], "img" = ["*.png"]} - -[tool.ruff] -line-length = 89 -target-version = "py312" +package-data = { "*" = ["CITATION.cff"], "img" = ["*.png"] } [tool.ruff.lint] ignore = ["E741"] @@ -69,12 +93,33 @@ line-ending = "lf" [tool.pylint.typecheck] generated-members = "matplotlib.cm.*" -[tool.pylint.main] -# Ignore notebook files for pylint to avoid false positives and unused-import in exploratory cells -ignore-patterns = [".*\\.ipynb$"] +[tool.pylint.messages_control] +disable = [ + "C0103", # Invalid naming convention + "C0302", # Too many lines in module + "R0902", # Too many instance attributes + "R0903", # Too few public methods + "R0911", # Too many return statements + "R0912", # Too many branches + "R0913", # Too many arguments for function + "R0914", # Too many local variables + "R0915", # Too many statements + "R0917", # Too many positional arguments for function +] [tool.pycodestyle] -ignore = ["E121", "E123", "E126", "E211", "E226", "E24", "E704", "W503", "W504", "E741"] +ignore = [ + "E121", + "E123", + "E126", + "E211", + "E226", + "E24", + "E704", + "W503", + "W504", + "E741", +] [tool.bumpversion] current_version = "2.6.4" diff --git a/tests/.materials/test_snowpit1.xml b/tests/.materials/test_snowpit1.xml new file mode 100644 index 0000000..a85f3f7 --- /dev/null +++ b/tests/.materials/test_snowpit1.xml @@ -0,0 +1,385 @@ + + + + HS 200 cm. HST 30 cm. + + + + + + 2019-10-03T03:00:00 + + + 2019-10-04T13:29:02-08:00 + 2019-10-04T13:29:49-08:00 + + + + Musterfirma + + hans.mueller@muster.de + + + + + Mt Gla.Martial.cumbre + SnowPilot Snowpit site + + + 1257 + + + + + E + + + + + 33 + + + + + -54.7877540 -68.4163660 + + + AR + Glaciar Martial + + + + + 100 + + BKN + Nil + -1.5 + M + + + W + + + + + + + 100 + + + + + + + DFbk + 0.5 + yes + + + 29 + + + + 0 + 0.5 + DFbk + FCsf + + + 0.5 + + + F + F + + + 0.5 + 19.5 + DFbk + FCso + + + 0.5 + + + F+ + + + 20 + 2 + PPgp + + + 3 + + + F + + + 22 + 8 + DFbk + FCso + + + 0.5 + + + F+ + + + 30 + 2 + MFcr + P+ + + + 32 + 1 + FCso + RGwp + + + 0.5 + + + 4F- + + + 33 + 7 + RGlr + RGwp + + + 0.5 + + + 1F + + + 40 + 1 + IFrc + P + + + 41 + 1 + FCxr + RGwp + + + 0.5 + + + 4F + + + 42 + 18 + RGsr + + + 0.5 + + + 1F + + + 60 + 2 + RGsr + FCxr + 4F+ + + + 62 + 37 + RGsr + + + 0.5 + + + 1F+ + + + 99 + 1 + MFcr + P + + + + + + 0 + -2.0 + + + 5 + -4.0 + + + 10 + -4.5 + + + 15 + -5.0 + + + 20 + -5.0 + + + 25 + -5.0 + + + 30 + -4.0 + + + 35 + -4.0 + + + 40 + -4.5 + + + 45 + -4.0 + + + 50 + -4.0 + + + 55 + -3.5 + + + 60 + -3.5 + + + 65 + -3.0 + + + 70 + -3.0 + + + 75 + -3.0 + + + 80 + -2.5 + + + 85 + -2.5 + + + 90 + -2.5 + + + 95 + -2.5 + + + 100 + -2.5 + + + + + + + unknown + + + 0 + 4.0 + 20 + + + 10 + 4.0 + 20 + + + 20 + 4.0 + 20 + + + 30 + 4.0 + 30 + + + 40 + 4.0 + 21 + + + 50 + 4.0 + 29 + + + 60 + 4.0 + 29 + + + + + + + 21 + + + SP + 4 + + + + + + + 32 + + + PC + 11 + + + + + + + 60 + + + RP + 24 + + + + + + + SnowPilot + 7.91-0.1 + \ No newline at end of file diff --git a/tests/.materials/test_snowpit2.xml b/tests/.materials/test_snowpit2.xml new file mode 100644 index 0000000..fd36ddf --- /dev/null +++ b/tests/.materials/test_snowpit2.xml @@ -0,0 +1,193 @@ + + + + + + + 2025-07-10T11:35:00 + + + 2025-07-10T13:29:19-06:00 + 2025-07-10T13:30:58-06:00 + + + + Musterfirma + + hans.mueller@muster.de + + + + + Falsa Parva + SnowPilot Snowpit site + + + 3604 + + + + + SE + + + + + 25 + + + + + -33.3148290 -70.2629220 + + + CL + La Parva + + + + + 65 + + CLR + Nil + -5.0 + L + + + NE + + + + + + + 65 + + + + + + 20 + 2 + + no + + + + + + 0 + 40 + FCxr + + + 2 + + + 1F- + 1F+ + D + + + 40 + 1 + MFcr + P- + + + 41 + 7 + RGxf + + + 3 + + + 1F- + D + true + + + 48 + 2 + MFcr + K + + + 50 + 15 + RGxf + 1F + D + + + + + + 10 + -10.0 + + + 15 + -10.0 + + + 25 + -8.0 + + + 35 + -6.5 + + + 45 + -4.5 + + + 55 + -3.5 + + + 65 + -1.0 + + + + + + + + + + 36 + + + Q3 + 24 + + + + + + + 36 + + + SF + 95.0 + 100.0 + + + + + + + SnowPilot + 7.91-0.1 + + public + + \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py index b0d52c7..e69de29 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,3 +0,0 @@ -""" -Unit tests for the WEAC (Weak Layer Anticrack Nucleation Model) package. -""" diff --git a/tests/analysis/__init__.py b/tests/analysis/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/analysis/test_analyzer.py b/tests/analysis/test_analyzer.py new file mode 100644 index 0000000..6e8b92a --- /dev/null +++ b/tests/analysis/test_analyzer.py @@ -0,0 +1,137 @@ +""" +This module contains tests for the Analyzer class. +""" + +# Standard library imports +import unittest + +# Third party imports +import numpy as np + +from weac.analysis import Analyzer +from weac.components import ( + Config, + Layer, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.components.model_input import ModelInput +from weac.core.system_model import SystemModel + + +class TestAnalyzer(unittest.TestCase): + """Test suite for the Analyzer.""" + + def setUp(self): + """Set up systems for tests: a generic skier system and a PST system.""" + # Basic "skier" system + self.model_input_ski = ModelInput( + scenario_config=ScenarioConfig(phi=15.0, system_type="skier"), + layers=[Layer()], + weak_layer=WeakLayer(), + segments=[Segment(), Segment()], + ) + self.sm_ski = SystemModel(model_input=self.model_input_ski, config=Config()) + self.an_ski = Analyzer(system_model=self.sm_ski, printing_enabled=False) + + # PST system for potential energy related methods + self.model_input_pst = ModelInput( + scenario_config=ScenarioConfig(phi=10.0, system_type="pst-"), + layers=[Layer()], + weak_layer=WeakLayer(), + segments=[Segment(), Segment()], + ) + self.sm_pst = SystemModel(model_input=self.model_input_pst, config=Config()) + self.an_pst = Analyzer(system_model=self.sm_pst, printing_enabled=False) + + def test_rasterize_solution_runs_and_shapes(self): + """Test rasterize_solution runs and shapes.""" + for mode in ("cracked", "uncracked"): + xs, Z, xs_supported = self.an_ski.rasterize_solution(mode=mode, num=200) + self.assertEqual(Z.shape[0], 6) + self.assertEqual(xs.shape[0], Z.shape[1]) + self.assertEqual(xs_supported.shape[0], xs.shape[0]) + self.assertTrue(np.all(np.diff(xs[~np.isnan(xs)]) >= 0)) + + def test_get_zmesh_contains_expected_keys(self): + """Test get_zmesh contains expected keys.""" + zmesh = self.an_ski.get_zmesh(dz=5) + for key in ("z", "E", "nu", "rho", "tensile_strength"): + self.assertIn(key, zmesh) + # Non-empty mesh + self.assertGreater(len(zmesh["z"]), 1) + z = np.asarray(zmesh["z"]) + self.assertTrue(np.all(np.diff(z) > 0)) + + def test_stress_fields_shapes_and_finite(self): + """Test stress fields shapes and finite values.""" + _, Z, _ = self.an_ski.rasterize_solution(num=150) + phi = self.sm_ski.scenario.phi + Sxx = self.an_ski.Sxx(Z=Z, phi=phi, dz=5) + Txz = self.an_ski.Txz(Z=Z, phi=phi, dz=5) + Szz = self.an_ski.Szz(Z=Z, phi=phi, dz=5) + # Consistent shapes + self.assertEqual(Sxx.shape, Txz.shape) + self.assertEqual(Sxx.shape, Szz.shape) + # Finite values + self.assertTrue(np.isfinite(Sxx).all()) + self.assertTrue(np.isfinite(Txz).all()) + self.assertTrue(np.isfinite(Szz).all()) + + def test_principal_stress_slab_variants(self): + """Test principal stress slab variants.""" + _, Z, _ = self.an_ski.rasterize_solution(num=120) + phi = self.sm_ski.scenario.phi + for val in ("max", "min"): + Ps = self.an_ski.principal_stress_slab(Z=Z, phi=phi, dz=5, val=val) + self.assertTrue(np.isfinite(Ps).all()) + # Normalized tensile principal stress + Ps_norm = self.an_ski.principal_stress_slab( + Z=Z, phi=phi, dz=5, val="max", normalize=True + ) + self.assertTrue(np.isfinite(Ps_norm).all()) + # Normalizing compressive should error + with self.assertRaises(ValueError): + _ = self.an_ski.principal_stress_slab( + Z=Z, phi=phi, dz=5, val="min", normalize=True + ) + + def test_principal_stress_weaklayer_variants(self): + """Test principal stress weaklayer variants.""" + _, Z, _ = self.an_ski.rasterize_solution(num=120) + for val in ("max", "min"): + ps = self.an_ski.principal_stress_weaklayer(Z=Z, val=val) + self.assertTrue(np.isfinite(ps).all()) + # Normalized compressive principal stress in weak layer + psn = self.an_ski.principal_stress_weaklayer(Z=Z, val="min", normalize=True) + self.assertTrue(np.isfinite(psn).all()) + # Normalizing tensile should error + with self.assertRaises(ValueError): + _ = self.an_ski.principal_stress_weaklayer(Z=Z, val="max", normalize=True) + + def test_energy_release_rates_shapes(self): + """Test energy release rates shapes.""" + Ginc = self.an_ski.incremental_ERR() + self.assertEqual(Ginc.shape, (3,)) + self.assertTrue(np.isfinite(Ginc).all()) + + Gdif = self.an_ski.differential_ERR() + self.assertEqual(Gdif.shape, (3,)) + self.assertTrue(np.isfinite(Gdif).all()) + + def test_internal_and_external_potentials_pst(self): + """Test internal and external potentials for PST.""" + # Ensure PST-specific methods run + Pi_total = self.an_pst.total_potential() + self.assertTrue(np.isfinite(Pi_total)) + + Pi_ext = self.an_pst._external_potential() # pylint: disable=protected-access + + self.assertTrue(np.isfinite(Pi_ext)) + + Pi_int = self.an_pst._internal_potential() # pylint: disable=protected-access + + self.assertTrue(np.isfinite(Pi_int)) + # Consistency: total β‰ˆ int + ext + self.assertAlmostEqual(Pi_total, Pi_int + Pi_ext, places=6) diff --git a/tests/analysis/test_criteria_evaluator.py b/tests/analysis/test_criteria_evaluator.py new file mode 100644 index 0000000..d97152b --- /dev/null +++ b/tests/analysis/test_criteria_evaluator.py @@ -0,0 +1,229 @@ +""" +This module contains tests for the CriteriaEvaluator class. +""" + +# Standard library imports +import unittest + +# Third party imports +import numpy as np + +# weac imports +from weac.analysis.criteria_evaluator import ( + CoupledCriterionResult, + CriteriaEvaluator, + FindMinimumForceResult, + SSERRResult, +) +from weac.components import ( + Config, + CriteriaConfig, + Layer, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.components.model_input import ModelInput +from weac.core.system_model import SystemModel + + +class TestCriteriaEvaluator(unittest.TestCase): + """Test suite for the CriteriaEvaluator.""" + + def setUp(self): + """Set up common objects for testing.""" + self.config = Config() + self.criteria_config = CriteriaConfig() + self.evaluator = CriteriaEvaluator(self.criteria_config) + + self.layers = [ + Layer(rho=170, h=100), + Layer(rho=190, h=40), + Layer(rho=230, h=130), + Layer(rho=250, h=20), + Layer(rho=210, h=70), + Layer(rho=380, h=20), + Layer(rho=280, h=100), + ] + self.weak_layer = WeakLayer(rho=180, h=10, G_Ic=0.5, G_IIc=0.8, kn=100, kt=100) + self.phi = 30.0 + self.segments_length = 10000 + + def test_fracture_toughness_criterion(self): + """Test the fracture toughness criterion calculation.""" + g_delta = self.evaluator.fracture_toughness_envelope( + G_I=0.25, G_II=0.4, weak_layer=self.weak_layer + ) + # Expected: (|0.25| / 0.5)^5.0 + (|0.4| / 0.8)^2.22 + # = (0.5)^5 + (0.5)^2.22 = 0.03125 + 0.2146... + np.testing.assert_almost_equal(g_delta, 0.2455609957, decimal=5) + + def test_stress_envelope_adam_unpublished(self): + """Test the 'adam_unpublished' stress envelope.""" + self.criteria_config.stress_envelope_method = "adam_unpublished" + sigma, tau = np.array([2.0]), np.array([1.5]) + result = self.evaluator.stress_envelope(sigma, tau, self.weak_layer) + self.assertGreater(result[0], 0) + + def test_find_minimum_force_convergence(self): + """Test the convergence of find_minimum_force.""" + segments = [ + Segment(length=self.segments_length, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=self.segments_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + results: FindMinimumForceResult = self.evaluator.find_minimum_force( + system=system + ) + skier_weight = results.critical_skier_weight + new_segments = results.new_segments + self.assertGreater(skier_weight, 0) + self.assertIsNotNone(new_segments) + + def test_find_crack_length_for_weight(self): + """Test the find_crack_length_for_weight method.""" + skier_weight = 100 # A substantial weight + segments = [ + Segment(length=self.segments_length, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=skier_weight), + Segment(length=0, has_foundation=False, m=0), + Segment(length=self.segments_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi, cut_length=0), + ), + config=self.config, + ) + crack_len, segments = self.evaluator.find_crack_length_for_weight( + system, skier_weight + ) + self.assertGreaterEqual(crack_len, 0) + self.assertIsInstance(segments, list) + self.assertTrue(all(isinstance(s, Segment) for s in segments)) + + def test_check_crack_propagation_stable(self): + """Test check_crack_propagation for a stable scenario (no crack).""" + segments = [Segment(length=self.segments_length, has_foundation=True, m=0)] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + g_delta, can_propagate = self.evaluator.check_crack_self_propagation(system) + self.assertFalse(can_propagate) + self.assertLess( + g_delta, 1.0, "Stable scenario should be below the fracture envelope" + ) + + def test_check_crack_propagation_unstable(self): + """Test check_crack_propagation for an unstable scenario (pre-cracked).""" + # A configuration with a very weak layer and a large crack that should + # be unstable under its own weight. + unstable_weak_layer = WeakLayer( + rho=180, h=10, G_Ic=0.01, G_IIc=0.01, kn=100, kt=100 + ) + crack_length = 4000 # 4m crack + side_length = (self.segments_length - crack_length) / 2 + segments = [ + Segment(length=side_length, has_foundation=True, m=0), + Segment(length=crack_length, has_foundation=False, m=0), + Segment(length=side_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=unstable_weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + g_delta, can_propagate = self.evaluator.check_crack_self_propagation(system) + self.assertGreater(g_delta, 1) + self.assertTrue(can_propagate) + + def test_evaluate_coupled_criterion_full_run(self): + """Test the main evaluate_coupled_criterion workflow.""" + segments = [ + Segment(length=self.segments_length, has_foundation=True, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=0, has_foundation=False, m=0), + Segment(length=self.segments_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + results: CoupledCriterionResult = self.evaluator.evaluate_coupled_criterion( + system=system + ) + self.assertIsInstance(results, CoupledCriterionResult) + self.assertGreater(results.critical_skier_weight, 0) + + def test_evaluate_SSERR(self): + """Test the evaluate_SSERR method.""" + segments = [ + Segment(length=self.segments_length, has_foundation=True, m=0), + Segment(length=self.segments_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + results: SSERRResult = self.evaluator.evaluate_SSERR(system) + self.assertTrue(results.converged) + self.assertGreater(results.SSERR, 0) + self.assertGreater(results.touchdown_distance, 0) + self.assertLess(results.touchdown_distance, system.scenario.L) + + def test_find_minimum_crack_length(self): + """Test the find_minimum_crack_length method.""" + segments = [ + Segment(length=self.segments_length, has_foundation=True, m=0), + Segment(length=self.segments_length, has_foundation=True, m=0), + ] + system = SystemModel( + model_input=ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=segments, + scenario_config=ScenarioConfig(phi=self.phi), + ), + config=self.config, + ) + crack_length, new_segments = self.evaluator.find_minimum_crack_length(system) + self.assertGreater(crack_length, 0) + self.assertIsInstance(new_segments, list) + self.assertTrue(all(isinstance(s, Segment) for s in new_segments)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/components/__init__.py b/tests/components/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/components/test_configs.py b/tests/components/test_configs.py new file mode 100644 index 0000000..5f54aec --- /dev/null +++ b/tests/components/test_configs.py @@ -0,0 +1,273 @@ +""" +Unit tests for configuration components. + +Tests Config, ScenarioConfig, CriteriaConfig, Segment, and ModelInput validation. +""" + +import json +import unittest + +from pydantic import ValidationError + +from weac.components import ( + Config, + CriteriaConfig, + Layer, + ModelInput, + ScenarioConfig, + Segment, + WeakLayer, +) + + +class TestConfig(unittest.TestCase): + """Test the Config class for runtime configuration.""" + + def test_config_default_creation(self): + """Test creating Config with default values.""" + config = Config() + + # Check default values + self.assertFalse(config.touchdown) + + +class TestScenarioConfig(unittest.TestCase): + """Test the ScenarioConfig class.""" + + def test_scenario_config_defaults(self): + """Test ScenarioConfig with default values.""" + scenario = ScenarioConfig() + + self.assertEqual(scenario.phi, 0) + self.assertEqual(scenario.system_type, "skiers") + self.assertEqual(scenario.cut_length, 0.0) + self.assertEqual(scenario.stiffness_ratio, 1000) + self.assertEqual(scenario.surface_load, 0.0) + + def test_scenario_config_custom_values(self): + """Test ScenarioConfig with custom values.""" + scenario = ScenarioConfig( + phi=30.0, + system_type="skier", + cut_length=150.0, + stiffness_ratio=500.0, + surface_load=0.1, + ) + + self.assertEqual(scenario.phi, 30.0) + self.assertEqual(scenario.system_type, "skier") + self.assertEqual(scenario.cut_length, 150.0) + self.assertEqual(scenario.stiffness_ratio, 500.0) + self.assertEqual(scenario.surface_load, 0.1) + + def test_scenario_config_validation(self): + """Test ScenarioConfig validation.""" + # Negative crack length + with self.assertRaises(ValidationError): + ScenarioConfig(cut_length=-10.0) + + # Invalid stiffness ratio (<= 0) + with self.assertRaises(ValidationError): + ScenarioConfig(stiffness_ratio=0.0) + + # Negative surface load + with self.assertRaises(ValidationError): + ScenarioConfig(surface_load=-5.0) + + # Invalid system type + with self.assertRaises(ValidationError): + ScenarioConfig(system_type="invalid_system") + + +class TestCriteriaConfig(unittest.TestCase): + """Test the CriteriaConfig class.""" + + def test_criteria_config_defaults(self): + """Test CriteriaConfig with default values.""" + criteria = CriteriaConfig() + + self.assertEqual(criteria.fn, 2.0) + self.assertEqual(criteria.fm, 2.0) + self.assertEqual(criteria.gn, 5.0) + self.assertAlmostEqual(criteria.gm, 1 / 0.45, places=10) + + def test_criteria_config_custom_values(self): + """Test CriteriaConfig with custom values.""" + criteria = CriteriaConfig(fn=1.5, fm=2.0, gn=0.8, gm=1.2) + + self.assertEqual(criteria.fn, 1.5) + self.assertEqual(criteria.fm, 2.0) + self.assertEqual(criteria.gn, 0.8) + self.assertEqual(criteria.gm, 1.2) + + def test_criteria_config_validation(self): + """Test CriteriaConfig validation.""" + # All parameters must be positive + with self.assertRaises(ValidationError): + CriteriaConfig(fn=0.0) + + with self.assertRaises(ValidationError): + CriteriaConfig(fm=-0.5) + + with self.assertRaises(ValidationError): + CriteriaConfig(gn=-1.0) + + with self.assertRaises(ValidationError): + CriteriaConfig(gm=0.0) + + +class TestSegment(unittest.TestCase): + """Test the Segment class.""" + + def test_segment_creation(self): + """Test creating segments with various parameters.""" + # Basic segment + seg1 = Segment(length=1000.0, has_foundation=True, m=0.0) + self.assertEqual(seg1.length, 1000.0) + self.assertEqual(seg1.has_foundation, True) + self.assertEqual(seg1.m, 0.0) + + # Segment with skier load + seg2 = Segment(length=2000.0, has_foundation=False, m=75.0) + self.assertEqual(seg2.length, 2000.0) + self.assertEqual(seg2.has_foundation, False) + self.assertEqual(seg2.m, 75.0) + + def test_segment_default_mass(self): + """Test that segment mass defaults to 0.""" + seg = Segment(length=1500.0, has_foundation=True) + self.assertEqual(seg.m, 0.0) + + def test_segment_validation(self): + """Test segment validation.""" + # Negative length + with self.assertRaises(ValidationError): + Segment(length=-100.0, has_foundation=True) + + # Negative mass + with self.assertRaises(ValidationError): + Segment(length=1000.0, has_foundation=True, m=-10.0) + + +class TestModelInput(unittest.TestCase): + """Test the ModelInput class for complete model validation.""" + + def setUp(self): + """Set up common test data.""" + self.scenario_config = ScenarioConfig(phi=25, system_type="skier") + self.weak_layer = WeakLayer(rho=50, h=30, E=0.25, G_Ic=1) + self.layers = [Layer(rho=200, h=100), Layer(rho=300, h=150)] + self.segments = [ + Segment(length=3000, has_foundation=True, m=70), + Segment(length=4000, has_foundation=True, m=0), + ] + + def test_model_input_complete(self): + """Test creating complete ModelInput.""" + model = ModelInput( + scenario_config=self.scenario_config, + weak_layer=self.weak_layer, + layers=self.layers, + segments=self.segments, + ) + + self.assertEqual(model.scenario_config, self.scenario_config) + self.assertEqual(model.weak_layer, self.weak_layer) + self.assertEqual(model.layers, self.layers) + self.assertEqual(model.segments, self.segments) + + def test_model_input_empty_collections(self): + """Test validation with empty layers or segments.""" + # Empty layers list + with self.assertRaises(ValidationError): + ModelInput( + scenario_config=self.scenario_config, + weak_layer=self.weak_layer, + layers=[], + segments=self.segments, + ) + + # Empty segments list + with self.assertRaises(ValidationError): + ModelInput( + scenario_config=self.scenario_config, + weak_layer=self.weak_layer, + layers=self.layers, + segments=[], + ) + + def test_model_input_json_serialization(self): + """Test JSON serialization and schema generation.""" + model = ModelInput( + scenario_config=self.scenario_config, + weak_layer=self.weak_layer, + layers=self.layers, + segments=self.segments, + ) + + # Test JSON serialization + json_str = model.model_dump_json() + self.assertIsInstance(json_str, str) + + # Test that it can be parsed back + parsed_data = json.loads(json_str) + self.assertIsInstance(parsed_data, dict) + + # Test schema generation + schema = ModelInput.model_json_schema() + self.assertIsInstance(schema, dict) + self.assertIn("properties", schema) + self.assertIn("scenario_config", schema["properties"]) + self.assertIn("weak_layer", schema["properties"]) + self.assertIn("layers", schema["properties"]) + self.assertIn("segments", schema["properties"]) + + +class TestModelInputPhysicalConsistency(unittest.TestCase): + """Test physical consistency checks for ModelInput.""" + + def test_layer_ordering_makes_sense(self): + """Test that layer ordering is physically reasonable.""" + # This is more of a documentation test - the model doesn't enforce + # physical layer ordering, but we can test that our test data makes sense + layers = [ + Layer(rho=150, h=50), # Light surface layer + Layer(rho=200, h=100), # Medium density + Layer(rho=350, h=75), # Denser bottom layer + ] + + weak_layer = WeakLayer(rho=80, h=20) # Weak layer should be less dense + + # Check that weak layer is less dense than slab layers + for layer in layers: + self.assertLess( + weak_layer.rho, + layer.rho, + "Weak layer should typically be less dense than slab layers", + ) + + def test_segment_length_consistency(self): + """Test that segment lengths are reasonable.""" + segments = [ + Segment(length=1000, has_foundation=True, m=0), # 1m segment + Segment( + length=2000, has_foundation=False, m=75 + ), # 2m free segment with skier + Segment(length=1500, has_foundation=True, m=0), # 1.5m segment + ] + + total_length = sum(seg.length for seg in segments) + self.assertGreater(total_length, 0, "Total length should be positive") + self.assertLess( + total_length, 100000, "Total length should be reasonable (< 100m)" + ) + + # Check that at least one segment is supported + has_support = any(seg.has_foundation for seg in segments) + self.assertTrue( + has_support, "At least one segment should have foundation support" + ) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/components/test_layer.py b/tests/components/test_layer.py new file mode 100644 index 0000000..c69243f --- /dev/null +++ b/tests/components/test_layer.py @@ -0,0 +1,221 @@ +""" +Unit tests for Layer and WeakLayer components. + +Tests validation, automatic property calculations, and edge cases. +""" + +import unittest + +import numpy as np +from pydantic import ValidationError + +from weac.components.layer import ( + Layer, + WeakLayer, + _bergfeld_youngs_modulus, + _gerling_youngs_modulus, + _scapozza_youngs_modulus, +) +from weac.constants import NU + + +class TestLayerPropertyCalculations(unittest.TestCase): + """Test the layer property calculation functions.""" + + def test_bergfeld_calculation(self): + """Test Bergfeld Young's modulus calculation.""" + # Test with standard ice density + E = _bergfeld_youngs_modulus(rho=917.0) # Ice density + self.assertGreater(E, 0, "Young's modulus should be positive") + self.assertTrue(np.isscalar(E), "Result should be a scalar") + + # Test with typical snow densities + E_light = _bergfeld_youngs_modulus(rho=100.0) + E_heavy = _bergfeld_youngs_modulus(rho=400.0) + self.assertLess(E_light, E_heavy, "Heavier snow should have higher modulus") + + def test_scapozza_calculation(self): + """Test Scapozza Young's modulus calculation.""" + E = _scapozza_youngs_modulus(rho=200.0) + self.assertGreater(E, 0, "Young's modulus should be positive") + + def test_gerling_calculation(self): + """Test Gerling Young's modulus calculation.""" + E = _gerling_youngs_modulus(rho=250.0) + self.assertGreater(E, 0, "Young's modulus should be positive") + + +class TestLayer(unittest.TestCase): + """Test the Layer class functionality.""" + + def test_layer_creation_with_required_fields(self): + """Test creating a layer with only required fields.""" + layer = Layer(rho=200.0, h=100.0) + + # Check required fields + self.assertEqual(layer.rho, 200.0) + self.assertEqual(layer.h, 100.0) + + # Check auto-calculated fields + self.assertIsNotNone(layer.E, "Young's modulus should be auto-calculated") + self.assertIsNotNone(layer.G, "Shear modulus should be auto-calculated") + self.assertGreater(layer.E, 0, "Young's modulus should be positive") + self.assertGreater(layer.G, 0, "Shear modulus should be positive") + + # Check default Poisson's ratio + self.assertEqual(layer.nu, NU, "Default Poisson's ratio should be 0.25") + + def test_layer_creation_with_all_fields(self): + """Test creating a layer with all fields specified.""" + layer = Layer(rho=250.0, h=150.0, nu=0.3, E=50.0, G=20.0) + + self.assertEqual(layer.rho, 250.0) + self.assertEqual(layer.h, 150.0) + self.assertEqual(layer.nu, 0.3) + self.assertEqual(layer.E, 50.0, "Specified E should override auto-calculation") + self.assertEqual(layer.G, 20.0, "Specified G should override auto-calculation") + + def test_layer_validation_errors(self): + """Test that invalid layer parameters raise ValidationError.""" + # Negative density + with self.assertRaises(ValidationError): + Layer(rho=-100.0, h=100.0) + + # Zero thickness + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=0.0) + + # Invalid Poisson's ratio (>= 0.5) + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=100.0, nu=0.5) + + # Negative Young's modulus + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=100.0, E=-10.0) + + def test_shear_modulus_calculation(self): + """Test automatic shear modulus calculation from E and nu.""" + layer = Layer(rho=200.0, h=100.0, nu=0.25, E=100.0) + + # G = E / (2 * (1 + nu)) + expected_G = 100.0 / (2 * (1 + 0.25)) + self.assertAlmostEqual(layer.G, expected_G, places=5) + + +class TestWeakLayer(unittest.TestCase): + """Test the WeakLayer class functionality.""" + + def test_weak_layer_creation_minimal(self): + """Test creating a weak layer with minimal required fields.""" + wl = WeakLayer(rho=50.0, h=10.0) + + # Check required fields + self.assertEqual(wl.rho, 50.0) + self.assertEqual(wl.h, 10.0) + + # Check auto-calculated fields + self.assertIsNotNone(wl.E, "Young's modulus should be auto-calculated") + self.assertIsNotNone(wl.G, "Shear modulus should be auto-calculated") + self.assertIsNotNone(wl.kn, "Normal stiffness should be auto-calculated") + self.assertIsNotNone(wl.kt, "Shear stiffness should be auto-calculated") + self.assertGreater(wl.E, 0, "Young's modulus should be positive") + self.assertGreater(wl.G, 0, "Shear modulus should be positive") + self.assertGreater(wl.kn, 0, "Normal stiffness should be positive") + self.assertGreater(wl.kt, 0, "Shear stiffness should be positive") + + # Check default fracture properties + self.assertEqual(wl.G_c, 1.0) + self.assertEqual(wl.G_Ic, 0.56) + self.assertEqual(wl.G_IIc, 0.79) + + def test_weak_layer_stiffness_calculations(self): + """Test weak layer stiffness calculations.""" + wl = WeakLayer(rho=100.0, h=20.0, E=10.0, nu=0.2) + + # kn = E_plane / h = E / (1 - nuΒ²) / h + E_plane = 10.0 / (1 - 0.2**2) + expected_kn = E_plane / 20.0 + self.assertAlmostEqual(wl.kn, expected_kn, places=5) + + # kt = G / h + expected_G = 10.0 / (2 * (1 + 0.2)) + expected_kt = expected_G / 20.0 + self.assertAlmostEqual(wl.kt, expected_kt, places=5) + + def test_weak_layer_custom_stiffnesses(self): + """Test weak layer with custom stiffness values.""" + wl = WeakLayer(rho=80.0, h=15.0, kn=5.0, kt=3.0) + + self.assertEqual(wl.kn, 5.0, "Custom kn should override calculation") + self.assertEqual(wl.kt, 3.0, "Custom kt should override calculation") + + def test_weak_layer_fracture_properties(self): + """Test weak layer fracture property validation.""" + wl = WeakLayer(rho=90.0, h=25.0, G_c=2.5, G_Ic=1.5, G_IIc=1.8) + + self.assertEqual(wl.G_c, 2.5) + self.assertEqual(wl.G_Ic, 1.5) + self.assertEqual(wl.G_IIc, 1.8) + + def test_weak_layer_validation_errors(self): + """Test weak layer validation errors.""" + # Negative fracture energy + with self.assertRaises(ValidationError): + WeakLayer(rho=100.0, h=20.0, G_c=-1.0) + + # Zero thickness + with self.assertRaises(ValidationError): + WeakLayer(rho=100.0, h=0.0) + + +class TestLayerPhysicalConsistency(unittest.TestCase): + """Test physical consistency of layer calculations.""" + + def test_layer_density_modulus_relationship(self): + """Test that higher density leads to higher modulus.""" + layer_light = Layer(rho=150.0, h=100.0) + layer_heavy = Layer(rho=350.0, h=100.0) + + self.assertLess( + layer_light.E, + layer_heavy.E, + "Heavier snow should have higher Young's modulus", + ) + self.assertLess( + layer_light.G, + layer_heavy.G, + "Heavier snow should have higher shear modulus", + ) + + def test_weak_layer_thickness_stiffness_relationship(self): + """Test that thicker weak layers have lower stiffness.""" + wl_thin = WeakLayer(rho=100.0, h=10.0) + wl_thick = WeakLayer(rho=100.0, h=30.0) + + self.assertGreater( + wl_thin.kn, + wl_thick.kn, + "Thinner weak layer should have higher normal stiffness", + ) + self.assertGreater( + wl_thin.kt, + wl_thick.kt, + "Thinner weak layer should have higher shear stiffness", + ) + + def test_poisson_ratio_bounds(self): + """Test Poisson's ratio physical bounds.""" + # Test upper bound (must be < 0.5 for positive definite stiffness) + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=100.0, nu=0.5) + + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=100.0, nu=0.6) + + # Test lower bound (must be >= 0) + with self.assertRaises(ValidationError): + Layer(rho=200.0, h=100.0, nu=-0.1) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/core/__init__.py b/tests/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/core/test_eigensystem.py b/tests/core/test_eigensystem.py new file mode 100644 index 0000000..d2ccb32 --- /dev/null +++ b/tests/core/test_eigensystem.py @@ -0,0 +1,368 @@ +""" +Unit tests for the Eigensystem class. + +Tests system matrix assembly, eigenvalue/eigenvector calculations, +complementary and particular solutions. +""" + +import unittest + +import numpy as np + +from weac.components import Layer, WeakLayer +from weac.core.eigensystem import Eigensystem +from weac.core.slab import Slab + + +class TestEigensystemBasicProperties(unittest.TestCase): + """Test basic eigensystem setup and property calculations.""" + + def setUp(self): + """Set up common test data.""" + self.layers = [Layer(rho=200, h=100), Layer(rho=300, h=150)] + self.weak_layer = WeakLayer(rho=50, h=20, E=0.5, G_Ic=1.0) + self.slab = Slab(self.layers) + self.eigensystem = Eigensystem(self.weak_layer, self.slab) + + def test_eigensystem_initialization(self): + """Test that eigensystem initializes correctly.""" + self.assertIsNotNone(self.eigensystem.weak_layer) + self.assertIsNotNone(self.eigensystem.slab) + + # Check that eigenvalue calculation was performed + self.assertIsNotNone( + self.eigensystem.ewC, "Complex eigenvalues should be calculated" + ) + self.assertIsNotNone( + self.eigensystem.ewR, "Real eigenvalues should be calculated" + ) + self.assertIsNotNone( + self.eigensystem.evC, "Complex eigenvectors should be calculated" + ) + self.assertIsNotNone( + self.eigensystem.evR, "Real eigenvectors should be calculated" + ) + + def test_laminate_stiffness_parameters(self): + """Test calculation of laminate stiffness parameters.""" + # Check that stiffness parameters are positive + self.assertGreater( + self.eigensystem.A11, 0, "Extensional stiffness should be positive" + ) + self.assertGreater( + self.eigensystem.D11, 0, "Bending stiffness should be positive" + ) + self.assertGreater( + self.eigensystem.kA55, 0, "Shear stiffness should be positive" + ) + + # K0 can be negative depending on coupling + self.assertIsInstance(self.eigensystem.K0, float) + + def test_system_matrix_properties(self): + """Test properties of the system matrix.""" + K = self.eigensystem.K + + # Check matrix dimensions + self.assertEqual(K.shape, (6, 6), "System matrix should be 6x6") + + # Check that it's a real matrix + self.assertTrue(np.all(np.isreal(K)), "System matrix should be real") + + # Check specific structure (first row should be [0, 1, 0, 0, 0, 0]) + expected_first_row = [0, 1, 0, 0, 0, 0] + np.testing.assert_array_equal( + K[0, :], + expected_first_row, + "First row of system matrix has known structure", + ) + + # Check third row should be [0, 0, 0, 1, 0, 0] + expected_third_row = [0, 0, 0, 1, 0, 0] + np.testing.assert_array_equal( + K[2, :], + expected_third_row, + "Third row of system matrix has known structure", + ) + + # Check fifth row should be [0, 0, 0, 0, 0, 1] + expected_fifth_row = [0, 0, 0, 0, 0, 1] + np.testing.assert_array_equal( + K[4, :], + expected_fifth_row, + "Fifth row of system matrix has known structure", + ) + + +class TestEigensystemEigenvalueCalculations(unittest.TestCase): + """Test eigenvalue and eigenvector calculations.""" + + def setUp(self): + """Set up test eigensystem.""" + layers = [Layer(rho=250, h=120)] + weak_layer = WeakLayer(rho=80, h=25, E=0.3) + slab = Slab(layers) + self.eigensystem = Eigensystem(weak_layer, slab) + + def test_eigenvalue_classification(self): + """Test that eigenvalues are correctly classified.""" + # Real eigenvalues should be real + self.assertTrue( + np.all(np.isreal(self.eigensystem.ewR)), + "Real eigenvalues should be real numbers", + ) + + # Complex eigenvalues should have positive imaginary parts + if len(self.eigensystem.ewC) > 0: + self.assertTrue( + np.all(self.eigensystem.ewC.imag > 0), + "Complex eigenvalues should have positive imaginary parts", + ) + + def test_eigenvector_dimensions(self): + """Test that eigenvectors have correct dimensions.""" + # Real eigenvectors + if len(self.eigensystem.ewR) > 0: + self.assertEqual( + self.eigensystem.evR.shape[0], + 6, + "Real eigenvectors should be 6-dimensional", + ) + self.assertEqual( + self.eigensystem.evR.shape[1], + len(self.eigensystem.ewR), + "Number of real eigenvectors should match number of real eigenvalues", + ) + + # Complex eigenvectors + if len(self.eigensystem.ewC) > 0: + self.assertEqual( + self.eigensystem.evC.shape[0], + 6, + "Complex eigenvectors should be 6-dimensional", + ) + self.assertEqual( + self.eigensystem.evC.shape[1], + len(self.eigensystem.ewC), + "Number of complex eigenvectors should match number of complex eigenvalues", + ) + + def test_eigenvalue_shifts(self): + """Test eigenvalue shift arrays.""" + # Shifts should have same length as eigenvalues + self.assertEqual( + len(self.eigensystem.sR), + len(self.eigensystem.ewR), + "Real shifts should match real eigenvalues", + ) + self.assertEqual( + len(self.eigensystem.sC), + len(self.eigensystem.ewC), + "Complex shifts should match complex eigenvalues", + ) + + # Shifts should be -1 or 0 + self.assertTrue( + np.all(np.isin(self.eigensystem.sR, [-1, 0])), + "Real shifts should be -1 or 0", + ) + self.assertTrue( + np.all(np.isin(self.eigensystem.sC, [-1, 0])), + "Complex shifts should be -1 or 0", + ) + + +class TestEigensystemSolutionMethods(unittest.TestCase): + """Test complementary and particular solution methods.""" + + def setUp(self): + """Set up test eigensystem.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=60, h=15) + slab = Slab(layers) + self.eigensystem = Eigensystem(weak_layer, slab) + + def test_complementary_solution_bedded(self): + """Test complementary solution for bedded segment.""" + x = 100.0 # Position + length = 1000.0 # Segment length + has_foundation = True # Bedded + + zh = self.eigensystem.zh(x, length, has_foundation) + + # Should return 6x6 matrix + self.assertEqual( + zh.shape, (6, 6), "Complementary solution should be 6x6 matrix" + ) + + # Should be real for bedded segments + self.assertTrue( + np.allclose(np.imag(zh), 0.0, atol=1e-12), + "Bedded complementary solution should be (numerically) real", + ) + + def test_complementary_solution_free(self): + """Test complementary solution for free segment.""" + x = 50.0 # Position + length = 500.0 # Segment length + has_foundation = False # Free + + zh = self.eigensystem.zh(x, length, has_foundation) + + # Should return 6x6 matrix + self.assertEqual( + zh.shape, (6, 6), "Complementary solution should be 6x6 matrix" + ) + + self.assertTrue( + np.allclose(np.imag(zh), 0.0, atol=1e-12), + "Free complementary solution should be (numerically) real", + ) + + def test_complementary_solution_at_origin(self): + """Test complementary solution at x=0.""" + zh_bedded = self.eigensystem.zh(0.0, 1000.0, True) + zh_free = self.eigensystem.zh(0.0, 1000.0, False) + + # At x=0, certain columns should have specific values + # For free segments, the polynomial form gives specific patterns + self.assertTrue( + np.isfinite(zh_bedded).all(), "Bedded solution should be finite at origin" + ) + self.assertTrue( + np.isfinite(zh_free).all(), "Free solution should be finite at origin" + ) + + def test_particular_solution_bedded(self): + """Test particular solution for bedded segment.""" + x = 200.0 # Position + phi = 30.0 # Inclination + has_foundation = True # Bedded + qs = 5.0 # Surface load + + zp = self.eigensystem.zp(x, phi, has_foundation, qs) + + # Should return 6x1 vector + self.assertEqual(zp.shape, (6, 1), "Particular solution should be 6x1 vector") + # Should be real + self.assertTrue( + np.allclose(np.imag(zp), 0.0, atol=1e-12), + "Particular solution should be (numerically) real", + ) + + def test_particular_solution_free(self): + """Test particular solution for free segment.""" + x = 150.0 # Position + phi = 25.0 # Inclination + has_foundation = False # Free + qs = 0.0 # No additional surface load + + zp = self.eigensystem.zp(x, phi, has_foundation, qs) + + # Should be real + self.assertTrue( + np.allclose(np.imag(zp), 0.0, atol=1e-12), + "Particular solution should be (numerically) real", + ) + + def test_load_vector_calculation(self): + """Test system load vector calculation.""" + phi = 20.0 # Inclination + qs = 10.0 # Surface load + + q = self.eigensystem.get_load_vector(phi, qs) + + # Should return 6x1 vector + self.assertEqual(q.shape, (6, 1), "Load vector should be 6x1") + + # Should be real + self.assertTrue( + np.allclose(np.imag(q), 0.0, atol=1e-12), + "Load vector should be (numerically) real", + ) + + +class TestEigensystemPhysicalConsistency(unittest.TestCase): + """Test physical consistency of eigensystem calculations.""" + + def test_stiffness_scaling_with_properties(self): + """Test that stiffness parameters scale correctly with material properties.""" + # Create two systems with different Young's moduli + layers1 = [Layer(rho=200, h=100, E=50)] + layers2 = [Layer(rho=200, h=100, E=100)] # Double the modulus + + weak_layer = WeakLayer(rho=50, h=20) + slab1 = Slab(layers1) + slab2 = Slab(layers2) + + eig1 = Eigensystem(weak_layer, slab1) + eig2 = Eigensystem(weak_layer, slab2) + + # Higher Young's modulus should lead to higher stiffnesses + self.assertGreater( + eig2.A11, eig1.A11, "Higher E should increase extensional stiffness" + ) + self.assertGreater( + eig2.D11, eig1.D11, "Higher E should increase bending stiffness" + ) + + def test_weak_layer_stiffness_influence(self): + """Test that weak layer properties affect system behavior.""" + layers = [Layer(rho=250, h=120)] + + # Soft weak layer + wl_soft = WeakLayer(rho=50, h=25, E=0.1) + # Stiff weak layer + wl_stiff = WeakLayer(rho=120, h=25, E=1.0) + + slab = Slab(layers) + eig_soft = Eigensystem(wl_soft, slab) + eig_stiff = Eigensystem(wl_stiff, slab) + + # Stiffness values should be different + self.assertNotAlmostEqual( + eig_soft.K[1, 0], + eig_stiff.K[1, 0], + msg="Different weak layer properties should affect system matrix", + ) + + def test_inclination_effect_on_loads(self): + """Test that inclination affects load vectors correctly.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + + # Compare load vectors for different inclinations + q_flat = eigensystem.get_load_vector(phi=0.0, qs=0.0) + q_inclined = eigensystem.get_load_vector(phi=30.0, qs=0.0) + + # Should be different for non-zero inclination + self.assertFalse( + np.allclose(q_flat, q_inclined), + "Load vectors should differ for different inclinations", + ) + + def test_complementary_solution_continuity(self): + """Test continuity of complementary solutions.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + + # Test continuity for bedded segments + x1, x2 = 100.0, 100.000001 # Very close points + length = 1000.0 + + zh1 = eigensystem.zh(x1, length, True) + zh2 = eigensystem.zh(x2, length, True) + + # Solutions should be very close for nearby points + self.assertTrue( + np.allclose(zh1, zh2, atol=1e-6), + "Complementary solutions should be continuous", + ) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/core/test_field_quantities.py b/tests/core/test_field_quantities.py new file mode 100644 index 0000000..e2d168a --- /dev/null +++ b/tests/core/test_field_quantities.py @@ -0,0 +1,460 @@ +""" +Unit tests for the FieldQuantities class. + +Tests displacement calculations, stress calculations, energy release rates, +and other field quantity computations. +""" + +import unittest + +import numpy as np + +from weac.components import Layer, WeakLayer +from weac.core.eigensystem import Eigensystem +from weac.core.field_quantities import FieldQuantities +from weac.core.slab import Slab + + +class TestFieldQuantitiesBasic(unittest.TestCase): + """Test basic field quantity calculations.""" + + def setUp(self): + """Set up test eigensystem and field quantities.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20, E=0.5) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + self.fq = FieldQuantities(eigensystem) + + # Create a simple test solution vector + # [u, u', w, w', psi, psi'] at multiple points + self.Z = np.array( + [ + [1.0, 2.0, 3.0], # u values at 3 points + [0.1, 0.2, 0.3], # u' values + [0.5, 1.0, 1.5], # w values + [0.05, 0.1, 0.15], # w' values + [0.01, 0.02, 0.03], # psi values + [0.001, 0.002, 0.003], # psi' values + ] + ) + + def test_center_line_displacement(self): + """Test center-line displacement calculation.""" + w_values = self.fq.w(self.Z) + + # Should return w values (row 2) in default units (mm) + expected = self.Z[2, :] + np.testing.assert_array_equal( + w_values, + expected, + err_msg="Center-line displacement should equal w component", + ) + + def test_center_line_displacement_units(self): + """Test center-line displacement with different units.""" + # Test different units + w_mm = self.fq.w(self.Z, unit="mm") + w_m = self.fq.w(self.Z, unit="m") + w_cm = self.fq.w(self.Z, unit="cm") + self.assertRaises(ValueError, self.fq.w, self.Z, unit="inch") + + # Check unit conversions + np.testing.assert_array_almost_equal( + w_m * 1000, + w_mm, + decimal=10, + err_msg="Meter to mm conversion should be correct", + ) + np.testing.assert_array_almost_equal( + w_cm * 10, + w_mm, + decimal=10, + err_msg="Centimeter to mm conversion should be correct", + ) + + def test_center_line_displacement_derivative(self): + """Test center-line displacement derivative.""" + dw_dx = self.fq.dw_dx(self.Z) + + # Should return w' values (row 3) + expected = self.Z[3, :] + np.testing.assert_array_equal( + dw_dx, expected, err_msg="Displacement derivative should equal w' component" + ) + + def test_rotation_calculation(self): + """Test rotation calculation.""" + psi_rad = self.fq.psi(self.Z, unit="rad") + psi_deg = self.fq.psi(self.Z, unit="deg") + + # Radians should equal psi component + expected_rad = self.Z[4, :] + np.testing.assert_array_equal( + psi_rad, + expected_rad, + err_msg="Rotation in radians should equal psi component", + ) + + # Degrees should be converted + expected_deg = expected_rad * 180 / np.pi + np.testing.assert_array_almost_equal( + psi_deg, + expected_deg, + decimal=10, + err_msg="Rotation conversion to degrees should be correct", + ) + + def test_rotation_derivative(self): + """Test rotation derivative calculation.""" + dpsi_dx = self.fq.dpsi_dx(self.Z) + + # Should return psi' values (row 5) + expected = self.Z[5, :] + np.testing.assert_array_equal( + dpsi_dx, expected, err_msg="Rotation derivative should equal psi' component" + ) + + +class TestFieldQuantitiesDisplacements(unittest.TestCase): + """Test displacement calculations at different heights.""" + + def setUp(self): + """Set up test system.""" + layers = [Layer(rho=250, h=120)] + weak_layer = WeakLayer(rho=60, h=25) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + self.fq = FieldQuantities(eigensystem) + + # Simple solution vector + self.Z = np.array( + [ + [2.0, 4.0], # u values + [0.2, 0.4], # u' values + [1.0, 2.0], # w values + [0.1, 0.2], # w' values + [0.05, 0.1], # psi values + [0.005, 0.01], # psi' values + ] + ) + + def test_displacement_at_different_heights(self): + """Test horizontal displacement at different heights.""" + h0 = 30.0 # Height above centerline + + u_values = self.fq.u(self.Z, h0) + + # u = u0 + h0 * psi + expected = self.Z[0, :] + h0 * self.Z[4, :] + np.testing.assert_array_almost_equal( + u_values, + expected, + decimal=10, + err_msg="Displacement at height should follow u = u0 + h*psi", + ) + + def test_displacement_derivative_at_height(self): + """Test displacement derivative at different heights.""" + h0 = 40.0 + + du_dx = self.fq.du_dx(self.Z, h0) + + # du/dx = u0' + h0 * psi' + expected = self.Z[1, :] + h0 * self.Z[5, :] + np.testing.assert_array_almost_equal( + du_dx, + expected, + decimal=10, + err_msg="Displacement derivative should follow du/dx = u0' + h*psi'", + ) + + def test_displacement_at_centerline(self): + """Test that displacement at centerline equals u0.""" + u_centerline = self.fq.u(self.Z, h0=0.0) + + # At centerline (h0=0), u = u0 + expected = self.Z[0, :] + np.testing.assert_array_equal( + u_centerline, expected, err_msg="Displacement at centerline should equal u0" + ) + + +class TestFieldQuantitiesStresses(unittest.TestCase): + """Test stress and force calculations.""" + + def setUp(self): + """Set up test system with known properties.""" + layers = [Layer(rho=200, h=100, E=50, nu=0.25)] # Known elastic properties + weak_layer = WeakLayer( + rho=50, h=20, E=0.5, kn=10.0, kt=5.0 + ) # Known stiffnesses + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + self.fq = FieldQuantities(eigensystem) + + # Test solution vector + self.Z = np.array( + [ + [1.0, 2.0], # u values + [0.1, 0.2], # u' values + [0.5, 1.0], # w values + [0.05, 0.1], # w' values + [0.01, 0.02], # psi values + [0.001, 0.002], # psi' values + ] + ) + + def test_axial_force_calculation(self): + """Test axial normal force calculation.""" + N = self.fq.N(self.Z) + + # N = A11 * u' + B11 * psi' + expected = self.fq.es.A11 * self.Z[1, :] + self.fq.es.B11 * self.Z[5, :] + np.testing.assert_array_almost_equal( + N, + expected, + decimal=10, + err_msg="Axial force should follow N = A11*u' + B11*psi'", + ) + + def test_bending_moment_calculation(self): + """Test bending moment calculation.""" + M = self.fq.M(self.Z) + + # M = B11 * u' + D11 * psi' + expected = self.fq.es.B11 * self.Z[1, :] + self.fq.es.D11 * self.Z[5, :] + np.testing.assert_array_almost_equal( + M, + expected, + decimal=10, + err_msg="Bending moment should follow M = B11*u' + D11*psi'", + ) + + def test_shear_force_calculation(self): + """Test vertical shear force calculation.""" + V = self.fq.V(self.Z) + + # V = kA55 * (w' + psi) + expected = self.fq.es.kA55 * (self.Z[3, :] + self.Z[4, :]) + np.testing.assert_array_almost_equal( + V, + expected, + decimal=10, + err_msg="Shear force should follow V = kA55*(w' + psi)", + ) + + def test_weak_layer_normal_stress(self): + """Test weak layer normal stress calculation.""" + sig_MPa = self.fq.sig(self.Z, unit="MPa") + sig_kPa = self.fq.sig(self.Z, unit="kPa") + + # sig = -kn * w + expected_MPa = -self.fq.es.weak_layer.kn * self.Z[2, :] + np.testing.assert_array_almost_equal( + sig_MPa, + expected_MPa, + decimal=10, + err_msg="Normal stress should follow sig = -kn*w", + ) + + # Check unit conversion + np.testing.assert_array_almost_equal( + sig_kPa, sig_MPa * 1000, decimal=8, err_msg="kPa should be 1000 times MPa" + ) + + def test_weak_layer_shear_stress(self): + """Test weak layer shear stress calculation.""" + tau = self.fq.tau(self.Z, unit="MPa") + + # tau = -kt * (w' * h/2 - u(h=H/2)) + h = self.fq.es.weak_layer.h + H = self.fq.es.slab.H + u_surface = self.fq.u(self.Z, h0=H / 2) + + expected = -self.fq.es.weak_layer.kt * (self.Z[3, :] * h / 2 - u_surface) + np.testing.assert_array_almost_equal( + tau, + expected, + decimal=10, + err_msg="Shear stress calculation should match expected formula", + ) + + +class TestFieldQuantitiesStrains(unittest.TestCase): + """Test strain calculations.""" + + def setUp(self): + """Set up test system.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + self.fq = FieldQuantities(eigensystem) + + self.Z = np.array( + [ + [1.0, 2.0], + [0.1, 0.2], + [0.5, 1.0], + [0.05, 0.1], + [0.01, 0.02], + [0.001, 0.002], + ] + ) + + def test_normal_strain_calculation(self): + """Test weak layer normal strain calculation.""" + eps = self.fq.eps(self.Z) + + # eps = -w / h + expected = -self.Z[2, :] / self.fq.es.weak_layer.h + np.testing.assert_array_almost_equal( + eps, expected, decimal=10, err_msg="Normal strain should follow eps = -w/h" + ) + + def test_shear_strain_calculation(self): + """Test weak layer shear strain calculation.""" + gamma = self.fq.gamma(self.Z) + + # gamma = w'/2 - u(h=H/2)/h + h = self.fq.es.weak_layer.h + H = self.fq.es.slab.H + u_surface = self.fq.u(self.Z, h0=H / 2) + + expected = self.Z[3, :] / 2 - u_surface / h + np.testing.assert_array_almost_equal( + gamma, + expected, + decimal=10, + err_msg="Shear strain should follow gamma = w'/2 - u(H/2)/h", + ) + + +class TestFieldQuantitiesEnergyReleaseRates(unittest.TestCase): + """Test energy release rate calculations.""" + + def setUp(self): + """Set up test system.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20, kn=10.0, kt=5.0) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + self.fq = FieldQuantities(eigensystem) + + # Single point solution vector (crack tip) + self.Z_tip = np.array( + [ + [1.0], # u + [0.1], # u' + [0.5], # w + [0.05], # w' + [0.01], # psi + [0.001], # psi' + ] + ) + + def test_mode_I_energy_release_rate(self): + """Test Mode I energy release rate calculation.""" + G_I = self.fq.Gi(self.Z_tip, unit="kJ/m^2") + + # G_I = sig^2 / (2 * kn) + sig = self.fq.sig(self.Z_tip, unit="MPa") + expected = sig**2 / (2 * self.fq.es.weak_layer.kn) + + np.testing.assert_array_almost_equal( + G_I, + expected, + decimal=10, + err_msg="Mode I ERR should follow G_I = sigΒ²/(2*kn)", + ) + + def test_mode_II_energy_release_rate(self): + """Test Mode II energy release rate calculation.""" + G_II = self.fq.Gii(self.Z_tip, unit="kJ/m^2") + + # G_II = tau^2 / (2 * kt) + tau = self.fq.tau(self.Z_tip, unit="MPa") + expected = tau**2 / (2 * self.fq.es.weak_layer.kt) + + np.testing.assert_array_almost_equal( + G_II, + expected, + decimal=10, + err_msg="Mode II ERR should follow G_II = tauΒ²/(2*kt)", + ) + + def test_energy_release_rate_units(self): + """Test energy release rate unit conversions.""" + G_I_kJ = self.fq.Gi(self.Z_tip, unit="kJ/m^2") + G_I_J = self.fq.Gi(self.Z_tip, unit="J/m^2") + G_I_N = self.fq.Gi(self.Z_tip, unit="N/mm") + + # Check unit conversions + np.testing.assert_array_almost_equal( + G_I_J, G_I_kJ * 1000, decimal=8, err_msg="J/mΒ² should be 1000 times kJ/mΒ²" + ) + np.testing.assert_array_almost_equal( + G_I_N, G_I_kJ, decimal=10, err_msg="N/mm should equal kJ/mΒ²" + ) + + +class TestFieldQuantitiesPhysicalConsistency(unittest.TestCase): + """Test physical consistency of field quantity calculations.""" + + def test_displacement_continuity(self): + """Test that displacements are continuous across heights.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + fq = FieldQuantities(eigensystem) + + Z = np.array([[1.0], [0.1], [0.5], [0.05], [0.01], [0.001]]) + + # Test displacement at nearby heights + h1, h2 = 30.0, 30.00001 + u1 = fq.u(Z, h1) + u2 = fq.u(Z, h2) + + # Should be very close for nearby heights + self.assertAlmostEqual( + u1[0], u2[0], places=6, msg="Displacement should be continuous" + ) + + def test_stress_sign_conventions(self): + """Test that stress sign conventions are physically reasonable.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + fq = FieldQuantities(eigensystem) + + # Positive deflection should give negative normal stress (compression) + Z_positive_w = np.array([[0], [0], [1.0], [0], [0], [0]]) # Positive w + sig_pos = fq.sig(Z_positive_w) + + self.assertLess( + sig_pos[0], 0, "Positive deflection should give compressive stress" + ) + + def test_energy_release_rate_positivity(self): + """Test that energy release rates are always positive.""" + layers = [Layer(rho=200, h=100)] + weak_layer = WeakLayer(rho=50, h=20) + slab = Slab(layers) + eigensystem = Eigensystem(weak_layer, slab) + fq = FieldQuantities(eigensystem) + + # Any non-zero solution should give positive ERR + Z_nonzero = np.array([[1.0], [0.1], [0.5], [0.05], [0.01], [0.001]]) + + G_I = fq.Gi(Z_nonzero) + G_II = fq.Gii(Z_nonzero) + + self.assertGreaterEqual(G_I[0], 0, "Mode I ERR should be non-negative") + self.assertGreaterEqual(G_II[0], 0, "Mode II ERR should be non-negative") + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/core/test_scenario.py b/tests/core/test_scenario.py new file mode 100644 index 0000000..4cf9771 --- /dev/null +++ b/tests/core/test_scenario.py @@ -0,0 +1,144 @@ +""" +This module contains tests for the Scenario class. +""" + +import unittest + +import numpy as np + +from weac.components import Layer, ScenarioConfig, Segment, WeakLayer +from weac.core.scenario import Scenario +from weac.core.slab import Slab +from weac.utils.misc import decompose_to_normal_tangential + + +class TestScenario(unittest.TestCase): + """Test the Scenario class.""" + + def setUp(self): + # Simple slab with a single layer + self.layer = Layer(rho=200, h=100) + self.slab = Slab([self.layer]) + # Weak layer with defaults (kn derived from properties) + self.weak_layer = WeakLayer(rho=150, h=30) + # Default two segments to test typical case + self.segments_two = [ + Segment(length=400.0, has_foundation=True, m=75.0), + Segment(length=600.0, has_foundation=True, m=0.0), + ] + # Config with non-zero angle and surface load to exercise load decomposition + self.cfg = ScenarioConfig( + phi=10.0, system_type="skiers", surface_load=0.2, cut_length=123.0 + ) + + def test_init_sets_core_attributes(self): + """Test that init sets core attributes correctly.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + self.assertEqual(s.system_type, self.cfg.system_type) + self.assertAlmostEqual(s.phi, self.cfg.phi) + self.assertAlmostEqual(s.surface_load, self.cfg.surface_load) + # L is total length + self.assertAlmostEqual(s.L, sum(seg.length for seg in self.segments_two)) + # cut_length is propagated + self.assertAlmostEqual(s.cut_length, self.cfg.cut_length) + + def test_setup_scenario_multiple_segments(self): + """Test that setup_scenario sets up correctly for multiple segments.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + # li is segment lengths + np.testing.assert_allclose(s.li, np.array([400.0, 600.0])) + # ki reflects foundation flags + np.testing.assert_array_equal(s.ki, np.array([True, True])) + # mi are masses at internal boundaries (all but last segment) + np.testing.assert_allclose(s.mi, np.array([75.0])) + # cumulative length + np.testing.assert_allclose(s.cum_sum_li, np.array([400.0, 1000.0])) + # get_segment_idx mapping across domains + self.assertEqual(s.get_segment_idx(0.0), 0) + self.assertEqual(s.get_segment_idx(399.9999), 0) + # exactly on boundary goes to next bin + self.assertEqual(s.get_segment_idx(400.0), 1) + self.assertEqual(s.get_segment_idx(999.9999), 1) + # vectorized + np.testing.assert_array_equal( + s.get_segment_idx(np.array([0.0, 100.0, 400.0, 500.0, 999.0])), + np.array([0, 0, 1, 1, 1]), + ) + # out of bounds (> L) raises + with self.assertRaisesRegex(ValueError, r"out of bounds|exceeds|beyond"): + s.get_segment_idx(1000.0001) + + def test_setup_scenario_single_segment_adds_dummy(self): + """Test that setup_scenario adds a dummy segment for single segment case.""" + segments_one = [Segment(length=750.0, has_foundation=True, m=0.0)] + s = Scenario(self.cfg, segments_one, self.weak_layer, self.slab) + # Dummy segment appended + self.assertEqual(len(s.li), 2) + self.assertAlmostEqual(s.li[0], 750.0) + self.assertAlmostEqual(s.li[1], 0.0) + self.assertTrue(bool(s.ki[1])) + self.assertAlmostEqual(s.mi[-1], 0.0) + # L equals the actual provided length + self.assertAlmostEqual(s.L, 750.0) + # get_segment_idx behavior at end + self.assertEqual(s.get_segment_idx(749.9999), 0) + # x == L is allowed and maps to bin 1 + self.assertEqual(s.get_segment_idx(750.0), 1) + with self.assertRaisesRegex(ValueError, r"out of bounds|exceeds|beyond"): + s.get_segment_idx(750.0001) + + def test_calc_normal_and_tangential_loads(self): + """Test that calc_normal_and_tangential_loads computes expected loads.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + # Expected from decomposition of slab weight and surface load + qwn, qwt = decompose_to_normal_tangential(self.slab.qw, self.cfg.phi) + qsn, qst = decompose_to_normal_tangential(self.cfg.surface_load, self.cfg.phi) + np.testing.assert_allclose(s.qn, qwn + qsn, rtol=1e-12, atol=1e-12) + np.testing.assert_allclose(s.qt, qwt + qst, rtol=1e-12, atol=1e-12) + # Sanity signs: qn positive (into slope), qt negative (downslope) + self.assertGreater(s.qn, 0.0) + self.assertLessEqual(s.qt, 0.0) + + def test_calc_crack_height(self): + """Test that calc_crack_height computes expected crack height.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + expected_crack_h = self.weak_layer.collapse_height - s.qn / self.weak_layer.kn + self.assertTrue(np.isfinite(expected_crack_h)) + self.assertAlmostEqual(s.crack_h, expected_crack_h) + + def test_refresh_from_config_updates_attributes( + self, + ): + """Test that refresh_from_config updates attributes.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + # Change config values + s.scenario_config.phi = 25.0 + s.scenario_config.surface_load = 0.2 + s.scenario_config.system_type = "pst-" + s.refresh_from_config() + # Attributes copied from config + self.assertEqual(s.system_type, "pst-") + self.assertAlmostEqual(s.phi, 25.0) + self.assertAlmostEqual(s.surface_load, 0.2) + + def test_refresh_recomputes_setup_when_segments_change(self): + """Test that refresh_from_config recomputes setup when segments change.""" + s = Scenario(self.cfg, self.segments_two, self.weak_layer, self.slab) + # Mutate segments: change lengths and foundation flags + new_segments = [ + Segment(length=100.0, has_foundation=True, m=0.0), + Segment(length=200.0, has_foundation=False, m=0.0), + Segment(length=300.0, has_foundation=True, m=0.0), + ] + s.segments = new_segments + # refresh_from_config should call _setup_scenario and _calc_crack_height + s.refresh_from_config() + np.testing.assert_allclose(s.li, np.array([100.0, 200.0, 300.0])) + np.testing.assert_array_equal(s.ki, np.array([True, False, True])) + np.testing.assert_allclose(s.mi, np.array([0.0, 0.0])) + np.testing.assert_allclose(s.cum_sum_li, np.array([100.0, 300.0, 600.0])) + self.assertAlmostEqual(s.L, 600.0) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/core/test_slab.py b/tests/core/test_slab.py new file mode 100644 index 0000000..d8cbb9a --- /dev/null +++ b/tests/core/test_slab.py @@ -0,0 +1,286 @@ +""" +Unit tests for the Slab class. + +Tests layer assembly, property calculations, center of gravity, and physical consistency. +""" + +import unittest + +import numpy as np + +from weac.components import Layer +from weac.constants import G_MM_S2 +from weac.core.slab import Slab + + +class TestSlabBasicOperations(unittest.TestCase): + """Test basic slab assembly and property calculations.""" + + def test_single_layer_slab(self): + """Test slab with a single layer.""" + layer = Layer(rho=250, h=100) + slab = Slab([layer]) + + # Check basic properties + self.assertEqual(len(slab.layers), 1) + self.assertEqual( + slab.H, 100.0, "Total thickness should equal single layer thickness" + ) + self.assertEqual(slab.hi[0], 100.0) + self.assertEqual(slab.rhoi[0], 250e-12, "Density should be converted to t/mmΒ³") + + # Check coordinate system (z=0 at slab midpoint) + self.assertEqual(slab.zi_mid[0], 0.0, "Single layer midpoint should be at z=0") + self.assertEqual(slab.zi_bottom[0], 50.0, "Bottom should be H/2 below midpoint") + + def test_multi_layer_slab(self): + """Test slab with multiple layers.""" + layers = [ + Layer(rho=150, h=50), # Top layer + Layer(rho=200, h=80), # Middle layer + Layer(rho=300, h=70), # Bottom layer + ] + slab = Slab(layers) + + # Check total thickness + expected_H = 50 + 80 + 70 + self.assertEqual(slab.H, expected_H) + + # Check layer thicknesses + np.testing.assert_array_almost_equal(slab.hi, [50, 80, 70]) + + # Check densities (converted to t/mmΒ³) + expected_rho = np.array([150, 200, 300]) * 1e-12 + np.testing.assert_array_almost_equal(slab.rhoi, expected_rho) + + # Check coordinate system + # Layer midpoints calculated as: H/2 - sum(hi[j:n]) + hi[j]/2 + # For H=200, hi=[50,80,70]: + # j=0: 100 - (50+80+70) + 50/2 = 100 - 200 + 25 = -75 + # j=1: 100 - (80+70) + 80/2 = 100 - 150 + 40 = -10 + # j=2: 100 - (70) + 70/2 = 100 - 70 + 35 = 65 + expected_zi_mid = [-75, -10, 65] + np.testing.assert_array_almost_equal(slab.zi_mid, expected_zi_mid) + + # Layer bottom coordinates + expected_zi_bottom = [-50, 30, 100] # Cumulative from top, centered at midpoint + np.testing.assert_array_almost_equal(slab.zi_bottom, expected_zi_bottom) + + +class TestSlabCenterOfGravity(unittest.TestCase): + """Test center of gravity calculations.""" + + def test_uniform_density_slab(self): + """Test CoG for uniform density slab.""" + layers = [ + Layer(rho=200, h=100), + Layer(rho=200, h=100), + ] + slab = Slab(layers) + + # For uniform density, CoG should be at geometric center (z=0) + self.assertAlmostEqual( + slab.z_cog, + 0.0, + places=5, + msg="Uniform density slab should have CoG at geometric center", + ) + + def test_density_gradient_slab(self): + """Test CoG for slab with density gradient.""" + layers = [ + Layer(rho=110, h=100), # Light top layer + Layer(rho=400, h=100), # Heavy bottom layer + ] + slab = Slab(layers) + + # CoG should shift toward heavier bottom layer (positive z) + self.assertGreater( + slab.z_cog, 0.0, "CoG should shift toward heavier bottom layer" + ) + + def test_top_heavy_slab(self): + """Test CoG for top-heavy slab.""" + layers = [ + Layer(rho=400, h=100), # Heavy top layer + Layer(rho=110, h=100), # Light bottom layer + ] + slab = Slab(layers) + + # CoG should shift toward heavier top layer (negative z) + self.assertLess(slab.z_cog, 0.0, "CoG should shift toward heavier top layer") + + +class TestSlabWeightCalculations(unittest.TestCase): + """Test weight and load calculations.""" + + def test_weight_load_calculation(self): + """Test calculation of weight load per unit length.""" + layers = [Layer(rho=200, h=100, E=50, G=20)] + slab = Slab(layers) + + # qw = sum(rho * g * h) for all layers + expected_qw = 200e-12 * G_MM_S2 * 100 # t/mmΒ³ * mm/sΒ² * mm = t*mm/sΒ²/mmΒ² = N/mm + self.assertAlmostEqual(slab.qw, expected_qw, places=8) + + def test_multi_layer_weight(self): + """Test weight calculation for multiple layers.""" + layers = [ + Layer(rho=150, h=60), + Layer(rho=250, h=80), + Layer(rho=350, h=100), + ] + slab = Slab(layers) + + # Calculate expected total weight per unit length + expected_qw = (150 * 60 + 250 * 80 + 350 * 100) * 1e-12 * G_MM_S2 + self.assertAlmostEqual(slab.qw, expected_qw, places=8) + + +class TestSlabVerticalCenterOfGravity(unittest.TestCase): + """Test vertical center of gravity calculations for inclined slabs.""" + + def test_vertical_cog_flat_surface(self): + """Test vertical CoG calculation for flat surface (phi=0).""" + layers = [Layer(rho=200, h=100)] + slab = Slab(layers) + + x_cog, z_cog, w = slab.calc_vertical_center_of_gravity(phi=0) + + # For flat surface, should have zero displacement and weight + self.assertEqual(x_cog, 0.0) + self.assertEqual(z_cog, 0.0) + self.assertEqual(w, 0.0) + + def test_vertical_cog_inclined_surface(self): + """Test vertical CoG calculation for inclined surface.""" + layers = [ + Layer(rho=200, h=50), + Layer(rho=300, h=100), + ] + slab = Slab(layers) + + x_cog, z_cog, w = slab.calc_vertical_center_of_gravity(phi=30) + + # For inclined surface, should have non-zero values + self.assertNotEqual( + x_cog, 0.0, "Horizontal CoG should be non-zero for inclined surface" + ) + self.assertNotEqual( + z_cog, 0.0, "Vertical CoG should be non-zero for inclined surface" + ) + self.assertGreater(w, 0.0, "Weight should be positive") + + def test_vertical_cog_steep_inclination(self): + """Test vertical CoG for steep inclination.""" + layers = [Layer(rho=250, h=80)] + slab = Slab(layers) + + x_cog_30, _, w_30 = slab.calc_vertical_center_of_gravity(phi=30) + x_cog_60, _, w_60 = slab.calc_vertical_center_of_gravity(phi=60) + + # Steeper inclination should result in larger displacements and weights + self.assertGreater( + abs(x_cog_60), + abs(x_cog_30), + "Steeper inclination should increase horizontal displacement", + ) + self.assertGreater( + w_60, + w_30, + "Steeper inclination should increase weight of triangular segment", + ) + + +class TestSlabElasticProperties(unittest.TestCase): + """Test elastic property assembly.""" + + def test_elastic_property_arrays(self): + """Test that elastic properties are correctly assembled.""" + layers = [ + Layer(rho=200, h=100, E=30, G=12, nu=0.25), + Layer(rho=300, h=150, E=60, G=24, nu=0.25), + ] + slab = Slab(layers) + + # Check Young's moduli + np.testing.assert_array_equal(slab.Ei, [30, 60]) + + # Check shear moduli + np.testing.assert_array_equal(slab.Gi, [12, 24]) + + # Check Poisson's ratios + np.testing.assert_array_equal(slab.nui, [0.25, 0.25]) + + def test_automatic_property_calculation(self): + """Test that properties are auto-calculated when not specified.""" + layers = [Layer(rho=250, h=120)] # Only rho and h specified + slab = Slab(layers) + + # Properties should be auto-calculated and positive + self.assertGreater( + slab.Ei[0], 0, "Young's modulus should be auto-calculated and positive" + ) + self.assertGreater( + slab.Gi[0], 0, "Shear modulus should be auto-calculated and positive" + ) + self.assertEqual(slab.nui[0], 0.25, "Default Poisson's ratio should be 0.25") + + +class TestSlabPhysicalConsistency(unittest.TestCase): + """Test physical consistency of slab calculations.""" + + def test_coordinate_system_consistency(self): + """Test that coordinate system is consistent.""" + layers = [ + Layer(rho=150, h=80), + Layer(rho=200, h=60), + Layer(rho=250, h=100), + ] + slab = Slab(layers) + + # Total thickness should equal sum of layer thicknesses + self.assertEqual(slab.H, sum(slab.hi)) + + # Bottom of last layer should be at H/2 + self.assertAlmostEqual(slab.zi_bottom[-1], slab.H / 2, places=5) + + # Top of first layer should be at -H/2 + # (first layer bottom - first layer thickness) + top_of_first = slab.zi_bottom[0] - slab.hi[0] + self.assertAlmostEqual(top_of_first, -slab.H / 2, places=5) + + def test_center_of_gravity_bounds(self): + """Test that center of gravity is within slab bounds.""" + layers = [ + Layer(rho=110, h=50), # Very light top + Layer(rho=500, h=50), # Very heavy bottom + ] + slab = Slab(layers) + + # CoG should be within slab thickness bounds + self.assertGreaterEqual( + slab.z_cog, -slab.H / 2, "CoG should be within slab (above top)" + ) + self.assertLessEqual( + slab.z_cog, slab.H / 2, "CoG should be within slab (below bottom)" + ) + + def test_mass_conservation(self): + """Test that mass calculations are consistent.""" + layers = [ + Layer(rho=200, h=80), + Layer(rho=300, h=120), + ] + slab = Slab(layers) + + # Calculate total mass per unit length + total_mass_per_length = sum(layer.rho * 1e-12 * layer.h for layer in layers) + + # Weight per unit length should equal mass per length times gravity + expected_weight = total_mass_per_length * G_MM_S2 + self.assertAlmostEqual(slab.qw, expected_weight, places=10) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/core/test_slab_touchdown.py b/tests/core/test_slab_touchdown.py new file mode 100644 index 0000000..bd34c93 --- /dev/null +++ b/tests/core/test_slab_touchdown.py @@ -0,0 +1,263 @@ +""" +This module contains tests for the SlabTouchdown class. +""" + +import unittest +from unittest.mock import patch + +import numpy as np + +from weac.components import Layer, ScenarioConfig, Segment, WeakLayer +from weac.constants import STIFFNESS_COLLAPSE_FACTOR +from weac.core.eigensystem import Eigensystem +from weac.core.scenario import Scenario +from weac.core.slab import Slab +from weac.core.slab_touchdown import SlabTouchdown + + +class SlabTouchdownTestBase(unittest.TestCase): + """Base class for SlabTouchdown tests, providing common setup.""" + + def make_base_objects(self): + """Make base objects for testing.""" + layers = [Layer(rho=220, h=120)] + slab = Slab(layers) + weak_layer = WeakLayer(rho=120, h=25) + # Two segments: supported then unsupported, typical PST layout + segments = [ + Segment(length=5e3, has_foundation=True, m=0.0), + Segment(length=200.0, has_foundation=False, m=0.0), + ] + cfg = ScenarioConfig( + phi=10.0, system_type="pst-", cut_length=200.0, surface_load=0.0 + ) + scenario = Scenario(cfg, segments, weak_layer, slab) + eig = Eigensystem(weak_layer, slab) + return scenario, eig + + +class TestSlabTouchdownInitialization(SlabTouchdownTestBase): + """Test the initialization of the SlabTouchdown class.""" + + def test_init_sets_flat_config_and_collapsed_eigensystem(self): + """Test the initialization of the SlabTouchdown class.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # flat_config has phi=0 and preserves other fields + self.assertEqual(td.flat_config.phi, 0.0) + self.assertEqual( + td.flat_config.system_type, scenario.scenario_config.system_type + ) + self.assertEqual(td.flat_config.cut_length, scenario.scenario_config.cut_length) + self.assertEqual( + td.flat_config.surface_load, scenario.scenario_config.surface_load + ) + # collapsed weak layer stiffness scaled + self.assertAlmostEqual( + td.collapsed_weak_layer.kn, + scenario.weak_layer.kn * STIFFNESS_COLLAPSE_FACTOR, + ) + self.assertAlmostEqual( + td.collapsed_weak_layer.kt, + scenario.weak_layer.kt * STIFFNESS_COLLAPSE_FACTOR, + ) + # collapsed eigensystem uses collapsed weak layer and same slab + self.assertIs(td.collapsed_eigensystem.weak_layer, td.collapsed_weak_layer) + self.assertIs(td.collapsed_eigensystem.slab, scenario.slab) + + +class TestSlabTouchdownBoundaries(SlabTouchdownTestBase): + """Test the calculation of touchdown mode boundaries.""" + + def test_calc_l_AB_root_exists_and_within_bounds(self): + """Test the calculation of touchdown mode boundaries.""" + scenario, eig = self.make_base_objects() + # Avoid heavy setup + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Make bs positive and control substitute stiffness to constants + td.eigensystem.A11 = 100.0 + td.eigensystem.B11 = 1.0 + td.eigensystem.D11 = 100.0 + td.eigensystem.kA55 = 10.0 + with patch.object(td, "_substitute_stiffness", return_value=2.0): + l_ab = td._calc_l_AB() # pylint: disable=protected-access + self.assertGreater(l_ab, 0.0) + self.assertLess(l_ab, td.scenario.L) + + def test_calc_l_BC_root_exists_and_within_bounds(self): + """Test the calculation of touchdown mode boundaries.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Make bs positive and control substitute stiffness to constants + td.eigensystem.A11 = 100.0 + td.eigensystem.B11 = 1.0 + td.eigensystem.D11 = 100.0 + td.eigensystem.kA55 = 10.0 + with patch.object(td, "_substitute_stiffness", return_value=3.0): + l_bc = td._calc_l_BC() # pylint: disable=protected-access + self.assertGreater(l_bc, 0.0) + self.assertLess(l_bc, td.scenario.L) + + +class TestSlabTouchdownModeAndDistance(SlabTouchdownTestBase): + """Test the calculation of touchdown mode and distance.""" + + def test_calc_touchdown_mode_assigns_correct_mode(self): + """Test the calculation of touchdown mode and distance.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + with ( + patch.object(td, "_calc_l_AB", return_value=300.0), + patch.object(td, "_calc_l_BC", return_value=600.0), + ): + # Mode A: cut_length <= l_AB + td.scenario.scenario_config.cut_length = 200.0 + td.scenario.cut_length = 200.0 + td._calc_touchdown_mode() # pylint: disable=protected-access + self.assertEqual(td.touchdown_mode, "A_free_hanging") + # Mode B: l_AB < cut_length <= l_BC + td.scenario.scenario_config.cut_length = 400.0 + td.scenario.cut_length = 400.0 + td._calc_touchdown_mode() # pylint: disable=protected-access + self.assertEqual(td.touchdown_mode, "B_point_contact") + # Mode C: cut_length > l_BC + td.scenario.scenario_config.cut_length = 800.0 + td.scenario.cut_length = 800.0 + td._calc_touchdown_mode() # pylint: disable=protected-access + self.assertEqual(td.touchdown_mode, "C_in_contact") + + def test_calc_touchdown_distance_sets_expected_values(self): + """Test the calculation of touchdown mode and distance.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Mode A/B: equals cut_length + td.touchdown_mode = "A_free_hanging" + td.scenario.cut_length = 123.0 + td._calc_touchdown_distance() # pylint: disable=protected-access + self.assertEqual(td.touchdown_distance, 123.0) + + td.touchdown_mode = "B_point_contact" + td.scenario.cut_length = 321.0 + td._calc_touchdown_distance() # pylint: disable=protected-access + self.assertEqual(td.touchdown_distance, 321.0) + + # Mode C: uses helper methods + td.touchdown_mode = "C_in_contact" + with ( + patch.object(td, "_calc_touchdown_distance_in_mode_C", return_value=111.0), + patch.object(td, "_calc_collapsed_weak_layer_kR", return_value=222.0), + ): + td._calc_touchdown_distance() # pylint: disable=protected-access + self.assertEqual(td.touchdown_distance, 111.0) + self.assertEqual(td.collapsed_weak_layer_kR, 222.0) + + +class TestSlabTouchdownHelpers(SlabTouchdownTestBase): + """Test helper methods for the SlabTouchdown class.""" + + def test_generate_straight_scenario(self): + """Test the generation of a straight scenario.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + L = 555.5 + straight = td._generate_straight_scenario(L) # pylint: disable=protected-access + self.assertAlmostEqual(straight.L, L) + self.assertEqual(straight.phi, 0.0) + # First segment should be the provided one, dummy appended internally + self.assertGreaterEqual(len(straight.li), 1) + self.assertTrue(bool(straight.ki[0])) + + def test_create_collapsed_eigensystem_scales_weak_layer(self): + """Test the creation of a collapsed eigensystem.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Recreate to test method in isolation + collapsed = td._create_collapsed_eigensystem() # pylint: disable=protected-access + self.assertAlmostEqual( + collapsed.weak_layer.kn, scenario.weak_layer.kn * STIFFNESS_COLLAPSE_FACTOR + ) + self.assertAlmostEqual( + collapsed.weak_layer.kt, scenario.weak_layer.kt * STIFFNESS_COLLAPSE_FACTOR + ) + + def test_calc_touchdown_distance_in_mode_C_root_in_range(self): + """Test the calculation of touchdown mode and distance.""" + scenario, eig = self.make_base_objects() + scenario.scenario_config.cut_length = 300.0 + scenario.cut_length = 300.0 + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Make bs positive and control substitute stiffness values by inspecting args + td.eigensystem.A11 = 100.0 + td.eigensystem.B11 = 1.0 + td.eigensystem.D11 = 100.0 + td.eigensystem.kA55 = 10.0 + + def fake_subst(straight_scenario, es, dof): # pylint: disable=unused-argument + """Fake substitute stiffness.""" + # Return different constants for original vs collapsed eigensystem + if es is td.eigensystem: + return 2.0 # kRl or kNl + if es is td.collapsed_eigensystem: + return 5.0 # kRr + return 3.0 + + with patch.object(td, "_substitute_stiffness", side_effect=fake_subst): + d = td._calc_touchdown_distance_in_mode_C() # pylint: disable=protected-access + + self.assertGreater(d, 0.0) + self.assertLess(d, scenario.cut_length) + + def test_calc_collapsed_weak_layer_kR_returns_positive(self): + """Test the calculation of collapsed weak layer stiffness.""" + scenario, eig = self.make_base_objects() + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + td.touchdown_mode = "A_free_hanging" + td.touchdown_distance = 100.0 + with patch.object(td, "_substitute_stiffness", return_value=7.5): + kR = td._calc_collapsed_weak_layer_kR() # pylint: disable=protected-access + self.assertGreater(kR, 0.0) + self.assertAlmostEqual(kR, 7.5) + + def test_substitute_stiffness_rot_and_trans_are_finite(self): + """Test the calculation of substitute stiffness.""" + scenario, eig = self.make_base_objects() + # Avoid running setup (roots) and use method directly + with patch.object(SlabTouchdown, "_setup_touchdown_system", return_value=None): + td = SlabTouchdown(scenario, eig) + # Use a small, straight scenario to compute substitute stiffness + straight = td._generate_straight_scenario(L=400.0) # pylint: disable=protected-access + kR = td._substitute_stiffness(straight, td.eigensystem, dof="rot") # pylint: disable=protected-access + kN = td._substitute_stiffness(straight, td.eigensystem, dof="trans") # pylint: disable=protected-access + self.assertTrue(np.isfinite(kR)) + self.assertTrue(np.isfinite(kN)) + self.assertGreater(kR, 0.0) + self.assertGreater(kN, 0.0) + + def test_setup_touchdown_system_calls_subroutines(self): + """Test the setup of the touchdown system.""" + scenario, eig = self.make_base_objects() + with ( + patch.object( + SlabTouchdown, "_calc_touchdown_mode", return_value=None + ) as m1, + patch.object( + SlabTouchdown, "_calc_touchdown_distance", return_value=None + ) as m2, + ): + SlabTouchdown(scenario, eig) + # The constructor calls _setup_touchdown_system which should call both + self.assertTrue(m1.called) + self.assertTrue(m2.called) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/core/test_system_model.py b/tests/core/test_system_model.py new file mode 100644 index 0000000..97e0205 --- /dev/null +++ b/tests/core/test_system_model.py @@ -0,0 +1,416 @@ +""" +This module contains tests for the SystemModel class. +""" + +import unittest +from unittest.mock import MagicMock, patch + +import numpy as np + +from weac.components import ( + Config, + Layer, + ModelInput, + ScenarioConfig, + SystemType, + Segment, + WeakLayer, +) +from weac.core.system_model import SystemModel + + +class TestSystemModelCaching(unittest.TestCase): + """Test caching mechanisms in the SystemModel.""" + + def setUp(self): + """Set up common components for tests.""" + self.config = Config() + self.layers = [Layer(rho=200, h=500)] + self.weak_layer = WeakLayer(rho=150, h=10) + self.segments = [Segment(length=10000, has_foundation=True, m=0)] + self.scenario_config = ScenarioConfig(phi=30, system_type="skiers") + + @patch("weac.core.eigensystem.Eigensystem.calc_eigensystem") + def test_eigensystem_calculation_called_once(self, mock_calc): + """Test that eigensystem calculation is called only once when cached.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + + # Access eigensystem multiple times + _ = system.eigensystem + _ = system.eigensystem + _ = system.eigensystem + + # calc_eigensystem should only be called once due to caching + self.assertEqual( + mock_calc.call_count, + 1, + "Eigensystem calculation should only be called once", + ) + + def test_eigensystem_caching(self): + """Test that eigensystem is cached and reused.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + eigensystem1 = system.eigensystem + eigensystem2 = system.eigensystem + self.assertIs( + eigensystem1, eigensystem2, "Cached eigensystem should be the same object" + ) + + def test_unknown_constants_caching(self): + """Test that unknown constants are cached and reused.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + constants1 = system.unknown_constants + constants2 = system.unknown_constants + self.assertIs( + constants1, constants2, "Cached constants should be the same object" + ) + + def test_slab_update_invalidates_all_caches(self): + """Test that slab updates invalidate both eigensystem and unknown constants.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + eigensystem_before = system.eigensystem + constants_before = system.unknown_constants + + # Update the slab layers + system.update_layers(new_layers=[Layer(rho=250, h=600)]) + + eigensystem_after = system.eigensystem + constants_after = system.unknown_constants + + self.assertIsNot(eigensystem_before, eigensystem_after) + self.assertIsNot(constants_before, constants_after) + + def test_weak_layer_update_invalidates_all_caches(self): + """Test that weak layer updates invalidate both caches.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + eigensystem_before = system.eigensystem + constants_before = system.unknown_constants + + # Update the weak layer + system.update_weak_layer(WeakLayer(rho=160, h=12)) + + eigensystem_after = system.eigensystem + constants_after = system.unknown_constants + + self.assertIsNot(eigensystem_before, eigensystem_after) + self.assertIsNot(constants_before, constants_after) + + def test_scenario_update_invalidates_constants_only(self): + """Test that scenario updates only invalidate unknown constants, not eigensystem.""" + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=self.scenario_config, + ) + system = SystemModel(model_input=model_input, config=self.config) + eigensystem_before = system.eigensystem + constants_before = system.unknown_constants + + # Update the scenario + new_cfg = system.scenario.scenario_config.model_copy() + new_cfg.phi = 45.0 + system.update_scenario(scenario_config=new_cfg) + + eigensystem_after = system.eigensystem + constants_after = system.unknown_constants + + self.assertIs(eigensystem_before, eigensystem_after) + self.assertIsNot(constants_before, constants_after) + + +class TestSystemModelBehavior(unittest.TestCase): + """Test the behavior of the SystemModel class.""" + + def setUp(self): + """Set up the test environment.""" + self.config = Config() + self.layers = [Layer(rho=200, h=500)] + self.weak_layer = WeakLayer(rho=150, h=10) + self.segments = [ + Segment(length=10000, has_foundation=True, m=80), + Segment(length=4000, has_foundation=False, m=0), + ] + self.scenario_config = ScenarioConfig( + phi=10.0, system_type="skiers", cut_length=3000.0 + ) + + def _build_model( + self, touchdown: bool = False, system_type: SystemType = "skiers" + ) -> SystemModel: + config = Config(touchdown=touchdown) + sc = ScenarioConfig(phi=10.0, system_type=system_type, cut_length=3000.0) + model_input = ModelInput( + layers=self.layers, + weak_layer=self.weak_layer, + segments=self.segments, + scenario_config=sc, + ) + return SystemModel(model_input=model_input, config=config) + + @patch("weac.core.system_model.SlabTouchdown") + def test_touchdown_updates_segments_for_pst_minus(self, mock_td): + """Test that touchdown updates segments for pst-.""" + mock_inst = MagicMock() + mock_inst.touchdown_distance = 1234.0 + mock_inst.touchdown_mode = "B_point_contact" + mock_inst.collapsed_weak_layer_kR = 42.0 + mock_td.return_value = mock_inst + + system = self._build_model(touchdown=True, system_type="pst-") + _ = system.slab_touchdown # trigger + + self.assertEqual(system.scenario.segments[-1].length, 1234.0) + + @patch("weac.core.system_model.SlabTouchdown") + def test_touchdown_updates_segments_for_minus_pst(self, mock_td): + """Test that touchdown updates segments for -pst.""" + mock_inst = MagicMock() + mock_inst.touchdown_distance = 2222.0 + mock_inst.touchdown_mode = "B_point_contact" + mock_inst.collapsed_weak_layer_kR = 11.0 + mock_td.return_value = mock_inst + + system = self._build_model(touchdown=True, system_type="-pst") + _ = system.slab_touchdown # trigger + + self.assertEqual(system.scenario.segments[0].length, 2222.0) + + @patch("weac.core.system_model.UnknownConstantsSolver.solve_for_unknown_constants") + @patch("weac.core.system_model.SlabTouchdown") + def test_unknown_constants_uses_touchdown_params_when_enabled( + self, mock_td, mock_solve + ): + """Test that unknown constants uses touchdown params when enabled.""" + mock_inst = MagicMock() + mock_inst.touchdown_distance = 1500.0 + mock_inst.touchdown_mode = "C_in_contact" + mock_inst.collapsed_weak_layer_kR = 7.5 + mock_td.return_value = mock_inst + + def solver_side_effect( + scenario, + eigensystem, # pylint: disable=unused-argument + system_type, # pylint: disable=unused-argument + touchdown_distance, # pylint: disable=unused-argument + touchdown_mode, # pylint: disable=unused-argument + collapsed_weak_layer_kR, # pylint: disable=unused-argument + ): + n = len(scenario.segments) + return np.zeros((6, n)) + + mock_solve.side_effect = solver_side_effect + + system = self._build_model(touchdown=True, system_type="pst-") + _ = system.unknown_constants + + mock_solve.assert_called_once() + _, kwargs = mock_solve.call_args + self.assertEqual(kwargs["touchdown_distance"], 1500.0) + self.assertEqual(kwargs["touchdown_mode"], "C_in_contact") + self.assertEqual(kwargs["collapsed_weak_layer_kR"], 7.5) + + @patch("weac.core.system_model.UnknownConstantsSolver.solve_for_unknown_constants") + def test_unknown_constants_without_touchdown_passes_none(self, mock_solve): + """Test that unknown constants without touchdown passes None.""" + + def solver_side_effect( + scenario, + eigensystem, # pylint: disable=unused-argument + system_type, # pylint: disable=unused-argument + touchdown_distance, + touchdown_mode, + collapsed_weak_layer_kR, + ): + n = len(scenario.segments) + self.assertIsNone(touchdown_distance) + self.assertIsNone(touchdown_mode) + self.assertIsNone(collapsed_weak_layer_kR) + return np.zeros((6, n)) + + mock_solve.side_effect = solver_side_effect + + system = self._build_model(touchdown=False, system_type="skiers") + _ = system.unknown_constants + mock_solve.assert_called_once() + + @patch("weac.core.system_model.UnknownConstantsSolver.solve_for_unknown_constants") + def test_uncracked_unknown_constants_sets_all_foundation(self, mock_solve): + """Test that uncracked_unknown_constants sets all foundation.""" + captured_scenarios = [] + + def solver_side_effect( + scenario, + eigensystem, # pylint: disable=unused-argument + system_type, # pylint: disable=unused-argument + touchdown_distance, # pylint: disable=unused-argument + touchdown_mode, # pylint: disable=unused-argument + collapsed_weak_layer_kR, # pylint: disable=unused-argument + ): + captured_scenarios.append(scenario) + n = len(scenario.segments) + return np.zeros((6, n)) + + mock_solve.side_effect = solver_side_effect + + system = self._build_model(touchdown=False, system_type="skiers") + _ = system.uncracked_unknown_constants + + self.assertGreater(len(captured_scenarios), 0) + self.assertTrue( + all(seg.has_foundation for seg in captured_scenarios[-1].segments) + ) + + @patch("weac.core.system_model.SlabTouchdown") + @patch("weac.core.system_model.UnknownConstantsSolver.solve_for_unknown_constants") + def test_update_scenario_invalidates_touchdown_and_constants( + self, mock_solve, mock_td + ): + """Test that update_scenario invalidates touchdown and constants.""" + mock_inst = MagicMock() + mock_inst.touchdown_distance = 1800.0 + mock_inst.touchdown_mode = "B_point_contact" + mock_inst.collapsed_weak_layer_kR = 3.14 + mock_td.return_value = mock_inst + + def solver_side_effect( + scenario, + eigensystem, # pylint: disable=unused-argument + system_type, # pylint: disable=unused-argument + touchdown_distance, # pylint: disable=unused-argument + touchdown_mode, # pylint: disable=unused-argument + collapsed_weak_layer_kR, # pylint: disable=unused-argument + ): + n = len(scenario.segments) + return np.zeros((6, n)) + + mock_solve.side_effect = solver_side_effect + + system = self._build_model(touchdown=True, system_type="pst-") + _ = system.slab_touchdown + first_td_calls = mock_td.call_count + _ = system.unknown_constants + + # Update scenario (e.g., change phi) + new_cfg = system.scenario.scenario_config + new_cfg.phi = 20.0 + system.update_scenario(scenario_config=new_cfg) + + # Access again to trigger recompute + _ = system.slab_touchdown + _ = system.unknown_constants + + self.assertGreater(mock_td.call_count, first_td_calls) + self.assertGreaterEqual(mock_solve.call_count, 2) + + @patch("weac.core.system_model.UnknownConstantsSolver.solve_for_unknown_constants") + def test_toggle_touchdown_switches_solver_arguments(self, mock_solve): + """Test that toggle_touchdown switches the solver arguments.""" + calls = [] + + def solver_side_effect( + scenario, + eigensystem, # pylint: disable=unused-argument + system_type, # pylint: disable=unused-argument + touchdown_distance, # pylint: disable=unused-argument + touchdown_mode, # pylint: disable=unused-argument + collapsed_weak_layer_kR, # pylint: disable=unused-argument + ): + calls.append((touchdown_distance, touchdown_mode, collapsed_weak_layer_kR)) + n = len(scenario.segments) + return np.zeros((6, n)) + + mock_solve.side_effect = solver_side_effect + + system = self._build_model(touchdown=False, system_type="skiers") + _ = system.unknown_constants # first call without TD + + with patch("weac.core.system_model.SlabTouchdown") as mock_td: + mock_inst = MagicMock() + mock_inst.touchdown_distance = 900.0 + mock_inst.touchdown_mode = "A_free_hanging" + mock_inst.collapsed_weak_layer_kR = None + mock_td.return_value = mock_inst + + system.toggle_touchdown(True) + _ = system.unknown_constants # second call with TD + + self.assertEqual(len(calls), 2) + # First without touchdown + self.assertEqual(calls[0], (None, None, None)) + # Second with touchdown + self.assertEqual(calls[1], (900.0, "A_free_hanging", None)) + + def test_z_function_scalar_and_array(self): + """Test the z function with scalar and array inputs.""" + system = self._build_model(touchdown=False, system_type="skiers") + + # Patch eigensystem methods on the instance to simple deterministic outputs + I6 = np.eye(6) + + def fake_zh(x, length, has_foundation): # pylint: disable=unused-argument + return 2.0 * I6 + + def fake_zp(x, phi, has_foundation, qs): # pylint: disable=unused-argument + return np.ones((6, 1)) + + with ( + patch.object(system.eigensystem, "zh", side_effect=fake_zh), + patch.object(system.eigensystem, "zp", side_effect=fake_zp), + ): + C = np.eye(6) + # Scalar x + z_scalar = system.z( + x=100.0, C=C, length=1000.0, phi=10.0, has_foundation=True, qs=0.0 + ) + self.assertEqual(z_scalar.shape, (6, 6)) + expected = 2.0 * I6 + np.ones((6, 1)) @ np.ones( + (1, 6) + ) # Broadcast to (6, 6) + np.testing.assert_allclose(z_scalar, expected) + # Array x of length 3 -> concatenation along axis=1 + x = np.array([0.0, 50.0, 100.0]) + z_array = system.z( + x=x, + C=C, + length=1000.0, + phi=10.0, + has_foundation=True, + qs=0.0, + ) + expected_cols = z_scalar.shape[1] * len(x) + self.assertEqual(z_array.shape, (6, expected_cols)) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/run_tests.py b/tests/run_tests.py old mode 100755 new mode 100644 index a90e4d0..786dcfb --- a/tests/run_tests.py +++ b/tests/run_tests.py @@ -6,279 +6,61 @@ Provides a pytest-like output with detailed reporting. """ -import io import os import sys -import time import unittest -from collections import defaultdict -from contextlib import redirect_stderr, redirect_stdout +from weac.logging_config import setup_logging # noqa: E402 -class PytestLikeTextTestResult(unittest.TextTestResult): - """A test result class that provides pytest-like output format.""" - - PASS = "\033[92m" # Green - FAIL = "\033[91m" # Red - SKIP = "\033[93m" # Yellow - END = "\033[0m" # Reset color - BOLD = "\033[1m" # Bold text - - def __init__(self, stream, descriptions, verbosity): - """Initialize the test result object.""" - # Override descriptions to prevent unittest from printing the test docstring - super().__init__(stream, False, verbosity) - self.stream = stream - self.verbosity = verbosity - self.descriptions = ( - False # Override to prevent unittest from printing docstrings - ) - self.successes = [] - self.start_time = time.time() - self.test_times: dict[str, float] = {} - self.module_counts: dict[str, dict[str, int]] = defaultdict( - lambda: defaultdict(int) - ) - self.total_tests = 0 - self.test_counter = 0 - self.test_start_time = 0.0 - - # Print header - self.stream.write( - f"\n{self.BOLD}============================== test session starts =============================={self.END}\n" - ) - self.stream.write(f"platform: {sys.platform}, Python {sys.version.split()[0]}\n") - self.stream.write( - f"rootdir: {os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))}\n" - ) - self.stream.flush() - - def getDescription(self, test): - """Override to return an empty description, preventing unittest from printing the docstring.""" - return "" - - def set_total_tests(self, count): - """Set the total number of tests to be run.""" - self.total_tests = count - - def startTest(self, test): - """Called when a test starts.""" - super().startTest(test) - self.test_start_time = time.time() - self.test_counter += 1 - - if self.verbosity > 1: - # Extract test name and module in a cleaner format - test_id = test.id() - module_name, class_name, test_name = test_id.split(".")[-3:] - - # Get test description - doc = test.shortDescription() or "" - - # Print the test name with progress indicator and description - progress = f"[ {self.test_counter}/{self.total_tests} ]" - self.stream.write(f"\n{progress} {module_name}.{class_name}.{test_name}\n") - if doc: - self.stream.write(f" {doc}\n") - - # Indentation for the result - self.stream.write(" ") - self.stream.flush() - - def _get_module_name(self, test): - """Extract module name from test.""" - return test.__class__.__module__.split(".")[-1] - - def addSuccess(self, test): - """Called when a test succeeds.""" - super().addSuccess(test) - self.successes.append(test) - self.test_times[test.id()] = time.time() - self.test_start_time - module_name = self._get_module_name(test) - self.module_counts[module_name]["passed"] += 1 - - if self.verbosity > 1: - self.stream.write(f" {self.PASS}βœ“ PASS{self.END}\n") - self.stream.flush() - - def addError(self, test, err): - """Called when a test raises an error.""" - super().addError(test, err) - self.test_times[test.id()] = time.time() - self.test_start_time - module_name = self._get_module_name(test) - self.module_counts[module_name]["errors"] += 1 - - if self.verbosity > 1: - self.stream.write(f" {self.FAIL}E ERROR{self.END}\n") - self.stream.flush() - - def addFailure(self, test, err): - """Called when a test fails.""" - super().addFailure(test, err) - self.test_times[test.id()] = time.time() - self.test_start_time - module_name = self._get_module_name(test) - self.module_counts[module_name]["failures"] += 1 - - if self.verbosity > 1: - self.stream.write(f" {self.FAIL}βœ— FAIL{self.END}\n") - self.stream.flush() - - def addSkip(self, test, reason): - """Called when a test is skipped.""" - super().addSkip(test, reason) - self.test_times[test.id()] = time.time() - self.test_start_time - module_name = self._get_module_name(test) - self.module_counts[module_name]["skipped"] += 1 - - if self.verbosity > 1: - self.stream.write(f" {self.SKIP}s SKIP{self.END} [{reason}]\n") - self.stream.flush() - - def printErrors(self): - """Print a formatted report of errors and failures.""" - if self.errors or self.failures: - self.stream.write( - f"\n{self.BOLD}============================== FAILURES =============================={self.END}\n" - ) - - for test, err in self.errors + self.failures: - test_id = test.id() - module_name, class_name, test_name = test_id.split(".")[-3:] - self.stream.write( - f"\n{self.BOLD}{self.FAIL}FAILED{self.END} {module_name}.{class_name}.{test_name}{self.END}\n" - ) - self.stream.write(f"{err}\n") - - def printTotal(self): - """Print a summary of all tests run.""" - total_time = time.time() - self.start_time - total_tests = self.testsRun - passed = len(self.successes) - failures = len(self.failures) - errors = len(self.errors) - skipped = len(self.skipped) - - # Print per-module summary - self.stream.write( - f"\n{self.BOLD}============================== test summary info =============================={self.END}\n" - ) - - for module, counts in sorted(self.module_counts.items()): - result_str = [] - if counts["passed"]: - result_str.append(f"{self.PASS}{counts['passed']} passed{self.END}") - if counts["failures"]: - result_str.append(f"{self.FAIL}{counts['failures']} failed{self.END}") - if counts["errors"]: - result_str.append(f"{self.FAIL}{counts['errors']} errors{self.END}") - if counts["skipped"]: - result_str.append(f"{self.SKIP}{counts['skipped']} skipped{self.END}") - - self.stream.write(f"{module}: {', '.join(result_str)}\n") - - # Print overall summary - self.stream.write( - f"\n{self.BOLD}============================== {total_tests} tests ran in {total_time:.2f}s =============================={self.END}\n" - ) - - result_parts = [] - if passed: - result_parts.append(f"{self.PASS}{passed} passed{self.END}") - if failures: - result_parts.append(f"{self.FAIL}{failures} failed{self.END}") - if errors: - result_parts.append(f"{self.FAIL}{errors} errors{self.END}") - if skipped: - result_parts.append(f"{self.SKIP}{skipped} skipped{self.END}") - - self.stream.write(", ".join(result_parts) + "\n") - - -class PytestLikeTextTestRunner(unittest.TextTestRunner): - """A test runner that uses PytestLikeTextTestResult to display results.""" - - def __init__( - self, - stream=None, - descriptions=False, # Override to prevent unittest from printing docstrings - verbosity=1, - failfast=False, - buffer=False, - warnings=None, - ): - """Initialize the runner.""" - super().__init__(stream, descriptions, verbosity, failfast, buffer, warnings) - - def _makeResult(self): - """Create and return a test result object that will be used to store results.""" - return PytestLikeTextTestResult(self.stream, self.descriptions, self.verbosity) - - def run(self, test): - """Run the given test case or test suite.""" - result = self._makeResult() - result.set_total_tests(self._count_tests(test)) - - self.stream.write(f"collecting ... {result.total_tests} items collected\n") - - # Run tests - startTestRun = getattr(result, "startTestRun", None) - if startTestRun is not None: - startTestRun() - try: - test(result) - finally: - stopTestRun = getattr(result, "stopTestRun", None) - if stopTestRun is not None: - stopTestRun() - - result.printErrors() - result.printTotal() - return result - - def get_runner_name(self) -> str: - """Return a human-readable name for this runner.""" - return self.__class__.__name__ - - def _count_tests(self, test): - """Count the total number of tests in a test suite.""" - if isinstance(test, unittest.TestSuite): - return sum(self._count_tests(t) for t in test) - return 1 - - -class CustomTextTestRunner(unittest.TextTestRunner): - """Hide default unittest output since we're using our custom runner.""" - - def run(self, test): - """Run the test suite with no output.""" - result = super().run(test) - return result - - def get_runner_name(self) -> str: - """Return a human-readable name for this runner.""" - return self.__class__.__name__ +setup_logging(level="WARNING") +current_dir = os.path.dirname(os.path.abspath(__file__)) +parent_dir = os.path.dirname(current_dir) def run_tests(): - """Discover and run all tests in the tests directory.""" - f = io.StringIO() - + """Discover and run all tests in the tests directory and subdirectories.""" # Get the directory containing this script test_dir = os.path.dirname(os.path.abspath(__file__)) - # Create a test runner with pytest-like output - test_runner = PytestLikeTextTestRunner(verbosity=2) + print(f"Discovering tests in: {test_dir}") + print("Looking for test files matching pattern: test_*.py") + print("Searching recursively in subdirectories...") + print("-" * 60) + + # Discover all tests in the tests directory (recursive by default) + test_suite = unittest.defaultTestLoader.discover( + test_dir, pattern="test_*.py", top_level_dir=parent_dir + ) - # Discover all tests in the tests directory - with redirect_stdout(f), redirect_stderr(f): - test_suite = unittest.defaultTestLoader.discover(test_dir) + # Count and display discovered tests + test_count = test_suite.countTestCases() + print(f"Found {test_count} test cases") + print("-" * 60) - # Run the tests with our custom output + # Create a test runner + test_runner = unittest.TextTestRunner(verbosity=2) + + # Run the tests result = test_runner.run(test_suite) - # Return appropriate exit code - return 0 if result.wasSuccessful() else 1 + # Print summary + print("\n" + "=" * 60) + print(f"Tests run: {result.testsRun}") + print(f"Failures: {len(result.failures)}") + print(f"Errors: {len(result.errors)}") + if result.testsRun > 0: + success_rate = ( + (result.testsRun - len(result.failures) - len(result.errors)) + / result.testsRun + * 100 + ) + print(f"Success rate: {success_rate:.1f}%") + else: + print("No tests were run") + + return result if __name__ == "__main__": - sys.exit(run_tests()) + unittest_result = run_tests() + sys.exit(0 if unittest_result.wasSuccessful() else 1) diff --git a/tests/test_comparison_results.py b/tests/test_comparison_results.py new file mode 100644 index 0000000..dde1b51 --- /dev/null +++ b/tests/test_comparison_results.py @@ -0,0 +1,557 @@ +""" +This module contains tests that compare the results of the old and new WEAC implementations. +""" + +import unittest + +import numpy as np + +from weac.analysis.analyzer import Analyzer +from weac.components import ( + Layer, + ModelInput, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.components.config import Config +from weac.core.system_model import SystemModel +from tests.utils.weac_reference_runner import ( # noqa: E402 + compute_reference_model_results, +) + + +class TestIntegrationOldVsNew(unittest.TestCase): + """Integration tests comparing old weac implementation with new weac implementation.""" + + def test_simple_two_layer_setup(self): + """ + Test that old and new implementations produce identical results + for a simple two-layer setup. + """ + # --- Setup for OLD implementation (published weac==2.6.X) --- + profile = [ + [200, 150], + [300, 100], + ] + inclination = 30.0 + total_length = 14000.0 + try: + _, old_state, old_z, old_analysis = compute_reference_model_results( + system="pst-", + layers_profile=profile, + touchdown=False, + L=total_length, + a=4000, + m=0, + phi=inclination, + ) + except RuntimeError as exc: + raise RuntimeError("Old weac environment unavailable") from exc + + # --- Setup for NEW implementation (main_weac2.py style) --- + # Equivalent setup in new system + layers = [ + Layer(rho=200, h=150), + Layer(rho=300, h=100), + ] + + segments = [ + Segment(length=10000, has_foundation=True, m=0), + Segment(length=4000, has_foundation=False, m=0), + ] + + scenario_config = ScenarioConfig( + phi=inclination, system_type="pst-", cut_length=4000 + ) + weak_layer = WeakLayer( + rho=50, h=30, E=0.25, G_Ic=1 + ) # Default weak layer properties + config = Config(touchdown=False) # Use default configuration + + model_input = ModelInput( + scenario_config=scenario_config, + weak_layer=weak_layer, + layers=layers, + segments=segments, + ) + + new_system = SystemModel(config=config, model_input=model_input) + new_constants = new_system.unknown_constants + + z1 = new_system.z( + x=[0, 5000, 10000], + C=new_constants[:, [0]], + length=10000, + phi=inclination, + has_foundation=True, + ) + z2 = new_system.z( + x=[0, 2000, 4000], + C=new_constants[:, [1]], + length=4000, + phi=inclination, + has_foundation=False, + ) + new_z = np.hstack([z1, z2]) + + # --- Analysis for NEW implementation --- + analyzer = Analyzer(new_system, printing_enabled=False) + new_raster_x, new_raster_z, new_raster_xb = analyzer.rasterize_solution(num=100) + new_z_mesh_dict = analyzer.get_zmesh(dz=2) + new_sxx = analyzer.Sxx(new_raster_z, inclination, dz=2, unit="kPa") + new_txz = analyzer.Txz(new_raster_z, inclination, dz=2, unit="kPa") + new_szz = analyzer.Szz(new_raster_z, inclination, dz=2, unit="kPa") + new_principal_stress_slab = analyzer.principal_stress_slab( + new_raster_z, inclination, dz=2, val="max", unit="kPa", normalize=False + ) + + # Compare the WeakLayer attributes + self.assertEqual( + old_state["weak"]["nu"], + new_system.weak_layer.nu, + "Weak layer Poisson's ratio should be the same", + ) + self.assertEqual( + old_state["weak"]["E"], + new_system.weak_layer.E, + "Weak layer Young's modulus should be the same", + ) + self.assertEqual( + old_state["t"], + new_system.weak_layer.h, + "Weak layer thickness should be the same", + ) + self.assertEqual( + old_state["kn"], + new_system.weak_layer.kn, + "Weak layer normal stiffness should be the same", + ) + self.assertEqual( + old_state["kt"], + new_system.weak_layer.kt, + "Weak layer shear stiffness should be the same", + ) + + # Compare the Slab properties + self.assertEqual( + old_state["h"], new_system.slab.H, "Slab thickness should be the same" + ) + self.assertEqual( + old_state["zs"], + new_system.slab.z_cog, + "Slab center of gravity should be the same", + ) + + # Compare the Layer properties + old_slab = ( + np.asarray(old_state["slab"]) if old_state["slab"] is not None else None + ) + self.assertIsNotNone(old_slab, "Old slab data should be available") + if old_slab is not None: + np.testing.assert_array_equal( + old_slab[:, 0] * 1e-12, + new_system.slab.rhoi, + "Layer density should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 1], + new_system.slab.hi, + "Layer thickness should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 2], + new_system.slab.Ei, + "Layer Young's modulus should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 3], + new_system.slab.Gi, + "Layer shear modulus should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 4], + new_system.slab.nui, + "Layer Poisson's ratio should be the same", + ) + + # Compare all the attributes of the old and new model + self.assertEqual( + old_state["a"], + new_system.scenario.cut_length, + "Cut length should be the same", + ) + + # Compare the z vectors + self.assertEqual(old_z.shape, new_z.shape, "Z-vector shapes should match") + np.testing.assert_allclose( + old_z, + new_z, + rtol=1e-10, + atol=1e-12, + err_msg="Old and new implementations should produce very similar z vectors", + ) + + # Compare analysis results + np.testing.assert_allclose( + old_analysis["raster_x"], + new_raster_x, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized x-coordinates should be very similar", + ) + np.testing.assert_allclose( + old_analysis["raster_z"], + new_raster_z, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized z-solutions should be very similar", + ) + # For raster_xb, we need to handle NaNs + np.testing.assert_allclose( + old_analysis["raster_xb"], + new_raster_xb, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized founded x-coordinates should be very similar", + equal_nan=True, + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 0], + new_z_mesh_dict["z"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 1], + new_z_mesh_dict["E"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 2], + new_z_mesh_dict["nu"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 3], + new_z_mesh_dict["rho"] * 1e12, + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["sxx"], + new_sxx, + rtol=1e-10, + atol=1e-12, + err_msg="Sxx stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["txz"], + new_txz, + rtol=1e-10, + atol=1e-12, + err_msg="Txz stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["szz"], + new_szz, + rtol=1e-10, + atol=1e-12, + err_msg="Szz stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["principal_stress_slab"], + new_principal_stress_slab, + rtol=1e-10, + atol=1e-12, + err_msg="Principal slab stress should be very similar", + ) + + def test_simple_two_layer_setup_with_touchdown(self): + """ + Test that old and new implementations produce identical results + for a simple two-layer setup with touchdown=True. + """ + # --- Setup for OLD implementation (published weac==2.6.X) --- + profile = [ + [200, 150], + [300, 100], + ] + inclination = 30.0 + total_length = 14000.0 + try: + _, old_state, old_z, old_analysis = compute_reference_model_results( + system="pst-", + layers_profile=profile, + touchdown=True, + L=total_length, + a=4000, + m=0, + phi=inclination, + set_foundation={"t": 20, "E": 0.35, "nu": 0.1}, + ) + except RuntimeError as exc: + raise RuntimeError("Old weac environment unavailable") from exc + + # --- Setup for NEW implementation (main_weac2.py style) --- + # Equivalent setup in new system + layers = [ + Layer(rho=200, h=150), + Layer(rho=300, h=100), + ] + + # For touchdown=True, the segmentation will be different + # Need to match the segments that would be created by calc_segments with touchdown=True + segments = [ + Segment(length=10000, has_foundation=True, m=0), + Segment(length=4000, has_foundation=False, m=0), + ] + + scenario_config = ScenarioConfig( + phi=inclination, system_type="pst-", cut_length=4000 + ) + weak_layer = WeakLayer( + rho=50, h=20, E=0.35, nu=0.1, G_Ic=1 + ) # Default weak layer properties + config = Config(touchdown=True) # Use default configuration + + model_input = ModelInput( + scenario_config=scenario_config, + weak_layer=weak_layer, + layers=layers, + segments=segments, + ) + + new_system = SystemModel(config=config, model_input=model_input) + new_constants = new_system.unknown_constants + + # Calculate z-vector for each segment using its actual length + z_parts = [] + for i, segment in enumerate(new_system.scenario.segments): + length = segment.length + x_coords = [0, length / 2, length] + z_segment = new_system.z( + x=x_coords, + C=new_constants[:, [i]], + length=length, + phi=inclination, + has_foundation=segment.has_foundation, + ) + z_parts.append(z_segment) + new_z = np.hstack(z_parts) + + # --- Analysis for NEW implementation --- + analyzer = Analyzer(new_system, printing_enabled=False) + new_raster_x, new_raster_z, new_raster_xb = analyzer.rasterize_solution(num=100) + new_z_mesh_dict = analyzer.get_zmesh(dz=2) + new_sxx = analyzer.Sxx(new_raster_z, inclination, dz=2, unit="kPa") + new_txz = analyzer.Txz(new_raster_z, inclination, dz=2, unit="kPa") + new_szz = analyzer.Szz(new_raster_z, inclination, dz=2, unit="kPa") + new_principal_stress_slab = analyzer.principal_stress_slab( + new_raster_z, inclination, dz=2, val="max", unit="kPa", normalize=False + ) + + # Compare the WeakLayer attributes + self.assertEqual( + old_state["weak"]["nu"], + new_system.weak_layer.nu, + "Weak layer Poisson's ratio should be the same", + ) + self.assertEqual( + old_state["weak"]["E"], + new_system.weak_layer.E, + "Weak layer Young's modulus should be the same", + ) + self.assertEqual( + old_state["t"], + new_system.weak_layer.h, + "Weak layer thickness should be the same", + ) + self.assertEqual( + old_state["kn"], + new_system.weak_layer.kn, + "Weak layer normal stiffness should be the same", + ) + self.assertEqual( + old_state["kt"], + new_system.weak_layer.kt, + "Weak layer shear stiffness should be the same", + ) + + # Compare the Slab Touchdown attributes + self.assertEqual( + old_state["touchdown"]["tc"], + new_system.scenario.crack_h, + "Crack height should be the same", + ) + self.assertEqual( + old_state["touchdown"]["a1"], + new_system.slab_touchdown.l_AB, + "Transition length A should be the same", + ) + self.assertEqual( + old_state["touchdown"]["a2"], + new_system.slab_touchdown.l_BC, + "Transition length B should be the same", + ) + self.assertEqual( + old_state["touchdown"]["td"], + new_system.slab_touchdown.touchdown_distance, + "Touchdown distance should be the same", + ) + + # Compare the Slab properties + self.assertEqual( + old_state["h"], new_system.slab.H, "Slab thickness should be the same" + ) + self.assertEqual( + old_state["zs"], + new_system.slab.z_cog, + "Slab center of gravity should be the same", + ) + + # Compare the Layer properties + old_slab = ( + np.asarray(old_state["slab"]) if old_state["slab"] is not None else None + ) + self.assertIsNotNone(old_slab, "Old slab data should be available") + if old_slab is not None: + np.testing.assert_array_equal( + old_slab[:, 0] * 1e-12, + new_system.slab.rhoi, + "Layer density should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 1], + new_system.slab.hi, + "Layer thickness should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 2], + new_system.slab.Ei, + "Layer Young's modulus should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 3], + new_system.slab.Gi, + "Layer shear modulus should be the same", + ) + np.testing.assert_array_equal( + old_slab[:, 4], + new_system.slab.nui, + "Layer Poisson's ratio should be the same", + ) + + # Compare all the attributes of the old and new model + self.assertEqual( + old_state["a"], + new_system.scenario.cut_length, + "Cut length should be the same", + ) + + # --- Compare results --- + self.assertEqual( + old_z.shape, + new_z.shape, + "Result arrays should have the same shape", + ) + + # Numerical differences lie in the absolute realm of e-12 + np.testing.assert_allclose( + old_z, + new_z, + rtol=1e-10, + atol=1e-12, + err_msg="Old and new implementations should produce very similar results", + ) + + # Compare analysis results + np.testing.assert_allclose( + old_analysis["raster_x"], + new_raster_x, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized x-coordinates should be very similar", + ) + np.testing.assert_allclose( + old_analysis["raster_z"], + new_raster_z, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized z-solutions should be very similar", + ) + # For raster_xb, we need to handle NaNs + np.testing.assert_allclose( + old_analysis["raster_xb"], + new_raster_xb, + rtol=1e-10, + atol=1e-12, + err_msg="Rasterized founded x-coordinates should be very similar", + equal_nan=True, + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 0], + new_z_mesh_dict["z"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 1], + new_z_mesh_dict["E"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 2], + new_z_mesh_dict["nu"], + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["z_mesh"][:, 3], + new_z_mesh_dict["rho"] * 1e12, + rtol=1e-10, + atol=1e-12, + err_msg="Z-mesh should be very similar", + ) + np.testing.assert_allclose( + old_analysis["sxx"], + new_sxx, + rtol=1e-10, + atol=1e-12, + err_msg="Sxx stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["txz"], + new_txz, + rtol=1e-10, + atol=1e-12, + err_msg="Txz stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["szz"], + new_szz, + rtol=1e-10, + atol=1e-12, + err_msg="Szz stress should be very similar", + ) + np.testing.assert_allclose( + old_analysis["principal_stress_slab"], + new_principal_stress_slab, + rtol=1e-10, + atol=1e-12, + err_msg="Principal slab stress should be very similar", + ) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_eigensystem.py b/tests/test_eigensystem.py deleted file mode 100644 index 930d0f8..0000000 --- a/tests/test_eigensystem.py +++ /dev/null @@ -1,467 +0,0 @@ -""" -Unit tests for the Eigensystem class in the WEAC package. -""" - -import unittest -from unittest import mock - -import numpy as np - -from weac.eigensystem import Eigensystem - - -class TestEigensystem(unittest.TestCase): - """Test cases for the Eigensystem class.""" - - def setUp(self): - """Set up test fixtures.""" - # Create an Eigensystem instance for testing - self.eigen = Eigensystem(system="pst-") - - # Set up properties needed for tests - self.eigen.set_beam_properties(layers="A") - self.eigen.set_foundation_properties() - - def test_initialization(self): - """Test that Eigensystem initializes with correct default values.""" - # Test default initialization - self.assertEqual(self.eigen.system, "pst-") - self.assertFalse(self.eigen.touchdown) - self.assertAlmostEqual(self.eigen.g, 9810.0) # Gravitational constant - - def test_all_system_types(self): - """Test initialization with all possible system types.""" - system_types = ["pst-", "-pst", "vpst-", "-vpst", "skier", "skiers"] - - for system in system_types: - with self.subTest(system=system): - eigen = Eigensystem(system=system) - self.assertEqual(eigen.system, system) - eigen.set_beam_properties(layers="A") - eigen.set_foundation_properties() - eigen.calc_fundamental_system() - - # Basic functionality checks - self.assertIsNotNone(eigen.kn) - self.assertIsNotNone(eigen.kt) - self.assertIsNotNone(eigen.A11) - self.assertIsNotNone(eigen.ewC) - self.assertIsNotNone(eigen.ewR) - - def test_system_type_eigenvalue_comparison(self): - """Test and compare eigenvalues between different system types.""" - # Define consistent properties for all systems - beam_props = [[300, 200]] - foundation_props = {"t": 30.0, "E": 0.25, "nu": 0.25} - - # Create eigensystems with different system types - systems = {} - for system_type in ["pst-", "-pst", "vpst-", "-vpst", "skier", "skiers"]: - eigen = Eigensystem(system=system_type) - eigen.set_beam_properties(beam_props) - eigen.set_foundation_properties(**foundation_props) - eigen.calc_fundamental_system() - systems[system_type] = eigen - - # Check that eigenvalues are produced for all systems - for system_type, eigen in systems.items(): - with self.subTest(system=system_type): - # Check that eigenvalues are calculated - self.assertIsNotNone(eigen.ewC) - self.assertIsNotNone(eigen.ewR) - - # Check that the number of eigenvalues is consistent with expectations - # For this beam on elastic foundation problem, we expect 2 complex eigenvalues - self.assertEqual( - len(eigen.ewC), - 2, - f"System {system_type} should have 2 complex eigenvalues", - ) - - # For PST-type systems, expect 2 real eigenvalues - if system_type in ["pst-", "-pst", "vpst-", "-vpst"]: - self.assertEqual( - len(eigen.ewR), - 2, - f"PST-type system {system_type} should have 2 real eigenvalues", - ) - - # Compare eigenvalues between different PST variants - # Corresponding eigenvalues may differ in sign but should have similar magnitudes - for i, _ in enumerate(systems["pst-"].ewC): - # Compare magnitudes of complex eigenvalues between PST variants - mag_pst_right = abs(systems["pst-"].ewC[i]) - mag_pst_left = abs(systems["-pst"].ewC[i]) - self.assertAlmostEqual( - mag_pst_right, - mag_pst_left, - places=2, - msg=f"Complex eigenvalue {i} should have similar magnitude in PST variants", - ) - - mag_vpst_right = abs(systems["vpst-"].ewC[i]) - mag_vpst_left = abs(systems["-vpst"].ewC[i]) - self.assertAlmostEqual( - mag_vpst_right, - mag_vpst_left, - places=2, - msg=f"Complex eigenvalue {i} should have similar magnitude in VPST variants", - ) - - def test_system_response_for_different_boundary_conditions(self): - """Test system response for different boundary conditions.""" - # Create test systems with different boundary conditions - systems = { - "pst-": Eigensystem(system="pst-"), - "skier": Eigensystem(system="skier"), - } - - # Set common properties - for system_type, eigen in systems.items(): - eigen.set_beam_properties(layers="A") - eigen.set_foundation_properties() - eigen.calc_fundamental_system() - - # Test coordinates for evaluation - x_values = np.linspace(0, 1000, 5) # 5 points from 0 to 1000 mm - - # Test constants for the solution - C = np.zeros((6, 1)) # Zero constants for simplicity - - # Set an incline angle - phi = 30 # degrees - - # Test that solutions can be computed for both systems - for system_type, eigen in systems.items(): - with self.subTest(system=system_type): - # Test bedded solution - z_bedded = eigen.z(x_values, C, 0, phi, bed=True) - - # Check solution dimensions - self.assertEqual(z_bedded.shape[0], 6) # 6 solution components - self.assertEqual( - z_bedded.shape[1], len(x_values) - ) # One column per x value - - # Test unbedded solution - z_unbedded = eigen.z(x_values, C, 0, phi, bed=False) - - # Check solution dimensions - self.assertEqual(z_unbedded.shape[0], 6) - self.assertEqual(z_unbedded.shape[1], len(x_values)) - - # Test that bedded and unbedded solutions are different - self.assertFalse(np.allclose(z_bedded, z_unbedded)) - - # Test with a single x value to cover line 656 - z_single = eigen.z(x_values[0], C, 0, phi, bed=True) - self.assertEqual(z_single.shape[0], 6) - self.assertEqual(z_single.shape[1], 1) - - # Test skier load - skier_system = systems["skier"] - skier_mass = 80 # kg - Fn, Ft = skier_system.get_skier_load(skier_mass, phi) - - # Check skier load values are reasonable - self.assertGreater(Fn, 0) - self.assertLess(Ft, 0) # Downslope component should be negative - - def test_set_beam_properties(self): - """Test setting beam properties with different layer configurations.""" - # Create a new instance to test from scratch - eigen = Eigensystem(system="pst-") - - # Test with a single layer - eigen.set_beam_properties(layers="A") - - # Check that slab property is set - self.assertIsNotNone(eigen.slab) - # The actual shape might be different from what we expected - # Let's just check that it's a 2D array with at least one row - self.assertGreaterEqual(eigen.slab.shape[0], 1) - - # Test with multiple layers - eigen.set_beam_properties( - [ - [200, 100], # [density (kg/m^3), thickness (mm)] - [300, 150], - [400, 50], - ] - ) - - # Check that slab property is updated - self.assertIsNotNone(eigen.slab) - # Check that we have the right number of layers - self.assertEqual(eigen.slab.shape[0], 3) - - def test_set_beam_properties_with_update(self): - """Test setting beam properties with update flag.""" - # Create a new instance - eigen = Eigensystem(system="pst-") - - # Set up a foundation to make calc_fundamental_system work - eigen.set_foundation_properties() - - # Test with update=True, which should trigger calc_fundamental_system - with mock.patch.object(eigen, "calc_fundamental_system") as mock_calc: - eigen.set_beam_properties([[300, 200]], update=True) - mock_calc.assert_called_once() - - @mock.patch("weac.eigensystem.load_dummy_profile") - def test_set_beam_properties_with_string(self, mock_load_profile): - """Test setting beam properties using a string input.""" - # Mock the load_dummy_profile function - mock_layers = np.array([[300, 200]]) - mock_E = np.array([10.0]) - mock_load_profile.return_value = (mock_layers, mock_E) - - # Create a new instance - eigen = Eigensystem(system="pst-") - - # Call set_beam_properties with a string - eigen.set_beam_properties(layers="B") - - # Verify the mock was called with the right parameter - mock_load_profile.assert_called_once_with("B") - - # Check that the properties were set correctly - self.assertIsNotNone(eigen.slab) - self.assertGreaterEqual(eigen.slab.shape[0], 1) - - def test_set_foundation_properties(self): - """Test setting foundation properties.""" - # Create a new instance to test from scratch - eigen = Eigensystem(system="pst-") - - # Test with default parameters - eigen.set_foundation_properties() - - # Check that weak layer properties are set - self.assertIsNotNone(eigen.weak) - self.assertIn("E", eigen.weak) - self.assertIn("nu", eigen.weak) - - # Test with custom parameters - eigen.set_foundation_properties( - t=50.0, # Weak layer thickness (mm) - E=0.5, # Young's modulus (MPa) - nu=0.3, # Poisson's ratio - ) - - # Check that weak layer properties are updated - self.assertIsNotNone(eigen.weak) - self.assertEqual(eigen.weak["E"], 0.5) - self.assertEqual(eigen.weak["nu"], 0.3) - self.assertEqual(eigen.t, 50.0) - - def test_set_foundation_properties_with_update(self): - """Test setting foundation properties with update flag.""" - # Create a new instance - eigen = Eigensystem(system="pst-") - - # Set beam properties to make calc_fundamental_system work - eigen.set_beam_properties(layers="A") - - # Test with update=True, which should trigger calc_fundamental_system - with mock.patch.object(eigen, "calc_fundamental_system") as mock_calc: - eigen.set_foundation_properties(update=True) - mock_calc.assert_called_once() - - def test_calc_fundamental_system(self): - """Test calculation of the fundamental system.""" - # Calculate the fundamental system - self.eigen.calc_fundamental_system() - - # Check that the system has been initialized - self.assertIsNotNone( - getattr(self.eigen, "kn", None) - ) # Foundation normal stiffness - self.assertIsNotNone( - getattr(self.eigen, "kt", None) - ) # Foundation shear stiffness - self.assertIsNotNone(getattr(self.eigen, "A11", None)) # Extensional stiffness - self.assertIsNotNone( - getattr(self.eigen, "B11", None) - ) # Bending-extension coupling stiffness - self.assertIsNotNone(getattr(self.eigen, "D11", None)) # Bending stiffness - self.assertIsNotNone(getattr(self.eigen, "kA55", None)) # Shear stiffness - - def test_set_surface_load(self): - """Test setting surface load.""" - # Create a new instance - eigen = Eigensystem() - - # Initial value should be 0 - self.assertEqual(eigen.p, 0) - - # Set a surface load - eigen.set_surface_load(100.0) - self.assertEqual(eigen.p, 100.0) - - def test_get_load_vector(self): - """Test getting the load vector.""" - # Initialize with beam and foundation properties - eigen = Eigensystem(system="pst-") - eigen.set_beam_properties(layers="A") - eigen.set_foundation_properties() - eigen.calc_fundamental_system() - - # Test the load vector calculation - phi = 30 # degrees - load_vector = eigen.get_load_vector(phi) - - # Check expected dimensions and structure - self.assertEqual(load_vector.shape, (6, 1)) - self.assertEqual(load_vector[0, 0], 0) # First component should be 0 - self.assertEqual(load_vector[2, 0], 0) # Third component should be 0 - self.assertEqual(load_vector[4, 0], 0) # Fifth component should be 0 - - # Test with surface load to ensure all branches are covered - eigen.set_surface_load(100.0) - load_vector_with_surface = eigen.get_load_vector(phi) - - # The resulting load vector should be different - self.assertFalse(np.array_equal(load_vector, load_vector_with_surface)) - - def test_pst_specific_behavior(self): - """Test PST (Propagation Saw Test) specific behavior.""" - # Test pst- (cut from right) - eigen_pst_right = Eigensystem(system="pst-") - eigen_pst_right.set_beam_properties(layers="A") - eigen_pst_right.set_foundation_properties() - eigen_pst_right.calc_fundamental_system() - - # Test -pst (cut from left) - eigen_pst_left = Eigensystem(system="-pst") - eigen_pst_left.set_beam_properties(layers="A") - eigen_pst_left.set_foundation_properties() - eigen_pst_left.calc_fundamental_system() - - # Both should have valid eigensystems but potentially different values - self.assertTrue(eigen_pst_right.ewC is not False) - self.assertTrue(eigen_pst_left.ewC is not False) - - def test_vpst_specific_behavior(self): - """Test vertical PST specific behavior.""" - # Test vpst- (vertical cut from right) - eigen_vpst_right = Eigensystem(system="vpst-") - eigen_vpst_right.set_beam_properties(layers="A") - eigen_vpst_right.set_foundation_properties() - eigen_vpst_right.calc_fundamental_system() - - # Test -vpst (vertical cut from left) - eigen_vpst_left = Eigensystem(system="-vpst") - eigen_vpst_left.set_beam_properties(layers="A") - eigen_vpst_left.set_foundation_properties() - eigen_vpst_left.calc_fundamental_system() - - # Both should have valid eigensystems - self.assertTrue(eigen_vpst_right.ewC is not False) - self.assertTrue(eigen_vpst_left.ewC is not False) - - def test_skier_specific_behavior(self): - """Test skier-specific behavior.""" - # Test single skier - eigen_skier = Eigensystem(system="skier") - eigen_skier.set_beam_properties(layers="A") - eigen_skier.set_foundation_properties() - eigen_skier.calc_fundamental_system() - - # Test skier load calculation - skier_mass = 80 # kg - slope_angle = 30 # degrees - Fn, Ft = eigen_skier.get_skier_load(skier_mass, slope_angle) - - # Check that load values are calculated and reasonable - self.assertGreater(Fn, 0) # Normal force should be positive - self.assertLess(Ft, 0) # Tangential force should be negative on a slope - - # Test multiple skiers - eigen_skiers = Eigensystem(system="skiers") - eigen_skiers.set_beam_properties(layers="A") - eigen_skiers.set_foundation_properties() - eigen_skiers.calc_fundamental_system() - - # Both should have valid eigensystems - self.assertTrue(eigen_skier.ewC is not False) - self.assertTrue(eigen_skiers.ewC is not False) - - def test_touchdown_parameter(self): - """Test the touchdown parameter behavior.""" - # Test with touchdown=True - eigen_touchdown = Eigensystem(system="pst-", touchdown=True) - self.assertTrue(eigen_touchdown.touchdown) - - # Test with touchdown=False (default) - eigen_no_touchdown = Eigensystem(system="pst-") - self.assertFalse(eigen_no_touchdown.touchdown) - - def test_touchdown_with_all_system_types(self): - """Test the touchdown flag behavior with all possible system types.""" - system_types = ["pst-", "-pst", "vpst-", "-vpst", "skier", "skiers"] - - # Test with touchdown=True for all system types - for system in system_types: - with self.subTest(system=system, touchdown=True): - eigen = Eigensystem(system=system, touchdown=True) - self.assertTrue(eigen.touchdown) - eigen.set_beam_properties(layers="A") - eigen.set_foundation_properties() - eigen.calc_fundamental_system() - - # Basic functionality checks - self.assertIsNotNone(eigen.kn) - self.assertIsNotNone(eigen.kt) - self.assertIsNotNone(eigen.A11) - self.assertIsNotNone(eigen.ewC) - self.assertIsNotNone(eigen.ewR) - - # Test with touchdown=False for all system types - for system in system_types: - with self.subTest(system=system, touchdown=False): - eigen = Eigensystem(system=system, touchdown=False) - self.assertFalse(eigen.touchdown) - eigen.set_beam_properties(layers="A") - eigen.set_foundation_properties() - eigen.calc_fundamental_system() - - # Basic functionality checks - self.assertIsNotNone(eigen.kn) - self.assertIsNotNone(eigen.kt) - self.assertIsNotNone(eigen.A11) - self.assertIsNotNone(eigen.ewC) - self.assertIsNotNone(eigen.ewR) - - def test_weight_and_surface_loads(self): - """Test the calculation of weight and surface loads.""" - eigen = Eigensystem() - eigen.set_beam_properties(layers="A") - - # Test weight load at different angles - # At 0 degrees (flat) - qn, qt = eigen.get_weight_load(0) - self.assertGreater(qn, 0) # Normal load is positive - self.assertAlmostEqual(qt, 0, places=5) # Tangential load is zero - - # At 30 degrees - qn, qt = eigen.get_weight_load(30) - self.assertGreater(qn, 0) # Normal load is positive - self.assertLess(qt, 0) # Tangential load is negative (downslope) - - # Set surface load - eigen.set_surface_load(100.0) - - # Test surface load at different angles - pn, pt = eigen.get_surface_load(0) - self.assertAlmostEqual(pn, 100.0) # Normal load equals input at 0 degrees - self.assertAlmostEqual(pt, 0, places=5) # Tangential load is zero - - # At 30 degrees - pn, pt = eigen.get_surface_load(30) - self.assertGreater(pn, 0) # Normal load is positive - self.assertLess(pt, 0) # Tangential load is negative (downslope) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/test_layered.py b/tests/test_layered.py deleted file mode 100644 index 919a476..0000000 --- a/tests/test_layered.py +++ /dev/null @@ -1,191 +0,0 @@ -""" -Unit tests for the Layered class in the WEAC package. -""" - -import unittest - -import numpy as np - -from weac.layered import Layered - - -class TestLayered(unittest.TestCase): - """Test cases for the Layered class.""" - - def setUp(self): - """Set up test fixtures.""" - # Create a default Layered instance for testing - self.layered = Layered(system="pst-") - - # Create a Layered instance with custom parameters - self.custom_layered = Layered( - system="skier", - layers=[[240, 200]], # [density (kg/m^3), thickness (mm)] - touchdown=True, - ) - - def test_initialization(self): - """Test that Layered initializes with correct default values.""" - # Test default initialization - self.assertEqual(self.layered.system, "pst-") - self.assertFalse(self.layered.touchdown) - - # Test custom initialization - self.assertEqual(self.custom_layered.system, "skier") - self.assertTrue(self.custom_layered.touchdown) - self.assertEqual(len(self.custom_layered.slab), 1) - self.assertAlmostEqual(self.custom_layered.slab[0, 0], 240.0) # Density - self.assertAlmostEqual(self.custom_layered.slab[0, 1], 200.0) # Thickness - - def test_calc_segments(self): - """Test calculation of segments for different systems.""" - # Test for PST cut from right - self.layered.system = "pst-" - segments = self.layered.calc_segments(L=1000, a=300) - - # Check that segments dictionary contains expected keys - self.assertIn("crack", segments) - self.assertIn("nocrack", segments) - self.assertIn("both", segments) - - # Check segment lengths for crack configuration - crack_segments = segments["crack"] - self.assertIn("li", crack_segments) - self.assertEqual(len(crack_segments["li"]), 2) # Two segments for PST- - self.assertAlmostEqual(crack_segments["li"][0], 700.0) # First segment length - self.assertAlmostEqual(crack_segments["li"][1], 300.0) # Second segment length - - # Test for skier system - self.layered.system = "skier" - segments = self.layered.calc_segments() - - # Check that segments dictionary contains expected keys - self.assertIn("crack", segments) - - # Check segment lengths for skier configuration - skier_segments = segments["crack"] - self.assertIn("li", skier_segments) - # Note: The actual implementation returns 4 segments for skier, not 2 - self.assertEqual(len(skier_segments["li"]), 4) # Four segments for skier - - # Test for multiple skiers - self.layered.system = "skiers" - segments = self.layered.calc_segments( - li=[500, 100, 250, 30, 30, 500], - ki=[True, True, True, False, False, True], - mi=[80, 80, 0, 0, 0], - ) - - # Check that segments dictionary contains expected keys - self.assertIn("crack", segments) - - # Check segment lengths for multiple skiers configuration - skiers_segments = segments["crack"] - self.assertIn("li", skiers_segments) - self.assertEqual(len(skiers_segments["li"]), 6) # Six segments as specified - self.assertAlmostEqual(skiers_segments["li"][0], 500.0) - self.assertAlmostEqual(skiers_segments["li"][1], 100.0) - self.assertAlmostEqual(skiers_segments["li"][2], 250.0) - self.assertAlmostEqual(skiers_segments["li"][3], 30.0) - self.assertAlmostEqual(skiers_segments["li"][4], 30.0) - self.assertAlmostEqual(skiers_segments["li"][5], 500.0) - - def test_assemble_and_solve(self): - """Test assembly and solution of the system.""" - # Set up a simple configuration - self.layered.set_beam_properties([[240, 200]]) - self.layered.set_foundation_properties() - self.layered.calc_fundamental_system() - - # Calculate segments - segments = self.layered.calc_segments(L=1000, a=300) - - # Assemble and solve the system - C = self.layered.assemble_and_solve(phi=0, **segments["crack"]) - - # Check that solution vector has correct shape - self.assertIsNotNone(C) - self.assertEqual(C.shape, (6, 2)) # 6 state variables, 2 segments - - # Test with non-zero slope angle - C_slope = self.layered.assemble_and_solve(phi=30, **segments["crack"]) - self.assertIsNotNone(C_slope) - self.assertEqual(C_slope.shape, (6, 2)) - - def test_rasterize_solution(self): - """Test rasterization of the solution.""" - # Set up a simple configuration - self.layered.set_beam_properties([[240, 200]]) - self.layered.set_foundation_properties() - self.layered.calc_fundamental_system() - - # Calculate segments - segments = self.layered.calc_segments(L=1000, a=300) - - # Assemble and solve the system - C = self.layered.assemble_and_solve(phi=0, **segments["crack"]) - - # Rasterize the solution - xsl, z, xwl = self.layered.rasterize_solution(C=C, phi=0, **segments["crack"]) - - # Check that output arrays have correct shapes - self.assertIsNotNone(xsl) - self.assertIsNotNone(z) - self.assertIsNotNone(xwl) - self.assertEqual(z.shape[0], 6) # 6 state variables - self.assertEqual(xsl.shape, z.shape[1:]) # Same length as state variables - - # Check that x coordinates are within expected range - self.assertGreaterEqual(np.min(xsl), 0) - self.assertLessEqual(np.max(xsl), 1000) - - def test_gdif(self): - """Test calculation of differential energy release rate.""" - # Set up a simple configuration - self.layered.set_beam_properties([[240, 200]]) - self.layered.set_foundation_properties() - self.layered.calc_fundamental_system() - - # Calculate segments - segments = self.layered.calc_segments(L=1000, a=300) - - # Assemble and solve the system - C = self.layered.assemble_and_solve(phi=0, **segments["crack"]) - - # Calculate differential energy release rate - G = self.layered.gdif(C, phi=0, **segments["crack"]) - - # Check that energy release rate is non-negative - self.assertIsNotNone(G) - self.assertEqual(len(G), 3) # Three components: mode I, mode II, and total - self.assertGreaterEqual( - G[2], 0 - ) # Total energy release rate should be non-negative - - def test_ginc(self): - """Test calculation of incremental energy release rate.""" - # Set up a simple configuration - self.layered.set_beam_properties([[240, 200]]) - self.layered.set_foundation_properties() - self.layered.calc_fundamental_system() - - # Calculate segments for both configurations - segments = self.layered.calc_segments(L=1000, a=300) - - # Assemble and solve the system for both configurations - C0 = self.layered.assemble_and_solve(phi=0, **segments["nocrack"]) - C1 = self.layered.assemble_and_solve(phi=0, **segments["crack"]) - - # Calculate incremental energy release rate - G = self.layered.ginc(C0, C1, phi=0, **segments["both"]) - - # Check that energy release rate is non-negative - self.assertIsNotNone(G) - self.assertEqual(len(G), 3) # Three components: mode I, mode II, and total - self.assertGreaterEqual( - G[2], 0 - ) # Total energy release rate should be non-negative - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/test_mixins.py b/tests/test_mixins.py deleted file mode 100644 index c27c5e4..0000000 --- a/tests/test_mixins.py +++ /dev/null @@ -1,184 +0,0 @@ -""" -Unit tests for the mixins module in the WEAC package. -""" - -import unittest - -import numpy as np - -from weac.eigensystem import Eigensystem -from weac.mixins import FieldQuantitiesMixin, SlabContactMixin, SolutionMixin - - -class TestClass(FieldQuantitiesMixin, SolutionMixin, SlabContactMixin, Eigensystem): - """Test class for mixin testing.""" - - def __init__(self): - """Initialize test class.""" - # Initialize parent class - super().__init__(system="pst-", touchdown=False) - - # Create a 2D array for Z where the first index is the state variable - # and the second index is the position - self.Z = np.zeros((6, 5)) # 6 state variables, 5 positions - for i in range(6): - self.Z[i, :] = i + 1 # Each row has values [1,1,1,1,1], [2,2,2,2,2], etc. - - # Set required attributes for the mixins - self.h = 200 # slab thickness in mm - self.td = 0 # touchdown length - self.t = 1 # weak layer thickness - self.A11 = 1e6 # axial stiffness - self.B11 = 1e4 # coupling stiffness - self.D11 = 1e2 # bending stiffness - self.kA55 = 1e5 # shear stiffness - self.kn = 1e3 # normal foundation stiffness - self.kt = 1e3 # tangential foundation stiffness - self.system = "pst-" # system type - self.touchdown = False # touchdown flag - self.g = 9810 # gravity constant - self.mode = "A" # touchdown mode - - # Create slab properties array with columns: - # density (kg/m^3), thickness (mm), Young's modulus (MPa), shear modulus (MPa), Poisson's ratio - self.slab = np.array([[300, 200, 1e3, 4e2, 0.25]]) - - self.p = 0 # surface line load - self.phi = 0 # inclination angle - - self.z_coord = np.array([0.0, 1.0]) - - def test_w(self): - """Test calculation of deflection.""" - # Test with default parameters - result = self.w(self.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 3)) # Third row of Z - - # Test with different units - result_mm = self.w(self.Z, unit="mm") - result_cm = self.w(self.Z, unit="cm") - self.assertTrue(np.allclose(result_mm, result_cm * 10)) - - def test_dw_dx(self): - """Test calculation of deflection derivative.""" - # Test with default parameters - result = self.dw_dx(self.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 4)) # Fourth row of Z - - def test_psi(self): - """Test calculation of rotation.""" - # Test with default parameters - result = self.psi(self.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 5)) # Fifth row of Z - - # Test with different units - result_rad = self.psi(self.Z, unit="rad") - result_deg = self.psi(self.Z, unit="degrees") - self.assertTrue(np.allclose(result_rad, np.deg2rad(result_deg))) - - def test_calc_segments(self): - """Test calculation of segments.""" - # Test with default parameters - crack_segments = self.calc_segments(L=1000, a=300) - - # Check that the segments dictionary contains expected keys - self.assertIn("crack", crack_segments) - self.assertIn("li", crack_segments["crack"]) - self.assertIn("ki", crack_segments["crack"]) - self.assertIn("mi", crack_segments["crack"]) - - # Check segment lengths - self.assertEqual( - len(crack_segments["crack"]["li"]), 2 - ) # Should have 2 segments for pst- - self.assertEqual(crack_segments["crack"]["li"][0], 700) # First segment length - self.assertEqual( - crack_segments["crack"]["li"][1], 300 - ) # Second segment length (crack length) - - def test_energy_release_rate_ratio(self): - """Test calculation of energy release rate ratio.""" - # Test with default parameters - result = self.layered.energy_release_rate_ratio(self.stress, self.stress_slope) - self.assertIsInstance(result, float) - self.assertTrue(np.allclose(result, self.expected_ratio)) - - -class TestFieldQuantitiesMixin(unittest.TestCase): - """Test cases for FieldQuantitiesMixin.""" - - def setUp(self): - """Set up test fixtures.""" - self.test_obj = TestClass() - - def test_w(self): - """Test calculation of deflection.""" - # Test with default parameters - result = self.test_obj.w(self.test_obj.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 3)) # Third row of Z - - # Test with different units - result_mm = self.test_obj.w(self.test_obj.Z, unit="mm") - result_cm = self.test_obj.w(self.test_obj.Z, unit="cm") - self.assertTrue(np.allclose(result_mm, result_cm * 10)) - - def test_dw_dx(self): - """Test calculation of deflection derivative.""" - # Test with default parameters - result = self.test_obj.dw_dx(self.test_obj.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 4)) # Fourth row of Z - - def test_psi(self): - """Test calculation of rotation.""" - # Test with default parameters - result = self.test_obj.psi(self.test_obj.Z) - self.assertIsInstance(result, np.ndarray) - self.assertEqual(result.shape, (5,)) # Should match number of positions - self.assertTrue(np.allclose(result, 5)) # Fifth row of Z - - # Test with different units - result_rad = self.test_obj.psi(self.test_obj.Z, unit="rad") - result_deg = self.test_obj.psi(self.test_obj.Z, unit="degrees") - self.assertTrue(np.allclose(result_rad, np.deg2rad(result_deg))) - - -class TestSolutionMixin(unittest.TestCase): - """Test cases for SolutionMixin.""" - - def setUp(self): - """Set up test fixtures.""" - self.test_obj = TestClass() - - def test_calc_segments(self): - """Test calculation of segments.""" - # Test with default parameters - crack_segments = self.test_obj.calc_segments(L=1000, a=300) - - # Check that the segments dictionary contains expected keys - self.assertIn("crack", crack_segments) - self.assertIn("li", crack_segments["crack"]) - self.assertIn("ki", crack_segments["crack"]) - self.assertIn("mi", crack_segments["crack"]) - - # Check segment lengths - self.assertEqual( - len(crack_segments["crack"]["li"]), 2 - ) # Should have 2 segments for pst- - self.assertEqual(crack_segments["crack"]["li"][0], 700) # First segment length - self.assertEqual( - crack_segments["crack"]["li"][1], 300 - ) # Second segment length (crack length) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/test_plot.py b/tests/test_plot.py deleted file mode 100644 index fa1992c..0000000 --- a/tests/test_plot.py +++ /dev/null @@ -1,124 +0,0 @@ -""" -Unit tests for the plot module in the WEAC package. -""" - -import os -import unittest - -import matplotlib.pyplot as plt -import numpy as np - -import weac.plot -from weac.layered import Layered - - -class TestPlot(unittest.TestCase): - """Test cases for visualization functions in the plot module.""" - - def setUp(self): - """Set up test fixtures.""" - # Create a Layered instance for testing - self.layered = Layered(system="pst-") - self.layered.set_beam_properties( - [[300, 200]] - ) # [density (kg/m^3), thickness (mm)] - self.layered.set_foundation_properties() - self.layered.calc_fundamental_system() - - # Calculate segments - self.segments = self.layered.calc_segments(L=1000, a=300) - - # Assemble and solve the system - self.C = self.layered.assemble_and_solve(phi=0, **self.segments["crack"]) - - # Rasterize the solution - self.xsl, self.z, self.xwl = self.layered.rasterize_solution( - C=self.C, phi=0, **self.segments["crack"] - ) - - # Create plots directory if it doesn't exist - if not os.path.exists("plots"): - os.makedirs("plots") - - self.compliance = np.array([[1.0, 0.0], [0.0, 1.0]]) - - def tearDown(self): - """Clean up after tests.""" - # Close all matplotlib figures to avoid memory leaks - plt.close("all") - - # Clean up plot files - plot_files = [ - "plots/profile.png", - "plots/cont.png", - "plots/disp.png", - "plots/stress.png", - ] - for file in plot_files: - if os.path.exists(file): - os.remove(file) - - def test_slab_profile(self): - """Test plotting of slab profile.""" - # Test with default parameters - weac.plot.slab_profile(self.layered) - - # Check that the plot file was created - self.assertTrue(os.path.exists("plots/profile.png")) - - def test_deformed(self): - """Test plotting of deformed slab.""" - # Test with default parameters - weac.plot.deformed(self.layered, xsl=self.xsl, xwl=self.xwl, z=self.z, phi=0) - - # Check that the plot file was created - self.assertTrue(os.path.exists("plots/cont.png")) - - # Test with custom parameters - weac.plot.deformed( - self.layered, - xsl=self.xsl, - xwl=self.xwl, - z=self.z, - phi=0, - scale=2.0, - field="w", - normalize=False, - ) - - # Check that the plot file was created - self.assertTrue(os.path.exists("plots/cont.png")) - - def test_displacements(self): - """Test plotting of displacements.""" - # Test with default parameters - weac.plot.displacements( - self.layered, - x=self.xsl, - z=self.z, - li=self.segments["crack"]["li"], - ki=self.segments["crack"]["ki"], - mi=self.segments["crack"]["mi"], # Add mi parameter - ) - - # Check that the plot file was created - self.assertTrue(os.path.exists("plots/disp.png")) - - def test_stresses(self): - """Test plotting of stresses.""" - # Test with default parameters - weac.plot.stresses( - self.layered, - x=self.xwl, - z=self.z, - li=self.segments["crack"]["li"], - ki=self.segments["crack"]["ki"], - mi=self.segments["crack"]["mi"], # Add mi parameter - ) - - # Check that the plot file was created - self.assertTrue(os.path.exists("plots/stress.png")) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/test_regression_simulation.py b/tests/test_regression_simulation.py new file mode 100644 index 0000000..411afb3 --- /dev/null +++ b/tests/test_regression_simulation.py @@ -0,0 +1,450 @@ +""" +This module contains regression tests for the WEAC model. +""" + +import unittest + +import numpy as np + +from weac.analysis import CriteriaEvaluator +from weac.components import ( + Config, + CriteriaConfig, + Layer, + ModelInput, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.core.system_model import SystemModel + +GT_skier_baseline = np.array( + [ + [ + -1.3311587133616033e-03, + -1.3311587133987555e-03, + -1.4922878538805329e-02, + -1.4922878538805305e-02, + -1.3316416781406679e-03, + -1.3311587133616033e-03, + ], + [ + -1.3400532113402682e-27, + -1.9609062333698352e-16, + -8.8088543943750638e-05, + 1.8243392275606253e-05, + 2.5491108889889770e-09, + 1.3113971286963517e-13, + ], + [ + 1.2028124616334202e-03, + 1.2028124616361854e-03, + 4.2336109897242152e-02, + 4.2336109897242159e-02, + 1.2027765147493792e-03, + 1.2028124616334202e-03, + ], + [ + 4.4863892018696710e-28, + 1.4594950179586782e-17, + 9.0840725538762377e-04, + -1.0213155501342633e-03, + 1.8972934933226463e-10, + 4.3904509669894562e-14, + ], + [ + 1.0207865877058275e-05, + 1.0207865877358878e-05, + 2.0858241860062231e-04, + 2.0858241860062263e-04, + 1.0211773622223890e-05, + 1.0207865877058275e-05, + ], + [ + 9.3082770992463219e-30, + 1.5866005526363208e-18, + 5.7089479049104315e-06, + 1.4556704561361483e-06, + -2.0625263341890901e-11, + -9.1092262290486623e-16, + ], + ] +) + +GT_skiers_baseline = np.array( + [ + [ + -3.3364140411700502e-03, + -3.3371039610692352e-03, + -1.0211953916849679e-02, + -1.0211953916849772e-02, + -3.7930081429868277e-03, + -1.1362149028450508e-02, + -1.1362149028450560e-02, + -3.3383877478897019e-03, + -3.3364140411700502e-03, + ], + [ + -8.0289180784556896e-13, + -2.3962146278368322e-09, + -3.5438765390651617e-05, + 4.4357106916068844e-06, + 5.6324248362093287e-07, + -4.1293393719283317e-05, + 5.2268283766852303e-06, + 6.8550347830960343e-09, + 2.2968941139093848e-12, + ], + [ + 5.3656877671703247e-03, + 5.3657501774765836e-03, + 4.0999377862256728e-02, + 4.0999377862256728e-02, + 5.3516089951323098e-03, + 4.6936976212589937e-02, + 4.6936976212589923e-02, + 5.3655092252078438e-03, + 5.3656877671703247e-03, + ], + [ + 2.1476913299692529e-13, + 2.1676209355807275e-10, + 3.2479067052872183e-04, + -3.9885538154198533e-04, + 1.4280212737807196e-07, + 3.7892379106187288e-04, + -4.6532993635395239e-04, + 6.2010795683549551e-10, + 6.1440651481267745e-13, + ], + [ + 1.0845857494374418e-05, + 1.0848064160073291e-05, + 9.1766771806106752e-05, + 9.1766771806106942e-05, + 1.2307527822099668e-05, + 1.0526725389866414e-04, + 1.0526725389866431e-04, + 1.0852170272287989e-05, + 1.0845857494374418e-05, + ], + [ + 1.1022164968036404e-15, + 7.6641418314537503e-12, + 3.3164846239000650e-06, + 1.7215055806097094e-06, + -1.7298852781935918e-09, + 3.8690662777605046e-06, + 2.0082573939217563e-06, + -2.1925402470511338e-11, + -3.1531951864791889e-15, + ], + ] +) + +GT_pst_without_touchdown = np.array( + [ + [ + -7.2487996383562396e-03, + -6.0196423568498235e-03, + 2.0773162839138180e00, + 2.0773162839138175e00, + 1.2130315043983948e01, + 1.3485989766738559e01, + ], + [ + -8.4703294725430034e-22, + 5.0708000603491068e-10, + 8.6973240373155250e-03, + 8.6973240373155267e-03, + 2.1039215467303948e-03, + 1.7347234759768071e-18, + ], + [ + 5.2190784110483475e-03, + 2.4392769285311888e-03, + 1.7127974554689163e00, + 1.7127974554689156e00, + 3.1178068254972919e02, + 8.2709909746257256e02, + ], + [ + -3.1911617258468120e-05, + -3.9755915991866683e-11, + 2.9311857533740264e-02, + 2.9311857533740261e-02, + 2.3604562295124668e-01, + 2.6458510067192831e-01, + ], + [ + 3.1911617258468134e-05, + 1.8113788874495151e-05, + -2.8287378556700056e-02, + -2.8287378556700049e-02, + -2.3553338346272659e-01, + -2.6458510067192831e-01, + ], + [ + 5.0398620458123951e-24, + -1.2082657686176822e-12, + -1.7819428769682468e-04, + -1.7819428769682468e-04, + -4.4063073869004441e-05, + 0.0000000000000000e00, + ], + ] +) + +GT_pst_with_touchdown = np.array( + [ + [ + -4.3146866755634006e-02, + -3.9757397730484006e-02, + -3.8870634125188548e-02, + -3.8870634125188416e-02, + -4.0032928708301152e-01, + 3.7738995266905739e00, + ], + [ + 4.2351647362715017e-22, + -5.3427584324835562e-07, + 1.8184245478981639e-04, + 1.8184245478981668e-04, + 2.0494571622815035e-04, + 4.7175299215212229e-03, + ], + [ + 4.4598339301043052e-02, + 2.8856853343279535e-02, + 4.5293934057096763e-01, + 4.5293934057096763e-01, + 4.2951344311263497e00, + 6.0998553744300381e01, + ], + [ + -7.1148137410428485e-05, + 2.2653209597744274e-08, + 2.7900680967986886e-03, + 2.7900680967986920e-03, + 5.8858696744321093e-04, + 8.5674005639022610e-02, + ], + [ + 7.1148137410428485e-05, + 1.8256141574911238e-05, + -2.5205172650368105e-03, + -2.5205172650368144e-03, + -8.3127562420141909e-04, + -8.6428933784300915e-02, + ], + [ + -6.6672444826954921e-24, + 1.5311948547352858e-10, + -7.3563675489538430e-06, + -7.3563675489538447e-06, + -5.9657474700133831e-06, + -9.4643267349888723e-05, + ], + ] +) + + +class TestRegressionSimulation(unittest.TestCase): + """Regression tests asserting stable outputs for key scenarios.""" + + def test_skier_baseline(self): + """Test the skier baseline.""" + layers = [Layer(rho=200, h=150)] + wl = WeakLayer(rho=150, h=10) + segs = [ + Segment(length=10000, has_foundation=True, m=80), + Segment(length=4000, has_foundation=True, m=0), + ] + sc = ScenarioConfig(phi=10.0, system_type="skier", cut_length=0) + mi = ModelInput(layers=layers, weak_layer=wl, segments=segs, scenario_config=sc) + sm = SystemModel(model_input=mi, config=Config(touchdown=False)) + C = sm.unknown_constants + + z1 = sm.z( + x=[0, 5000, 10000], + C=C[:, [0]], + length=10000, + phi=10.0, + has_foundation=True, + ) + z2 = sm.z( + x=[0, 2000, 4000], + C=C[:, [1]], + length=4000, + phi=10.0, + has_foundation=True, + ) + + zz = np.hstack([z1, z2]) + np.testing.assert_allclose(GT_skier_baseline, zz, rtol=1e-10, atol=1e-12) + + def test_skiers_baseline(self): + """Test the skiers baseline.""" + layers = [Layer(rho=200, h=150)] + wl = WeakLayer() + segs = [ + Segment(length=5e3, has_foundation=True, m=30.0), + Segment(length=2000, has_foundation=True, m=35.0), + Segment(length=5e3, has_foundation=True, m=0.0), + ] + sc = ScenarioConfig(phi=10.0, system_type="skiers", cut_length=0.0) + mi = ModelInput(layers=layers, weak_layer=wl, segments=segs, scenario_config=sc) + sm = SystemModel(model_input=mi, config=Config(touchdown=False)) + C = sm.unknown_constants + + z1 = sm.z( + x=[0, 2500, 5000], + C=C[:, [0]], + length=5000, + phi=10.0, + has_foundation=True, + ) + z2 = sm.z( + x=[0, 1000, 2000], + C=C[:, [1]], + length=2000, + phi=10.0, + has_foundation=True, + ) + z3 = sm.z( + x=[0, 2500, 5000], + C=C[:, [2]], + length=5000, + phi=10.0, + has_foundation=True, + ) + + zz = np.hstack([z1, z2, z3]) + np.testing.assert_allclose(GT_skiers_baseline, zz, rtol=1e-10, atol=1e-12) + + def test_pst_without_touchdown_baseline(self): + """Test the pst without touchdown baseline.""" + layers = [Layer(rho=200, h=150), Layer(rho=300, h=100)] + wl = WeakLayer(rho=170, h=20) + segs = [ + Segment(length=10000, has_foundation=True, m=0), + Segment(length=4000, has_foundation=False, m=0), + ] + sc = ScenarioConfig(phi=30.0, system_type="pst-", cut_length=4000) + mi = ModelInput(layers=layers, weak_layer=wl, segments=segs, scenario_config=sc) + sm = SystemModel(model_input=mi, config=Config(touchdown=False)) + C = sm.unknown_constants + + z1 = sm.z( + x=[0, 5000, 10000], + C=C[:, [0]], + length=10000, + phi=30.0, + has_foundation=True, + ) + z2 = sm.z( + x=[0, 2000, 4000], + C=C[:, [1]], + length=4000, + phi=30.0, + has_foundation=False, + ) + + zz = np.hstack([z1, z2]) + np.testing.assert_allclose(GT_pst_without_touchdown, zz, rtol=1e-10, atol=1e-12) + + def test_pst_with_touchdown_baseline(self): + """Test the pst with touchdown baseline.""" + layers = [Layer(rho=200, h=150), Layer(rho=300, h=100)] + wl = WeakLayer(rho=50, h=20, E=0.35, nu=0.1) + segs = [ + Segment(length=10000, has_foundation=True, m=0), + Segment(length=4000, has_foundation=False, m=0), + ] + sc = ScenarioConfig(phi=30.0, system_type="pst-", cut_length=4000) + mi = ModelInput(layers=layers, weak_layer=wl, segments=segs, scenario_config=sc) + sm = SystemModel(model_input=mi, config=Config(touchdown=True)) + + td = sm.slab_touchdown + C = sm.unknown_constants + + # Touchdown mode and distance baselines + self.assertEqual(td.touchdown_mode, "C_in_contact") + self.assertAlmostEqual(td.touchdown_distance, 1577.2698088929287, places=6) + + # Scenario segments updated by touchdown length + seg_lengths = np.array([seg.length for seg in sm.scenario.segments]) + np.testing.assert_allclose( + seg_lengths, np.array([10000.0, 1577.269808892929]), rtol=1e-12, atol=1e-12 + ) + + z1 = sm.z( + x=[0, 5000, 10000], + C=C[:, [0]], + length=10000, + phi=30.0, + has_foundation=True, + ) + z2 = sm.z( + x=[0, 2000, 4000], + C=C[:, [1]], + length=4000, + phi=30.0, + has_foundation=False, + ) + + zz = np.hstack([z1, z2]) + np.testing.assert_allclose(GT_pst_with_touchdown, zz, rtol=1e-10, atol=1e-12) + + def test_criteria_evaluator_regressions(self): + """Test the criteria evaluator regressions.""" + layers = [Layer(rho=170, h=100), Layer(rho=230, h=130)] + wl = WeakLayer(rho=180, h=20) + segs = [Segment(length=10000, has_foundation=True, m=0)] + sc = ScenarioConfig(phi=30.0, system_type="skier", cut_length=0.0) + mi = ModelInput(layers=layers, weak_layer=wl, segments=segs, scenario_config=sc) + sm = SystemModel(model_input=mi, config=Config(touchdown=False)) + + evaluator = CriteriaEvaluator(CriteriaConfig()) + + # find_minimum_force baseline + fm = evaluator.find_minimum_force(system=sm, tolerance_stress=0.005) + self.assertTrue(fm.success) + self.assertGreater(fm.critical_skier_weight, 0) + # Baseline values recorded + self.assertAlmostEqual(fm.critical_skier_weight, 68.504569930, places=6) + self.assertAlmostEqual(fm.max_dist_stress, 1.0000189267255666, places=6) + self.assertLess(fm.min_dist_stress, 1.0) + + # evaluate_SSERR baseline + ss = evaluator.evaluate_SSERR(system=sm, vertical=False) + self.assertTrue(ss.converged) + self.assertGreater(ss.touchdown_distance, 0) + # Baseline values recorded + self.assertAlmostEqual(ss.touchdown_distance, 1320.108936137, places=6) + np.testing.assert_allclose(ss.SSERR, 2.168112101045914, rtol=1e-8, atol=0) + + # evaluate_coupled_criterion baseline + cc = evaluator.evaluate_coupled_criterion(system=sm, max_iterations=10) + self.assertIsNotNone(cc) + self.assertIsInstance(cc.critical_skier_weight, float) + self.assertIsInstance(cc.crack_length, float) + # Baseline values recorded + self.assertTrue(cc.converged) + np.testing.assert_allclose( + cc.critical_skier_weight, 183.40853553646807, rtol=1e-2 + ) + np.testing.assert_allclose(cc.crack_length, 119.58600407185531, rtol=1e-2) + np.testing.assert_allclose(cc.g_delta, 1.0, rtol=1e-2) + np.testing.assert_allclose(cc.dist_ERR_envelope, 0.0, atol=1e-2) + + # find_minimum_crack_length baseline (returns crack length > 0) + crack_len, new_segments = evaluator.find_minimum_crack_length(system=sm) + self.assertGreater(crack_len, 0) + self.assertTrue(all(isinstance(s, Segment) for s in new_segments)) + # Baseline value recorded + np.testing.assert_allclose(crack_len, 1582.87791111003, rtol=1e-2) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_tools.py b/tests/test_tools.py deleted file mode 100644 index 4895fb7..0000000 --- a/tests/test_tools.py +++ /dev/null @@ -1,41 +0,0 @@ -""" -Unit tests for the tools module in the WEAC package. -""" - -import unittest - -import numpy as np - -from weac.tools import bergfeld - - -class TestTools(unittest.TestCase): - """Test cases for utility functions in the tools module.""" - - def test_bergfeld(self): - """Test the Bergfeld function for calculating Young's modulus from density.""" - # Test with a typical snow density - density = 300 # kg/m^3 - young = bergfeld(density) - - # Check that the result is positive and within expected range - self.assertGreater(young, 0) - - # Test with an array of densities - densities = np.array([200, 300, 400]) - youngs = bergfeld(densities) - - # Check that the result is an array of the same shape - self.assertEqual(youngs.shape, densities.shape) - - # Check that all values are positive and increasing with density - self.assertTrue(np.all(youngs > 0)) - self.assertTrue(np.all(np.diff(youngs) > 0)) - - # Test with zero density (should handle gracefully) - zero_young = bergfeld(0) - self.assertGreaterEqual(zero_young, 0) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/utils/json_helpers.py b/tests/utils/json_helpers.py new file mode 100644 index 0000000..15a7256 --- /dev/null +++ b/tests/utils/json_helpers.py @@ -0,0 +1,14 @@ +"""JSON serialization helpers for tests.""" + +from __future__ import annotations + +import numpy as np + + +def json_default(o: object) -> object: + """Custom JSON serializer for numpy data types.""" + if isinstance(o, np.ndarray): + return o.tolist() + if isinstance(o, np.generic): # covers np.int64, np.float64, np.bool_, etc. + return o.item() + return str(o) diff --git a/tests/utils/test_json_helpers.py b/tests/utils/test_json_helpers.py new file mode 100644 index 0000000..15ef6bf --- /dev/null +++ b/tests/utils/test_json_helpers.py @@ -0,0 +1,92 @@ +"""Unit tests for JSON helpers.""" + +import json +import unittest + +import numpy as np + +from .json_helpers import json_default + + +class TestJsonHelpers(unittest.TestCase): + """Test the JSON serialization helpers.""" + + def test_json_default_numpy_array(self): + """Verify numpy arrays are serialized to lists.""" + data = {"a": np.array([1, 2, 3])} + result = json.dumps(data, default=json_default) + self.assertEqual(json.loads(result), {"a": [1, 2, 3]}) + + def test_json_default_numpy_scalars(self): + """Verify numpy scalar types are serialized to Python primitives.""" + cases = { + "int64": np.int64(42), + "float64": np.float64(3.14), + "bool_true": np.bool_(True), + "bool_false": np.bool_(False), + } + result = json.dumps(cases, default=json_default) + expected = { + "int64": 42, + "float64": 3.14, + "bool_true": True, + "bool_false": False, + } + self.assertDictEqual(json.loads(result), expected) + + def test_json_default_mixed_types(self): + """Verify mixed data including numpy and standard types serializes correctly.""" + data = { + "np_array": np.arange(3), + "np_float": np.float32(1.23), + "py_int": 100, + "py_str": "hello", + "py_list": [1, "a", None], + } + result = json.dumps(data, default=json_default) + # Note: np.float32 may have precision differences, test against its .item() + expected_py_float = np.float32(1.23).item() + self.assertAlmostEqual( + json.loads(result)["np_float"], expected_py_float, places=6 + ) + # Check the rest of the dictionary + loaded_result = json.loads(result) + del loaded_result["np_float"] + expected_dict = { + "np_array": [0, 1, 2], + "py_int": 100, + "py_str": "hello", + "py_list": [1, "a", None], + } + self.assertDictEqual(loaded_result, expected_dict) + + def test_json_default_unhandled_type(self): + """Verify unhandled types are converted to their string representation.""" + + class Unserializable: # pylint: disable=too-few-public-methods + """Unserializable object.""" + + def __str__(self): + return "UnserializableObject" + + data = {"key": Unserializable()} + result = json.dumps(data, default=json_default) + self.assertEqual(json.loads(result), {"key": "UnserializableObject"}) + + def test_various_inputs(self): + """Test a variety of inputs for comprehensive coverage.""" + test_cases = [ + (np.int32(-5), "-5"), + (np.float64(1e-9), "1e-09"), + (np.array([1.0, 2.5]), "[1.0, 2.5]"), + (True, "true"), + (None, "null"), + ] + + for value, expected in test_cases: + with self.subTest(value=value): + self.assertEqual(json.dumps(value, default=json_default), expected) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/utils/test_misc.py b/tests/utils/test_misc.py new file mode 100644 index 0000000..b9223c2 --- /dev/null +++ b/tests/utils/test_misc.py @@ -0,0 +1,332 @@ +""" +Unit tests for utility functions. + +Tests force decomposition, skier load calculations, and other utility functions. +""" + +import unittest + +import numpy as np + +from weac.constants import G_MM_S2, LSKI_MM +from weac.utils.misc import decompose_to_normal_tangential, get_skier_point_load + + +class TestForceDecomposition(unittest.TestCase): + """Test the decompose_to_normal_tangential function.""" + + def test_flat_surface_decomposition(self): + """Test force decomposition on flat surface (phi=0).""" + f = 100.0 # Vertical force + phi = 0.0 # Flat surface + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # On flat surface, normal component equals original force, tangential is zero + self.assertAlmostEqual( + f_norm, + f, + places=10, + msg="Normal component should equal original force on flat surface", + ) + self.assertAlmostEqual( + f_tan, + 0.0, + places=10, + msg="Tangential component should be zero on flat surface", + ) + + def test_vertical_surface_decomposition(self): + """Test force decomposition on vertical surface (phi=90).""" + f = 100.0 # Vertical force + phi = 90.0 # Vertical surface + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # On vertical surface, normal component is zero, tangential equals original force + self.assertAlmostEqual( + f_norm, + 0.0, + places=10, + msg="Normal component should be zero on vertical surface", + ) + self.assertAlmostEqual( + f_tan, + -f, + places=10, + msg="Tangential component should equal negative original force", + ) + + def test_45_degree_decomposition(self): + """Test force decomposition on 45-degree surface.""" + f = 100.0 # Vertical force + phi = 45.0 # 45-degree surface + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # On 45-degree surface, both components should be equal in magnitude + expected_component = f / np.sqrt(2) + self.assertAlmostEqual( + abs(f_norm), + expected_component, + places=8, + msg="Normal component magnitude should be f/√2 for 45Β° surface", + ) + self.assertAlmostEqual( + abs(f_tan), + expected_component, + places=8, + msg="Tangential component magnitude should be f/√2 for 45Β° surface", + ) + + # Check signs: normal should be positive (into slope), tangential negative (downslope) + self.assertGreater( + f_norm, 0, "Normal component should be positive (into slope)" + ) + self.assertLess(f_tan, 0, "Tangential component should be negative (downslope)") + + def test_30_degree_decomposition(self): + """Test force decomposition on 30-degree surface.""" + f = 100.0 # Vertical force + phi = 30.0 # 30-degree surface + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # Known analytical values for 30 degrees + expected_norm = f * np.cos(np.deg2rad(30)) # f * cos(30Β°) = f * √3/2 + expected_tan = -f * np.sin(np.deg2rad(30)) # -f * sin(30Β°) = -f/2 + + self.assertAlmostEqual(f_norm, expected_norm, places=10) + self.assertAlmostEqual(f_tan, expected_tan, places=10) + + def test_negative_angles(self): + """Test force decomposition with negative angles.""" + f = 100.0 # Vertical force + phi = -30.0 # Negative angle (surface slopes down in +x direction) + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # Normal component should still be positive and equal to f*cos(phi) + # Tangential should be positive (upslope for negative angle) with magnitude f*sin(phi) + expected_norm = f * np.cos(np.deg2rad(phi)) + expected_tan = -f * np.sin(np.deg2rad(phi)) + self.assertAlmostEqual(f_norm, expected_norm, places=10) + self.assertAlmostEqual(f_tan, expected_tan, places=10) + + def test_zero_force(self): + """Test force decomposition with zero force.""" + f = 0.0 + phi = 30.0 + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + self.assertEqual(f_norm, 0.0, "Zero force should give zero normal component") + self.assertEqual(f_tan, 0.0, "Zero force should give zero tangential component") + + def test_energy_conservation(self): + """Test that force decomposition conserves energy (magnitude).""" + f = 150.0 + phi = 37.0 # Arbitrary angle + + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # Total magnitude should be conserved: fΒ² = f_normΒ² + f_tanΒ² + original_magnitude_squared = f**2 + decomposed_magnitude_squared = f_norm**2 + f_tan**2 + + self.assertAlmostEqual( + original_magnitude_squared, + decomposed_magnitude_squared, + places=10, + msg="Force magnitude should be conserved in decomposition", + ) + + +class TestSkierPointLoad(unittest.TestCase): + """Test the get_skier_point_load function.""" + + def test_skier_load_calculation(self): + """Test basic skier load calculation.""" + m = 70.0 # 70 kg skier + + F = get_skier_point_load(m) + + # Expected calculation: F = 1e-3 * m * G_MM_S2 / LSKI_MM + expected_F = 1e-3 * m * G_MM_S2 / LSKI_MM + + self.assertAlmostEqual( + F, expected_F, places=10, msg="Skier load should match expected calculation" + ) + + def test_skier_load_units(self): + """Test that skier load has correct units.""" + m = 80.0 # kg + F = get_skier_point_load(m) + + # Result should be in N/mm (force per unit length) + # For typical values, this should be a small positive number + self.assertGreater(F, 0, "Skier load should be positive") + self.assertLess(F, 1, "Skier load should be reasonable magnitude (< 1 N/mm)") + + def test_zero_mass_skier(self): + """Test skier load calculation with zero mass.""" + m = 0.0 + F = get_skier_point_load(m) + + self.assertEqual(F, 0.0, "Zero mass should give zero load") + + def test_heavy_skier(self): + """Test skier load calculation with heavy skier.""" + m = 120.0 # Heavy skier + F = get_skier_point_load(m) + + # Should be positive and larger than for lighter skier + m_light = 60.0 + F_light = get_skier_point_load(m_light) + + self.assertGreater(F, F_light, "Heavier skier should produce larger load") + self.assertAlmostEqual( + F / F_light, + m / m_light, + places=10, + msg="Load should scale linearly with mass", + ) + + def test_skier_load_scaling(self): + """Test that skier load scales linearly with mass.""" + masses = [50, 75, 100, 125] # Different skier masses + loads = [get_skier_point_load(m) for m in masses] + + # Check linear scaling + for i in range(1, len(masses)): + ratio_mass = masses[i] / masses[0] + ratio_load = loads[i] / loads[0] + self.assertAlmostEqual( + ratio_mass, + ratio_load, + places=10, + msg=f"Load should scale linearly: mass ratio {ratio_mass}, load ratio {ratio_load}", + ) + + +class TestUtilityFunctionConsistency(unittest.TestCase): + """Test consistency and edge cases for utility functions.""" + + def test_decomposition_symmetry(self): + """Test that force decomposition is symmetric for opposite angles.""" + f = 100.0 + phi = 25.0 + + f_norm_pos, f_tan_pos = decompose_to_normal_tangential(f, phi) + f_norm_neg, f_tan_neg = decompose_to_normal_tangential(f, -phi) + + # Normal components should be equal + self.assertAlmostEqual( + f_norm_pos, + f_norm_neg, + places=10, + msg="Normal components should be equal for Β±Ο†", + ) + + # Tangential components should be opposite + self.assertAlmostEqual( + f_tan_pos, + -f_tan_neg, + places=10, + msg="Tangential components should be opposite for Β±Ο†", + ) + + def test_large_angles(self): + """Test force decomposition for large angles.""" + f = 100.0 + + # Test beyond 90 degrees + phi = 120.0 + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # At 120Β°, normal component should be negative (surface leans over) + # and tangential component should be negative (large downslope) + self.assertLess( + f_norm, 0, "Normal component should be negative for obtuse angles" + ) + self.assertLess(f_tan, 0, "Tangential component should be negative") + + def test_angle_bounds(self): + """Test force decomposition at angle boundaries.""" + f = 100.0 + + # Test at exactly 0Β° + f_norm, f_tan = decompose_to_normal_tangential(f, 0.0) + self.assertAlmostEqual(f_norm, f, places=15) + self.assertAlmostEqual(f_tan, 0.0, places=15) + + # Test at exactly 90Β° (expect some floating-point precision issues) + f_norm, f_tan = decompose_to_normal_tangential(f, 90.0) + self.assertAlmostEqual(f_norm, 0.0, places=10) # Reduced precision for 90Β° case + self.assertAlmostEqual(f_tan, -f, places=15) + + def test_force_decomposition_with_arrays(self): + """Test that functions work with array inputs (if applicable).""" + # This tests if the functions can handle numpy arrays + masses = np.array([60.0, 70.0, 80.0]) + + # Should work with array input + try: + loads = get_skier_point_load(masses) + self.assertEqual(len(loads), len(masses), "Should handle array input") + for i, m in enumerate(masses): + expected = get_skier_point_load(m) + self.assertAlmostEqual(loads[i], expected, places=10) + except (TypeError, AttributeError) as exc: + self.skipTest(f"get_skier_point_load does not support array inputs: {exc}") + + +class TestPhysicalReasonableness(unittest.TestCase): + """Test that utility functions produce physically reasonable results.""" + + def test_typical_skier_loads(self): + """Test that typical skier loads are in reasonable ranges.""" + # Typical skier masses + typical_masses = [50, 70, 90, 110] # kg + + for m in typical_masses: + F = get_skier_point_load(m) + + # Load should be positive but not huge + self.assertGreater(F, 0, f"Load should be positive for {m} kg skier") + self.assertLess(F, 10, f"Load should be reasonable for {m} kg skier") + + # Rough sanity check: load should be on order of mg/length + # where length is ski contact length + rough_estimate = m * 9.81 / 1000 # Very rough estimate in N/mm + self.assertLess( + F, 10 * rough_estimate, "Load should be reasonable compared to weight" + ) + + def test_typical_force_decompositions(self): + """Test force decomposition for typical avalanche slopes.""" + f = 100.0 # Typical force + typical_angles = [25, 30, 35, 40, 45] # Typical avalanche slope angles + + for phi in typical_angles: + f_norm, f_tan = decompose_to_normal_tangential(f, phi) + + # Both components should be significant but less than original force + self.assertGreater( + abs(f_norm), 0, f"Normal component should be non-zero at {phi}Β°" + ) + self.assertGreater( + abs(f_tan), 0, f"Tangential component should be non-zero at {phi}Β°" + ) + self.assertLess( + abs(f_norm), f, f"Normal component should be less than total at {phi}Β°" + ) + self.assertLess( + abs(f_tan), + f, + f"Tangential component should be less than total at {phi}Β°", + ) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/utils/test_snowpilot_parser.py b/tests/utils/test_snowpilot_parser.py new file mode 100644 index 0000000..1945127 --- /dev/null +++ b/tests/utils/test_snowpilot_parser.py @@ -0,0 +1,200 @@ +""" +Unit tests for the SnowPilotParser class. + +Tests the parsing of CAAML files, density measurement extraction, +fallback to hardness+grain type calculations, and stability test parsing. +""" + +import os +import unittest + +from weac.components import Layer, WeakLayer +from weac.utils.snowpilot_parser import SnowPilotParser + + +class TestSnowPilotParser(unittest.TestCase): + """Test the SnowPilotParser functionality.""" + + def setUp(self): + """Set up test fixtures with paths to test CAAML files.""" + # Paths to test materials in .materials/ + self.materials_dir = os.path.join( + os.path.dirname(os.path.dirname(__file__)), ".materials" + ) + self.caaml_with_density = os.path.join(self.materials_dir, "test_snowpit1.xml") + self.caaml_without_density = os.path.join( + self.materials_dir, "test_snowpit2.xml" + ) + + # Verify test files exist + self.assertTrue( + os.path.exists(self.caaml_with_density), + f"Test file not found: {self.caaml_with_density}", + ) + self.assertTrue( + os.path.exists(self.caaml_without_density), + f"Test file not found: {self.caaml_without_density}", + ) + + def test_parse_caaml_with_density_measurements(self): + """Test parsing CAAML file that contains density measurements.""" + parser = SnowPilotParser(self.caaml_with_density) + layers, density_methods = parser.extract_layers() + + # Should have extracted layers + self.assertGreater(len(layers), 0, "Should extract layers from CAAML") + self.assertGreater( + density_methods.count("density_obs"), + 0, + "Should use measured density for some layers", + ) + + def test_parse_caaml_without_density_measurements(self): + """Test parsing CAAML file that lacks density measurements.""" + parser = SnowPilotParser(self.caaml_without_density) + layers, density_methods = parser.extract_layers() + + # Should have extracted layers + self.assertGreater(len(layers), 0, "Should extract layers from CAAML") + self.assertEqual(density_methods.count("geldsetzer"), len(layers)) + + def test_density_extraction_logic(self): + """Test the density extraction logic with overlapping measurements.""" + parser = SnowPilotParser(self.caaml_with_density) + + # Get density layers for testing + sp_density_layers = [ + layer + for layer in parser.snowpit.snow_profile.density_profile + if layer.depth_top is not None + ] + + # Test case 1: Layer that should overlap with density measurements + # From the CAAML file, we have density measurements at 0-4cm, 10-14cm, etc. + # Test a layer at 2-6cm (should overlap with 0-4cm measurement) + density = parser.get_density_for_layer_range( + 20, 60, sp_density_layers + ) # 2-6cm in mm + self.assertIsNotNone(density, "Should find density for overlapping layer") + self.assertIsInstance(density, float, "Density should be a float") + self.assertGreater(density, 0, "Density should be positive") + + # Test case 2: Layer with no overlap + # Test a layer well beyond the density measurements + density_no_overlap = parser.get_density_for_layer_range( + 1000, 1100, sp_density_layers + ) # 100-110cm + self.assertIsNone( + density_no_overlap, "Should return None for non-overlapping layer" + ) + + def test_layer_properties_validation(self): + """Test that extracted layers have valid properties.""" + parser = SnowPilotParser(self.caaml_with_density) + layers, _ = parser.extract_layers() + + for i, layer in enumerate(layers): + with self.subTest(layer_index=i): + # Validate layer properties + self.assertIsInstance( + layer, Layer, f"Layer {i} should be Layer instance" + ) + self.assertGreater( + layer.rho, 0, f"Layer {i} density should be positive" + ) + self.assertGreater( + layer.h, 0, f"Layer {i} thickness should be positive" + ) + self.assertLessEqual( + layer.rho, + 1000, + f"Layer {i} density should be reasonable (<= 1000 kg/mΒ³)", + ) + + def test_weak_layer_extraction(self): + """Test weak layer extraction for different depths.""" + parser = SnowPilotParser(self.caaml_with_density) + layers, _ = parser.extract_layers() + + # Test weak layer extraction at a specific depth (e.g., 21cm from CT test) + test_depth_mm = 210 # 21cm converted to mm + weak_layer, layers_above = parser.extract_weak_layer_and_layers_above( + test_depth_mm, layers + ) + + # Validate weak layer + self.assertIsInstance( + weak_layer, WeakLayer, "Should extract WeakLayer instance" + ) + self.assertGreater(weak_layer.rho, 0, "Weak layer density should be positive") + self.assertGreater(weak_layer.h, 0, "Weak layer thickness should be positive") + + # Validate layers above + self.assertGreater(len(layers_above), 0, "Should have layers above weak layer") + total_depth_above = sum(layer.h for layer in layers_above) + self.assertAlmostEqual( + total_depth_above, + test_depth_mm, + delta=1, + msg="Total depth of layers above should match test depth", + ) + + def test_error_handling_missing_data(self): + """Test error handling for missing required data.""" + # This would require creating a malformed CAAML file or mocking + # For now, test that parser handles empty density layers gracefully + parser = SnowPilotParser(self.caaml_without_density) + + # Test with empty density layers list + result = parser.get_density_for_layer_range(0, 100, []) + self.assertIsNone(result, "Should return None for empty density layers") + + def test_unit_conversion(self): + """Test that different units are converted correctly.""" + parser = SnowPilotParser(self.caaml_with_density) + layers, _ = parser.extract_layers() + + # All thicknesses should be in mm (converted from cm in CAAML) + for layer in layers: + # Thicknesses should be reasonable for mm units (> 1mm, < 2000mm typically) + self.assertGreater(layer.h, 0.1, "Layer thickness should be > 0.1mm") + self.assertLess( + layer.h, 5000, "Layer thickness should be < 5000mm (reasonable limit)" + ) + + def test_density_weighted_average(self): + """Test that overlapping density measurements are weighted correctly.""" + parser = SnowPilotParser(self.caaml_with_density) + + # Get density layers + sp_density_layers = [ + layer + for layer in parser.snowpit.snow_profile.density_profile + if layer.depth_top is not None + ] + + # Test a layer that spans multiple density measurements + # Based on the CAAML data, density measurements are at: + # 0-4cm (20 kg/mΒ³), 10-14cm (20 kg/mΒ³), 20-24cm (20 kg/mΒ³), etc. + + # Test layer from 0-25cm (should span first 3 measurements) + density = parser.get_density_for_layer_range( + 0, 250, sp_density_layers + ) # 0-25cm in mm + + if density is not None: # May be None if no overlap logic issue + self.assertIsInstance(density, float, "Weighted density should be float") + self.assertGreater(density, 0, "Weighted density should be positive") + # Should be close to 20 since most measurements are 20 kg/mΒ³ + self.assertAlmostEqual( + density, 20, delta=5, msg="Weighted average should be close to 20 kg/mΒ³" + ) + + +if __name__ == "__main__": + # Set up logging to see debug info during tests + import logging + + logging.basicConfig(level=logging.INFO) + + unittest.main() diff --git a/tests/utils/weac_reference_runner.py b/tests/utils/weac_reference_runner.py new file mode 100644 index 0000000..70f4e48 --- /dev/null +++ b/tests/utils/weac_reference_runner.py @@ -0,0 +1,379 @@ +""" +Utility to run code against a reference (pinned) PyPI weac version in isolation. + +Creates and caches a dedicated virtual environment per version under +`.weac-reference/` (overridable via WEAC_REFERENCE_HOME), installs the +requested version, executes a small helper script inside that environment, and +returns computed results to the tests via JSON. + +This avoids import-name conflicts with the local in-repo `weac` package. +""" + +from __future__ import annotations + +import json +import os +import shutil +import subprocess +import sys +import tempfile +from dataclasses import dataclass +from typing import Any, Dict, Optional, Tuple + +# For type hints without importing numpy at module import time +try: + import numpy as _np +except ImportError: + from typing import TYPE_CHECKING + + if TYPE_CHECKING: + import numpy as _np + else: + _np = Any # type: ignore[assignment, misc] + + +DEFAULT_REFERENCE_VERSION = os.environ.get("WEAC_REFERENCE_VERSION", "2.6.4") +REFERENCE_HOME = os.environ.get("WEAC_REFERENCE_HOME", None) + + +@dataclass +class ReferenceEnv: + """Reference environment for running the reference weac implementation.""" + + python_exe: str + venv_dir: str + version: str + + +# New: ensure subprocesses don't see local project on sys.path or user site +def _clean_env() -> Dict[str, str]: + env = os.environ.copy() + env.pop("PYTHONPATH", None) + env["PYTHONNOUSERSITE"] = "1" + return env + + +def _project_root() -> str: + # tests/utils/weac_reference_runner.py -> tests -> project root + return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) + + +def _venv_dir(version: str) -> str: + # Place under project root to cache between test runs + root = _project_root() + base = REFERENCE_HOME or os.path.join(root, ".weac-reference") + return os.path.join(base, version) + + +def _venv_python(venv_dir: str) -> str: + if sys.platform == "win32": + return os.path.join(venv_dir, "Scripts", "python.exe") + return os.path.join(venv_dir, "bin", "python") + + +def ensure_weac_reference_env( + version: str = DEFAULT_REFERENCE_VERSION, +) -> Optional[ReferenceEnv]: + """Create a dedicated venv with weac==version installed if missing. + + Returns ReferenceEnv on success, or None on failure (e.g., no network). + """ + venv_dir = _venv_dir(version) + py_exe = _venv_python(venv_dir) + + try: + if not os.path.exists(py_exe): + os.makedirs(venv_dir, exist_ok=True) + # Create venv + subprocess.run( + [sys.executable, "-m", "venv", venv_dir], + check=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + ) + + # Ensure pip is up to date + subprocess.run( + [py_exe, "-m", "pip", "install", "--upgrade", "pip"], + check=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + ) + + # Ensure numpy is available for the runner script regardless of weac deps + subprocess.run( + [py_exe, "-m", "pip", "install", "--upgrade", "numpy"], + check=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + ) + + # Install exact version if not present or mismatched + code = ( + "import sys\n" + "try:\n" + " from importlib.metadata import version, PackageNotFoundError\n" + "except Exception:\n" + " from importlib_metadata import version, PackageNotFoundError\n" + "try:\n" + f" v = version('weac'); sys.exit(0 if v == '{version}' else 1)\n" + "except PackageNotFoundError:\n" + " sys.exit(2)\n" + ) + check_proc = subprocess.run( + [py_exe, "-c", code], + cwd=venv_dir, + env=_clean_env(), + check=False, + ) + if check_proc.returncode != 0: + # Install pinned reference version and its deps + subprocess.run( + [ + py_exe, + "-m", + "pip", + "install", + f"weac=={version}", + ], + check=True, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + env=_clean_env(), + ) + + return ReferenceEnv(python_exe=py_exe, venv_dir=venv_dir, version=version) + except subprocess.CalledProcessError as e: + # Capture and log the output for easier debugging in CI + output = e.stdout.strip() if e.stdout else "" + error_msg = ( + f"Failed to create reference environment for weac=={version}.\n" + f"Command: {' '.join(e.cmd)}\n" + f"Return code: {e.returncode}\n" + f"Output:\n{output}" + ) + print(error_msg, file=sys.stderr) + return None + + +def _write_runner_script(script_path: str) -> None: + """Write the Python script executed inside the reference venv. + + The script reads a JSON config path from argv[1], executes the reference API, + and prints JSON to stdout. + """ + script = r""" +import json +import sys +import numpy as np +from json_helpers import json_default + + +def main(): + cfg_path = sys.argv[1] + with open(cfg_path, 'r', encoding='utf-8') as f: + cfg = json.load(f) + + import weac as ref_weac + + # Build model + system = cfg.get('system', 'skier') + layers_profile = cfg['layers_profile'] + touchdown = bool(cfg.get('touchdown', False)) + model = ref_weac.Layered(system=system, layers=layers_profile, touchdown=touchdown) + + set_foundation = cfg.get('set_foundation') + if set_foundation: + # e.g. {"t": 20, "E": 0.35, "nu": 0.1} + model.set_foundation_properties(update=True, **set_foundation) + + L = float(cfg['L']) + a = float(cfg['a']) + m = float(cfg['m']) + phi = float(cfg['phi']) + + segs = model.calc_segments(L=L, a=a, m=m, li=None, mi=None, ki=None, phi=phi)["crack"] + constants = model.assemble_and_solve(phi=phi, **segs) + + z_parts = [] + num_segments = constants.shape[1] + # The 'pst-' system returns segments in lists under 'li', 'mi', 'ki' + seg_lengths = segs.get('li', []) + seg_foundations = segs.get('ki', []) + + for i in range(num_segments): + seg_len = seg_lengths[i] + is_bed = seg_foundations[i] + x_coords = [0, seg_len/2, seg_len] + C_seg = constants[:, [i]] + + z_segment = model.z( + x=x_coords, + C=C_seg, + l=seg_len, + phi=phi, + bed=is_bed + ) + z_parts.append(np.asarray(z_segment)) + + if z_parts: + z_combined = np.hstack(z_parts) + z_list = z_combined.tolist() + else: + z_list = [] + + + # --- Analysis --- + analysis_results = {} + if num_segments > 0: + raster_x, raster_z, raster_xb = model.rasterize_solution( + C=constants, phi=phi, li=seg_lengths, ki=seg_foundations, num=100 + ) + z_mesh = model.get_zmesh(dz=2) + sxx = model.Sxx(raster_z, phi, dz=2, unit="kPa") + txz = model.Txz(raster_z, phi, dz=2, unit="kPa") + szz = model.Szz(raster_z, phi, dz=2, unit="kPa") + principal_stress_slab = model.principal_stress_slab( + raster_z, phi, dz=2, val="max", unit="kPa", normalize=False + ) + + analysis_results = { + "raster_x": np.asarray(raster_x).tolist(), + "raster_z": np.asarray(raster_z).tolist(), + "raster_xb": np.asarray(raster_xb).tolist(), + "z_mesh": np.asarray(z_mesh).tolist(), + "sxx": np.asarray(sxx).tolist(), + "txz": np.asarray(txz).tolist(), + "szz": np.asarray(szz).tolist(), + "principal_stress_slab": np.asarray(principal_stress_slab).tolist(), + } + + # Extract state needed by tests + state = { + "weak": { + "nu": model.weak.get("nu"), + "E": model.weak.get("E"), + }, + "t": getattr(model, 't', None), + "kn": getattr(model, 'kn', None), + "kt": getattr(model, 'kt', None), + "slab": model.slab.tolist() if hasattr(model, 'slab') else None, + "h": getattr(model, 'h', None), + "zs": getattr(model, 'zs', None), + "a": getattr(model, 'a', None), + "touchdown": { + "tc": getattr(model, 'tc', None), + "a1": getattr(model, 'a1', None), + "a2": getattr(model, 'a2', None), + "td": getattr(model, 'td', None), + }, + "segs": segs, + } + + out = {"constants": np.asarray(constants).tolist(), "state": state, "z": z_list, "analysis": analysis_results} + print(json.dumps(out, default=json_default)) + +if __name__ == '__main__': + main() +""" + with open(script_path, "w", encoding="utf-8") as f: + f.write(script) + + +def compute_reference_model_results( + *, + system: str, + layers_profile: Any, + touchdown: bool, + L: float, + a: float, + m: float, + phi: float, + set_foundation: Optional[Dict[str, Any]] = None, + version: str = DEFAULT_REFERENCE_VERSION, +) -> Tuple["_np.ndarray", Dict[str, Any], "_np.ndarray", Dict[str, Any]]: + """Run the reference published weac implementation and return (constants, state, z). + + The return constants is a numpy array; state is a JSON-serializable dict + with selected model attributes used in tests. + """ + env = ensure_weac_reference_env(version=version) + if env is None: + raise RuntimeError( + f"Unable to provision reference weac environment (weac=={version})." + ) + + tmp_dir = tempfile.mkdtemp(prefix="weac_reference_run_") + try: + # Copy helper to be available to the runner script + json_helpers_src = os.path.join(os.path.dirname(__file__), "json_helpers.py") + shutil.copy(json_helpers_src, tmp_dir) + + cfg = { + "system": system, + "layers_profile": layers_profile, + "touchdown": touchdown, + "L": L, + "a": a, + "m": m, + "phi": phi, + "set_foundation": set_foundation, + } + + cfg_path = os.path.join(tmp_dir, "config.json") + with open(cfg_path, "w", encoding="utf-8") as f: + json.dump(cfg, f) + + runner_path = os.path.join(tmp_dir, "reference_runner.py") + _write_runner_script(runner_path) + + proc = subprocess.run( + [env.python_exe, runner_path, cfg_path], + check=False, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True, + cwd=tmp_dir, + env=_clean_env(), + ) + + if proc.returncode != 0: + raise RuntimeError( + f"Reference runner failed with code {proc.returncode}: {proc.stderr.strip()}" + ) + + data = json.loads(proc.stdout) + + # Lazy import numpy only in the main environment + import numpy as np # pylint: disable=import-outside-toplevel + + constants = np.asarray(data["constants"]) + state = data["state"] + z = np.asarray(data["z"]) + analysis = data.get("analysis", {}) + if "raster_x" in analysis: + analysis["raster_x"] = np.asarray(analysis["raster_x"]) + if "raster_z" in analysis: + analysis["raster_z"] = np.asarray(analysis["raster_z"]) + if "raster_xb" in analysis: + analysis["raster_xb"] = np.asarray(analysis["raster_xb"]) + if "z_mesh" in analysis: + analysis["z_mesh"] = np.asarray(analysis["z_mesh"]) + if "sxx" in analysis: + analysis["sxx"] = np.asarray(analysis["sxx"]) + if "txz" in analysis: + analysis["txz"] = np.asarray(analysis["txz"]) + if "szz" in analysis: + analysis["szz"] = np.asarray(analysis["szz"]) + if "principal_stress_slab" in analysis: + analysis["principal_stress_slab"] = np.asarray( + analysis["principal_stress_slab"] + ) + + return constants, state, z, analysis + finally: + shutil.rmtree(tmp_dir, ignore_errors=True) diff --git a/weac/__init__.py b/weac/__init__.py index 78fea09..916b1da 100644 --- a/weac/__init__.py +++ b/weac/__init__.py @@ -1,17 +1,5 @@ """ -WEak Layer AntiCrack nucleation model. - -Implementation of closed-form analytical models for the analysis of -dry-snow slab avalanche release. +WEAC - Weak Layer Anticrack Nucleation Model """ -# Module imports -from weac import plot -from weac.inverse import Inverse -from weac.layered import Layered - -# Version __version__ = "2.6.4" - -# Public names -__all__ = ["Layered", "Inverse", "plot"] diff --git a/weac/analysis/__init__.py b/weac/analysis/__init__.py new file mode 100644 index 0000000..7f08d60 --- /dev/null +++ b/weac/analysis/__init__.py @@ -0,0 +1,23 @@ +""" +This package contains modules for analyzing the results of the WEAC model. +""" + +from .analyzer import Analyzer +from .criteria_evaluator import ( + CoupledCriterionHistory, + CoupledCriterionResult, + CriteriaEvaluator, + FindMinimumForceResult, + SSERRResult, +) +from .plotter import Plotter + +__all__ = [ + "Analyzer", + "CriteriaEvaluator", + "CoupledCriterionHistory", + "CoupledCriterionResult", + "FindMinimumForceResult", + "SSERRResult", + "Plotter", +] diff --git a/weac/analysis/analyzer.py b/weac/analysis/analyzer.py new file mode 100644 index 0000000..47e6016 --- /dev/null +++ b/weac/analysis/analyzer.py @@ -0,0 +1,790 @@ +""" +This module provides the Analyzer class, which is used to analyze the results of the WEAC model. +""" + +# Standard library imports +import logging +import time +from collections import defaultdict +from functools import partial, wraps +from typing import Literal + +# Third party imports +import numpy as np +from scipy.integrate import cumulative_trapezoid, quad + +from weac.constants import G_MM_S2 + +# Module imports +from weac.core.system_model import SystemModel + +logger = logging.getLogger(__name__) + + +def track_analyzer_call(func): + """Decorator to track call count and execution time of Analyzer methods.""" + + @wraps(func) + def wrapper(self, *args, **kwargs): + """Wrapper that adds tracking functionality.""" + + start_time = time.perf_counter() + result = func(self, *args, **kwargs) + duration = time.perf_counter() - start_time + + func_name = func.__name__ + self.call_stats[func_name]["count"] += 1 + self.call_stats[func_name]["total_time"] += duration + + logger.debug( + "Analyzer method '%s' called. Execution time: %.4f seconds.", + func_name, + duration, + ) + + return result + + return wrapper + + +class Analyzer: + """ + Provides methods for the analysis of layered slabs on compliant + elastic foundations. + """ + + sm: SystemModel + printing_enabled: bool = True + + def __init__(self, system_model: SystemModel, printing_enabled: bool = True): + self.sm = system_model + self.call_stats = defaultdict(lambda: {"count": 0, "total_time": 0.0}) + self.printing_enabled = printing_enabled + + def get_call_stats(self): + """Returns the call statistics.""" + return self.call_stats + + def print_call_stats(self, message: str = "Analyzer Call Statistics"): + """Prints the call statistics in a readable format.""" + if self.printing_enabled: + print(f"--- {message} ---") + if not self.call_stats: + print("No methods have been called.") + return + + sorted_stats = sorted( + self.call_stats.items(), + key=lambda item: item[1]["total_time"], + reverse=True, + ) + + for func_name, stats in sorted_stats: + count = stats["count"] + total_time = stats["total_time"] + avg_time = total_time / count if count > 0 else 0 + print( + f"- {func_name}: " + f"called {count} times, " + f"total time {total_time:.4f}s, " + f"avg time {avg_time:.4f}s" + ) + print("---------------------------------") + + @track_analyzer_call + def rasterize_solution( + self, + mode: Literal["cracked", "uncracked"] = "cracked", + num: int = 4000, + ): + """ + Compute rasterized solution vector. + + Parameters: + --------- + mode : Literal["cracked", "uncracked"] + Mode of the solution. + num : int + Number of grid points. + + Returns + ------- + xs : ndarray + Grid point x-coordinates at which solution vector + is discretized. + zs : ndarray + Matrix with solution vectors as columns at grid + points xs. + x_founded : ndarray + Grid point x-coordinates that lie on a foundation. + """ + ki = self.sm.scenario.ki + match mode: + case "cracked": + C = self.sm.unknown_constants + case "uncracked": + ki = np.full(len(ki), True) + C = self.sm.uncracked_unknown_constants + phi = self.sm.scenario.phi + li = self.sm.scenario.li + qs = self.sm.scenario.surface_load + + # Drop zero-length segments + li = abs(li) + isnonzero = li > 0 + C, ki, li = C[:, isnonzero], ki[isnonzero], li[isnonzero] + + # Compute number of plot points per segment (+1 for last segment) + ni = np.ceil(li / li.sum() * num).astype("int") + ni[-1] += 1 + + # Provide cumulated length and plot point lists + lic = np.insert(np.cumsum(li), 0, 0) + nic = np.insert(np.cumsum(ni), 0, 0) + + # Initialize arrays + issupported = np.full(ni.sum(), True) + xs = np.full(ni.sum(), np.nan) + zs = np.full([6, xs.size], np.nan) + + # Loop through segments + for i, length in enumerate(li): + # Get local x-coordinates of segment i + endpoint = i == li.size - 1 + xi = np.linspace(0, length, num=ni[i], endpoint=endpoint) + # Compute start and end coordinates of segment i + x0 = lic[i] + # Assemble global coordinate vector + xs[nic[i] : nic[i + 1]] = x0 + xi + # Mask coordinates not on foundation (including endpoints) + if not ki[i]: + issupported[nic[i] : nic[i + 1]] = False + # Compute segment solution + zi = self.sm.z(xi, C[:, [i]], length, phi, ki[i], qs=qs) + # Assemble global solution matrix + zs[:, nic[i] : nic[i + 1]] = zi + + # Make sure cracktips are included + transmissionbool = [ki[j] or ki[j + 1] for j, _ in enumerate(ki[:-1])] + for i, truefalse in enumerate(transmissionbool, start=1): + issupported[nic[i]] = truefalse + + # Assemble vector of coordinates on foundation + xs_supported = np.full(ni.sum(), np.nan) + xs_supported[issupported] = xs[issupported] + + return xs, zs, xs_supported + + @track_analyzer_call + def get_zmesh(self, dz=2): + """ + Get z-coordinates of grid points and corresponding elastic properties. + + Arguments + --------- + dz : float, optional + Element size along z-axis (mm). Default is 2 mm. + + Returns + ------- + mesh : ndarray + Mesh along z-axis. Columns are a list of z-coordinates (mm) of + grid points along z-axis with at least two grid points (top, + bottom) per layer, Young's modulus of each grid point, shear + modulus of each grid point, and Poisson's ratio of each grid + point. + """ + # Get z-coordinates of slab layers + z = np.concatenate([[self.sm.slab.z0], self.sm.slab.zi_bottom]) + # Compute number of grid points per layer + nlayer = np.ceil((z[1:] - z[:-1]) / dz).astype(np.int32) + 1 + # Calculate grid points as list of z-coordinates (mm) + zi = np.hstack( + [ + np.linspace(z[i], z[i + 1], n, endpoint=True) + for i, n in enumerate(nlayer) + ] + ) + # Extract elastic properties for each layer, reversing to match z order + layer_properties = { + "E": [layer.E for layer in self.sm.slab.layers], + "nu": [layer.nu for layer in self.sm.slab.layers], + "rho": [ + layer.rho * 1e-12 for layer in self.sm.slab.layers + ], # Convert to t/mm^3 + "tensile_strength": [ + layer.tensile_strength for layer in self.sm.slab.layers + ], + } + + # Repeat properties for each grid point in the layer + si = {"z": zi} + for prop, values in layer_properties.items(): + si[prop] = np.repeat(values, nlayer) + + return si + + @track_analyzer_call + def Sxx(self, Z, phi, dz=2, unit="kPa"): + """ + Compute axial normal stress in slab layers. + + Arguments + ---------- + Z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + dz : float, optional + Element size along z-axis (mm). Default is 2 mm. + unit : {'kPa', 'MPa'}, optional + Desired output unit. Default is 'kPa'. + + Returns + ------- + ndarray, float + Axial slab normal stress in specified unit. + """ + # Unit conversion dict + convert = {"kPa": 1e3, "MPa": 1} + + # Get mesh along z-axis + zmesh = self.get_zmesh(dz=dz) + zi = zmesh["z"] + rho = zmesh["rho"] + + # Get dimensions of stress field (n rows, m columns) + n = len(zmesh["z"]) + m = Z.shape[1] + + # Initialize axial normal stress Sxx + Sxx = np.zeros(shape=[n, m]) + + # Compute axial normal stress Sxx at grid points in MPa + for i, z in enumerate(zi): + E = zmesh["E"][i] + nu = zmesh["nu"][i] + Sxx[i, :] = E / (1 - nu**2) * self.sm.fq.du_dx(Z, z) + + # Calculate weight load at grid points and superimpose on stress field + qt = -rho * G_MM_S2 * np.sin(np.deg2rad(phi)) + # Old Implementation: Changed for numerical stability + # for i, qi in enumerate(qt[:-1]): + # Sxx[i, :] += qi * (zi[i + 1] - zi[i]) + # Sxx[-1, :] += qt[-1] * (zi[-1] - zi[-2]) + # New Implementation: Changed for numerical stability + dz = np.diff(zi) + Sxx[:-1, :] += qt[:-1, np.newaxis] * dz[:, np.newaxis] + Sxx[-1, :] += qt[-1] * dz[-1] + + # Return axial normal stress in specified unit + return convert[unit] * Sxx + + @track_analyzer_call + def Txz(self, Z, phi, dz=2, unit="kPa"): + """ + Compute shear stress in slab layers. + + Arguments + ---------- + Z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + dz : float, optional + Element size along z-axis (mm). Default is 2 mm. + unit : {'kPa', 'MPa'}, optional + Desired output unit. Default is 'kPa'. + + Returns + ------- + ndarray + Shear stress at grid points in the slab in specified unit. + """ + # Unit conversion dict + convert = {"kPa": 1e3, "MPa": 1} + # Get mesh along z-axis + zmesh = self.get_zmesh(dz=dz) + zi = zmesh["z"] + rho = zmesh["rho"] + qs = self.sm.scenario.surface_load + + # Get dimensions of stress field (n rows, m columns) + n = len(zi) + m = Z.shape[1] + + # Get second derivatives of centerline displacement u0 and + # cross-section rotaiton psi of all grid points along the x-axis + du0_dxdx = self.sm.fq.du0_dxdx(Z, phi, qs=qs) + dpsi_dxdx = self.sm.fq.dpsi_dxdx(Z, phi, qs=qs) + + # Initialize first derivative of axial normal stress sxx w.r.t. x + dsxx_dx = np.zeros(shape=[n, m]) + + # Calculate first derivative of sxx at z-grid points + for i, z in enumerate(zi): + E = zmesh["E"][i] + nu = zmesh["nu"][i] + dsxx_dx[i, :] = E / (1 - nu**2) * (du0_dxdx + z * dpsi_dxdx) + + # Calculate weight load at grid points + qt = -rho * G_MM_S2 * np.sin(np.deg2rad(phi)) + + # Integrate -dsxx_dx along z and add cumulative weight load + # to obtain shear stress Txz in MPa + Txz = cumulative_trapezoid(dsxx_dx, zi, axis=0, initial=0) + Txz += cumulative_trapezoid(qt, zi, initial=0)[:, None] + + # Return shear stress Txz in specified unit + return convert[unit] * Txz + + @track_analyzer_call + def Szz(self, Z, phi, dz=2, unit="kPa"): + """ + Compute transverse normal stress in slab layers. + + Arguments + ---------- + Z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + dz : float, optional + Element size along z-axis (mm). Default is 2 mm. + unit : {'kPa', 'MPa'}, optional + Desired output unit. Default is 'kPa'. + + Returns + ------- + ndarray, float + Transverse normal stress at grid points in the slab in + specified unit. + """ + # Unit conversion dict + convert = {"kPa": 1e3, "MPa": 1} + + # Get mesh along z-axis + zmesh = self.get_zmesh(dz=dz) + zi = zmesh["z"] + rho = zmesh["rho"] + qs = self.sm.scenario.surface_load + # Get dimensions of stress field (n rows, m columns) + n = len(zi) + m = Z.shape[1] + + # Get third derivatives of centerline displacement u0 and + # cross-section rotaiton psi of all grid points along the x-axis + du0_dxdxdx = self.sm.fq.du0_dxdxdx(Z, phi, qs=qs) + dpsi_dxdxdx = self.sm.fq.dpsi_dxdxdx(Z, phi, qs=qs) + + # Initialize second derivative of axial normal stress sxx w.r.t. x + dsxx_dxdx = np.zeros(shape=[n, m]) + + # Calculate second derivative of sxx at z-grid points + for i, z in enumerate(zi): + E = zmesh["E"][i] + nu = zmesh["nu"][i] + dsxx_dxdx[i, :] = E / (1 - nu**2) * (du0_dxdxdx + z * dpsi_dxdxdx) + + # Calculate weight load at grid points + qn = rho * G_MM_S2 * np.cos(np.deg2rad(phi)) + + # Integrate dsxx_dxdx twice along z to obtain transverse + # normal stress Szz in MPa + integrand = cumulative_trapezoid(dsxx_dxdx, zi, axis=0, initial=0) + Szz = cumulative_trapezoid(integrand, zi, axis=0, initial=0) + Szz += cumulative_trapezoid(-qn, zi, initial=0)[:, None] + + # Return shear stress txz in specified unit + return convert[unit] * Szz + + @track_analyzer_call + def principal_stress_slab( + self, + Z, + phi: float, + dz: float = 2, + unit: Literal["kPa", "MPa"] = "kPa", + val: Literal["min", "max"] = "max", + normalize: bool = False, + ): + """ + Compute maximum or minimum principal stress in slab layers. + + Arguments + --------- + Z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + dz : float, optional + Element size along z-axis (mm). Default is 2 mm. + unit : {'kPa', 'MPa'}, optional + Desired output unit. Default is 'kPa'. + val : str, optional + Maximum 'max' or minimum 'min' principal stress. Default is 'max'. + normalize : bool + Toggle layerwise normalization to strength. + + Returns + ------- + ndarray + Maximum or minimum principal stress in specified unit. + + Raises + ------ + ValueError + If specified principal stress component is neither 'max' nor + 'min', or if normalization of compressive principal stress + is requested. + """ + # Raise error if specified component is not available + if val not in ["min", "max"]: + raise ValueError(f"Component {val} not defined.") + + # Multiplier selection dict + m = {"max": 1, "min": -1} + + # Get axial normal stresses, shear stresses, transverse normal stresses + Sxx = self.Sxx(Z=Z, phi=phi, dz=dz, unit=unit) + Txz = self.Txz(Z=Z, phi=phi, dz=dz, unit=unit) + Szz = self.Szz(Z=Z, phi=phi, dz=dz, unit=unit) + + # Calculate principal stress + Ps = (Sxx + Szz) / 2 + m[val] * np.sqrt((Sxx - Szz) ** 2 + 4 * Txz**2) / 2 + + # Raise error if normalization of compressive stresses is attempted + if normalize and val == "min": + raise ValueError("Can only normalize tensile stresses.") + + # Normalize tensile stresses to tensile strength + if normalize and val == "max": + zmesh = self.get_zmesh(dz=dz) + tensile_strength = zmesh["tensile_strength"] + # Normalize maximum principal stress to layers' tensile strength + normalized_Ps = Ps / tensile_strength[:, None] + return normalized_Ps + + # Return absolute principal stresses + return Ps + + @track_analyzer_call + def principal_stress_weaklayer( + self, + Z, + sc: float = 2.6, + unit: Literal["kPa", "MPa"] = "kPa", + val: Literal["min", "max"] = "min", + normalize: bool = False, + ): + """ + Compute maximum or minimum principal stress in the weak layer. + + Arguments + --------- + Z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + sc : float + Weak-layer compressive strength. Default is 2.6 kPa. + unit : {'kPa', 'MPa'}, optional + Desired output unit. Default is 'kPa'. + val : str, optional + Maximum 'max' or minimum 'min' principal stress. Default is 'min'. + normalize : bool + Toggle layerwise normalization to strength. + + Returns + ------- + ndarray + Maximum or minimum principal stress in specified unit. + + Raises + ------ + ValueError + If specified principal stress component is neither 'max' nor + 'min', or if normalization of tensile principal stress + is requested. + """ + # Raise error if specified component is not available + if val not in ["min", "max"]: + raise ValueError(f"Component {val} not defined.") + + # Multiplier selection dict + m = {"max": 1, "min": -1} + + # Get weak-layer normal and shear stresses + sig = self.sm.fq.sig(Z, unit=unit) + tau = self.sm.fq.tau(Z, unit=unit) + + # Calculate principal stress + ps = sig / 2 + m[val] * np.sqrt(sig**2 + 4 * tau**2) / 2 + + # Raise error if normalization of tensile stresses is attempted + if normalize and val == "max": + raise ValueError("Can only normalize compressive stresses.") + + # Normalize compressive stresses to compressive strength + if normalize and val == "min": + return ps / sc + + # Return absolute principal stresses + return ps + + @track_analyzer_call + def incremental_ERR( + self, tolerance: float = 1e-6, unit: Literal["kJ/m^2", "J/m^2"] = "kJ/m^2" + ) -> np.ndarray: + """ + Compute incremental energy release rate (ERR) of all cracks. + + Returns + ------- + ndarray + List of total, mode I, and mode II energy release rates. + """ + li = self.sm.scenario.li + ki = self.sm.scenario.ki + k0 = np.ones_like(ki, dtype=bool) + C_uncracked = self.sm.uncracked_unknown_constants + C_cracked = self.sm.unknown_constants + phi = self.sm.scenario.phi + qs = self.sm.scenario.surface_load + + # Reduce inputs to segments with crack advance + iscrack = k0 & ~ki + C_uncracked, C_cracked, li = ( + C_uncracked[:, iscrack], + C_cracked[:, iscrack], + li[iscrack], + ) + + # Compute total crack lenght and initialize outputs + da = li.sum() if li.sum() > 0 else np.nan + Ginc1, Ginc2 = 0, 0 + + # Loop through segments with crack advance + for j, length in enumerate(li): + # Uncracked (0) and cracked (1) solutions at integration points + z_uncracked = partial( + self.sm.z, + C=C_uncracked[:, [j]], + length=length, + phi=phi, + has_foundation=True, + qs=qs, + ) + z_cracked = partial( + self.sm.z, + C=C_cracked[:, [j]], + length=length, + phi=phi, + has_foundation=False, + qs=qs, + ) + + # Mode I (1) and II (2) integrands at integration points + intGI = partial( + self._integrand_GI, z_uncracked=z_uncracked, z_cracked=z_cracked + ) + intGII = partial( + self._integrand_GII, z_uncracked=z_uncracked, z_cracked=z_cracked + ) + + # Segment contributions to total crack opening integral + Ginc1 += quad(intGI, 0, length, epsabs=tolerance, epsrel=tolerance)[0] / ( + 2 * da + ) + Ginc2 += quad(intGII, 0, length, epsabs=tolerance, epsrel=tolerance)[0] / ( + 2 * da + ) + + convert = {"kJ/m^2": 1, "J/m^2": 1e3} + return np.array([Ginc1 + Ginc2, Ginc1, Ginc2]).flatten() * convert[unit] + + @track_analyzer_call + def differential_ERR( + self, unit: Literal["kJ/m^2", "J/m^2"] = "kJ/m^2" + ) -> np.ndarray: + """ + Compute differential energy release rate of all crack tips. + + Returns + ------- + ndarray + List of total, mode I, and mode II energy release rates. + """ + li = self.sm.scenario.li + ki = self.sm.scenario.ki + C = self.sm.unknown_constants + phi = self.sm.scenario.phi + qs = self.sm.scenario.surface_load + + # Get number and indices of segment transitions + ntr = len(li) - 1 + itr = np.arange(ntr) + + # Identify supported-free and free-supported transitions as crack tips + iscracktip = [ki[j] != ki[j + 1] for j in range(ntr)] + + # Transition indices of crack tips and total number of crack tips + ict = itr[iscracktip] + nct = len(ict) + + # Initialize energy release rate array + Gdif = np.zeros([3, nct]) + + # Compute energy relase rate of all crack tips + for j, idx in enumerate(ict): + # Solution at crack tip + z = self.sm.z( + li[idx], C[:, [idx]], li[idx], phi, has_foundation=ki[idx], qs=qs + ) + # Mode I and II differential energy release rates + Gdif[1:, j] = np.concatenate( + (self.sm.fq.Gi(z, unit=unit), self.sm.fq.Gii(z, unit=unit)) + ) + + # Sum mode I and II contributions + Gdif[0, :] = Gdif[1, :] + Gdif[2, :] + + # Adjust contributions for center cracks + if nct > 1: + avgmask = np.full(nct, True) # Initialize mask + avgmask[[0, -1]] = ki[[0, -1]] # Do not weight edge cracks + Gdif[:, avgmask] *= 0.5 # Weigth with half crack length + + # Return total differential energy release rate of all crack tips + return Gdif.sum(axis=1) + + def _integrand_GI( + self, x: float | np.ndarray, z_uncracked, z_cracked + ) -> float | np.ndarray: + """ + Mode I integrand for energy release rate calculation. + """ + sig_uncracked = self.sm.fq.sig(z_uncracked(x)) + eps_cracked = self.sm.fq.eps(z_cracked(x)) + return sig_uncracked * eps_cracked * self.sm.weak_layer.h + + def _integrand_GII( + self, x: float | np.ndarray, z_uncracked, z_cracked + ) -> float | np.ndarray: + """ + Mode II integrand for energy release rate calculation. + """ + tau_uncracked = self.sm.fq.tau(z_uncracked(x)) + gamma_cracked = self.sm.fq.gamma(z_cracked(x)) + return tau_uncracked * gamma_cracked * self.sm.weak_layer.h + + @track_analyzer_call + def total_potential(self): + """ + Returns total differential potential. + Currently only implemented for PST systems. + + Returns + ------- + Pi : float + Total differential potential (Nmm). + """ + Pi_int = self._internal_potential() + Pi_ext = self._external_potential() + + return Pi_int + Pi_ext + + def _external_potential(self): + """ + Compute total external potential (pst only). + + Returns + ------- + Pi_ext : float + Total external potential [Nmm]. + """ + if self.sm.scenario.system_type not in ["pst-", "-pst"]: + logger.error("Input error: Only pst-setup implemented at the moment.") + raise NotImplementedError("Only pst-setup implemented at the moment.") + + # Rasterize solution + xq, zq, xb = self.rasterize_solution(mode="cracked", num=2000) + _ = xq, xb + # Compute displacements where weight loads are applied + w0 = self.sm.fq.w(zq) + us = self.sm.fq.u(zq, h0=self.sm.slab.z_cog) + # Get weight loads + qn = self.sm.scenario.qn + qt = self.sm.scenario.qt + # use +/- and us[0]/us[-1] according to system and phi + # compute total external potential + Pi_ext = ( + -qn * (self.sm.scenario.li[0] + self.sm.scenario.li[1]) * np.average(w0) + - qn + * (self.sm.scenario.L - (self.sm.scenario.li[0] + self.sm.scenario.li[1])) + * self.sm.scenario.crack_h + ) + # Ensure + ub = us[0] if self.sm.scenario.system_type in ["-pst"] else us[-1] + Pi_ext += ( + -qt * (self.sm.scenario.li[0] + self.sm.scenario.li[1]) * np.average(us) + - qt + * (self.sm.scenario.L - (self.sm.scenario.li[0] + self.sm.scenario.li[1])) + * ub + ) + + return Pi_ext + + def _internal_potential(self): + """ + Compute total internal potential (pst only). + + Returns + ------- + Pi_int : float + Total internal potential [Nmm]. + """ + if self.sm.scenario.system_type not in ["pst-", "-pst"]: + logger.error("Input error: Only pst-setup implemented at the moment.") + raise NotImplementedError("Only pst-setup implemented at the moment.") + + # Extract system parameters + L = self.sm.scenario.L + system_type = self.sm.scenario.system_type + A11 = self.sm.eigensystem.A11 + B11 = self.sm.eigensystem.B11 + D11 = self.sm.eigensystem.D11 + kA55 = self.sm.eigensystem.kA55 + kn = self.sm.weak_layer.kn + kt = self.sm.weak_layer.kt + + # Rasterize solution + xq, zq, xb = self.rasterize_solution(mode="cracked", num=2000) + + # Compute section forces + N, M, V = self.sm.fq.N(zq), self.sm.fq.M(zq), self.sm.fq.V(zq) + + # Drop parts of the solution that are not a foundation + zweak = zq[:, ~np.isnan(xb)] + xweak = xb[~np.isnan(xb)] + + # Compute weak layer displacements + wweak = self.sm.fq.w(zweak) + uweak = self.sm.fq.u(zweak, h0=self.sm.slab.H / 2) + + # Compute stored energy of the slab (monte-carlo integration) + n = len(xq) + nweak = len(xweak) + # energy share from moment, shear force, wl normal and tangential springs + Pi_int = ( + L / 2 / n / A11 * np.sum([Ni**2 for Ni in N]) + + L / 2 / n / (D11 - B11**2 / A11) * np.sum([Mi**2 for Mi in M]) + + L / 2 / n / kA55 * np.sum([Vi**2 for Vi in V]) + + L * kn / 2 / nweak * np.sum([wi**2 for wi in wweak]) + + L * kt / 2 / nweak * np.sum([ui**2 for ui in uweak]) + ) + # energy share from substitute rotation spring + if system_type in ["pst-"]: + Pi_int += 1 / 2 * M[-1] * (self.sm.fq.psi(zq)[-1]) ** 2 + elif system_type in ["-pst"]: + Pi_int += 1 / 2 * M[0] * (self.sm.fq.psi(zq)[0]) ** 2 + + return Pi_int diff --git a/weac/analysis/criteria_evaluator.py b/weac/analysis/criteria_evaluator.py new file mode 100644 index 0000000..cb44145 --- /dev/null +++ b/weac/analysis/criteria_evaluator.py @@ -0,0 +1,1169 @@ +""" +This module provides the CriteriaEvaluator class, which is used to evaluate various +fracture criteria based on the model results. +""" + +# Standard library imports +import copy +import logging +import time +import warnings +from dataclasses import dataclass +from typing import List, Optional, Union + +# Third party imports +import numpy as np +from scipy.optimize import brentq, root_scalar + +from weac.analysis.analyzer import Analyzer + +# weac imports +from weac.components import ( + CriteriaConfig, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.constants import RHO_ICE +from weac.core.system_model import SystemModel + +logger = logging.getLogger(__name__) + + +@dataclass +class CoupledCriterionHistory: + """Stores the history of the coupled criterion evaluation.""" + + skier_weights: List[float] + crack_lengths: List[float] + incr_energies: List[np.ndarray] + g_deltas: List[float] + dist_maxs: List[float] + dist_mins: List[float] + + +@dataclass +class CoupledCriterionResult: + """ + Holds the results of the coupled criterion evaluation. + + Attributes: + ----------- + converged : bool + Whether the algorithm converged. + message : str + The message of the evaluation. + self_collapse : bool + Whether the system collapsed. + pure_stress_criteria : bool + Whether the pure stress criteria is satisfied. + critical_skier_weight : float + The critical skier weight. + initial_critical_skier_weight : float + The initial critical skier weight. + crack_length : float + The crack length. + g_delta : float + The g_delta value. + dist_ERR_envelope : float + The distance to the ERR envelope. + iterations : int + The number of iterations. + history : CoupledCriterionHistory + The history of the evaluation. + final_system : SystemModel + The final system model. + max_dist_stress : float + The maximum distance to failure. + min_dist_stress : float + The minimum distance to failure. + """ + + converged: bool + message: str + self_collapse: bool + pure_stress_criteria: bool + critical_skier_weight: float + initial_critical_skier_weight: float + crack_length: float + g_delta: float + dist_ERR_envelope: float + iterations: int + history: Optional[CoupledCriterionHistory] + final_system: SystemModel + max_dist_stress: float + min_dist_stress: float + + +@dataclass +class SSERRResult: + """ + Holds the results of the SSERR evaluation. + + Attributes: + ----------- + converged : bool + Whether the algorithm converged. + message : str + The message of the evaluation. + touchdown_distance : float + The touchdown distance. + SSERR : float + The Steady-State Energy Release Rate calculated with the + touchdown distance from G_I and G_II. + """ + + converged: bool + message: str + touchdown_distance: float + SSERR: float + + +@dataclass +class FindMinimumForceResult: + """ + Holds the results of the find_minimum_force evaluation. + + Attributes: + ----------- + success : bool + Whether the algorithm converged. + critical_skier_weight : float + The critical skier weight. + new_segments : List[Segment] + The new segments. + old_segments : List[Segment] + The old segments. + iterations : int + The number of iterations. + max_dist_stress : float + The maximum distance to failure. + min_dist_stress : float + The minimum distance to failure. + """ + + success: bool + critical_skier_weight: float + new_segments: List[Segment] + old_segments: List[Segment] + iterations: Optional[int] + max_dist_stress: float + min_dist_stress: float + + +class CriteriaEvaluator: + """ + Provides methods for stability analysis of layered slabs on compliant + elastic foundations, based on the logic from criterion_check.py. + """ + + criteria_config: CriteriaConfig + + def __init__(self, criteria_config: CriteriaConfig): + """ + Initializes the evaluator with global simulation and criteria configurations. + + Parameters: + ---------- + criteria_config (CriteriaConfig): The configuration for failure criteria. + """ + self.criteria_config = criteria_config + + def fracture_toughness_envelope( + self, G_I: float | np.ndarray, G_II: float | np.ndarray, weak_layer: WeakLayer + ) -> float | np.ndarray: + """ + Evaluates the fracture toughness criterion for a given combination of + Mode I (G_I) and Mode II (G_II) energy release rates. + + The criterion is defined as: + g_delta = (|G_I| / G_Ic)^gn + (|G_II| / G_IIc)^gm + + A value of 1 indicates the boundary of the fracture toughness envelope is reached. + + Parameters: + ----------- + G_I : float + Mode I energy release rate (ERR) in J/mΒ². + G_II : float + Mode II energy release rate (ERR) in J/mΒ². + weak_layer : WeakLayer + The weak layer object containing G_Ic and G_IIc. + + Returns: + ------- + g_delta : float + Evaluation of the fracture toughness envelope. + """ + g_delta = (np.abs(G_I) / weak_layer.G_Ic) ** self.criteria_config.gn + ( + np.abs(G_II) / weak_layer.G_IIc + ) ** self.criteria_config.gm + + return g_delta + + def stress_envelope( + self, + sigma: Union[float, np.ndarray], + tau: Union[float, np.ndarray], + weak_layer: WeakLayer, + method: Optional[str] = None, + ) -> np.ndarray: + """ + Evaluate the stress envelope for given stress components. + Weak Layer failure is defined as the stress envelope crossing 1. + + Parameters + ---------- + sigma: ndarray + Normal stress components (kPa). + tau: ndarray + Shear stress components (kPa). + weak_layer: WeakLayer + The weak layer object, used to get density. + method: str, optional + Method to use for the stress envelope. Defaults to None. + + Returns + ------- + stress_envelope: ndarray + Stress envelope evaluation values in [0, inf]. + Values > 1 indicate failure. + + Notes + ----- + - Mede's envelopes ('mede_s-RG1', 'mede_s-RG2', 'mede_s-FCDH') are derived + from the work of Mede et al. (2018), "Snow Failure Modes Under Mixed + Loading," published in Geophysical Research Letters. + - SchΓΆttner's envelope ('schottner') is based on the preprint by SchΓΆttner + et al. (2025), "On the Compressive Strength of Weak Snow Layers of + Depth Hoar". + - The 'adam_unpublished' envelope scales with weak layer density linearly + (compared to density baseline) by a 'scaling_factor' + (weak layer density / density baseline), unless modified by + 'order_of_magnitude'. + - Mede's criteria ('mede_s-RG1', 'mede_s-RG2', 'mede_s-FCDH') define + failure based on a piecewise function of stress ranges. + """ + sigma = np.abs(np.asarray(sigma)) + tau = np.abs(np.asarray(tau)) + results = np.zeros_like(sigma) + + envelope_method = ( + method + if method is not None + else self.criteria_config.stress_envelope_method + ) + density = weak_layer.rho + sigma_c = weak_layer.sigma_c + tau_c = weak_layer.tau_c + fn = self.criteria_config.fn + fm = self.criteria_config.fm + order_of_magnitude = self.criteria_config.order_of_magnitude + scaling_factor = self.criteria_config.scaling_factor + + def mede_common_calculations(sigma, tau, p0, tau_T, p_T): + results_local = np.zeros_like(sigma) + in_first_range = (sigma >= (p_T - p0)) & (sigma <= p_T) + in_second_range = sigma > p_T + results_local[in_first_range] = ( + -tau[in_first_range] * (p0 / (tau_T * p_T)) + + sigma[in_first_range] * (1 / p_T) + + p0 / p_T + ) + results_local[in_second_range] = (tau[in_second_range] ** 2) + ( + (tau_T / p0) ** 2 + ) * ((sigma[in_second_range] - p_T) ** 2) + return results_local + + if envelope_method == "adam_unpublished": + if scaling_factor > 1: + order_of_magnitude = 0.7 + scaling_factor = max(scaling_factor, 0.55) + scaled_sigma_c = sigma_c * (scaling_factor**order_of_magnitude) + scaled_tau_c = tau_c * (scaling_factor**order_of_magnitude) + return (sigma / scaled_sigma_c) ** fn + (tau / scaled_tau_c) ** fm + + if envelope_method == "schottner": + sigma_y = 2000 + scaled_sigma_c = sigma_y * 13 * (density / RHO_ICE) ** order_of_magnitude + scaled_tau_c = tau_c * (scaled_sigma_c / sigma_c) + return (sigma / scaled_sigma_c) ** fn + (tau / scaled_tau_c) ** fm + + if envelope_method == "mede_s-RG1": + p0, tau_T, p_T = 7.00, 3.53, 1.49 + results = mede_common_calculations(sigma, tau, p0, tau_T, p_T) + return results + + if envelope_method == "mede_s-RG2": + p0, tau_T, p_T = 2.33, 1.22, 0.19 + results = mede_common_calculations(sigma, tau, p0, tau_T, p_T) + return results + + if envelope_method == "mede_s-FCDH": + p0, tau_T, p_T = 1.45, 0.61, 0.17 + results = mede_common_calculations(sigma, tau, p0, tau_T, p_T) + return results + + raise ValueError(f"Invalid envelope type: {envelope_method}") + + def evaluate_coupled_criterion( + self, + system: SystemModel, + max_iterations: int = 25, + damping_ERR: float = 0.0, + tolerance_ERR: float = 0.002, + tolerance_stress: float = 0.005, + print_call_stats: bool = False, + _recursion_depth: int = 0, + ) -> CoupledCriterionResult: + """ + Evaluates the coupled criterion for anticrack nucleation, finding the + critical combination of skier weight and anticrack length. + + Parameters: + ---------- + system: SystemModel + The system model. + max_iterations: int + Max iterations for the solver. Defaults to 25. + damping_ERR: float + damping factor for the ERR criterion. Defaults to 0.0. + tolerance_ERR: float, optional + Tolerance for g_delta convergence. Defaults to 0.002. + tolerance_stress: float, optional + Tolerance for stress envelope convergence. Defaults to 0.005. + print_call_stats: bool + Whether to print the call statistics. Defaults to False. + _recursion_depth: int + The depth of the recursion. Defaults to 0. + + Returns + ------- + results: CoupledCriterionResult + An object containing the results of the analysis, including + critical skier weight, crack length, and convergence details. + """ + logger.info("Starting coupled criterion evaluation.") + L = system.scenario.L + weak_layer = system.weak_layer + + logger.info("Finding minimum force...") + force_finding_start = time.time() + + force_result = self.find_minimum_force( + system, tolerance_stress=tolerance_stress, print_call_stats=print_call_stats + ) + initial_critical_skier_weight = force_result.critical_skier_weight + max_dist_stress = force_result.max_dist_stress + min_dist_stress = force_result.min_dist_stress + logger.info( + "Minimum force finding took %.4f seconds.", + time.time() - force_finding_start, + ) + + analyzer = Analyzer(system, printing_enabled=print_call_stats) + # --- Failure: in finding the critical skier weight --- + if not force_result.success: + logger.warning("No critical skier weight found") + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=False, + message="Failed to find critical skier weight.", + self_collapse=False, + pure_stress_criteria=False, + critical_skier_weight=0, + initial_critical_skier_weight=0, + crack_length=0, + g_delta=0, + dist_ERR_envelope=1, + iterations=0, + history=None, + final_system=system, + max_dist_stress=0, + min_dist_stress=0, + ) + + # --- Exception: the entire solution is cracked --- + if min_dist_stress > 1: + logger.info("The entire solution is cracked.") + # --- Larger scenario to calculate the incremental ERR --- + segments = copy.deepcopy(system.scenario.segments) + for segment in segments: + segment.has_foundation = False + # Add 50m of padding to the left and right of the system + segments.insert(0, Segment(length=50000, has_foundation=True, m=0)) + segments.append(Segment(length=50000, has_foundation=True, m=0)) + system.update_scenario(segments=segments) + + inc_energy = analyzer.incremental_ERR(unit="J/m^2") + g_delta = self.fracture_toughness_envelope( + inc_energy[1], inc_energy[2], system.weak_layer + ) + + history_data = CoupledCriterionHistory([], [], [], [], [], []) + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=True, + message="System fails under its own weight (self-collapse).", + self_collapse=True, + pure_stress_criteria=False, + critical_skier_weight=0, + initial_critical_skier_weight=initial_critical_skier_weight, + crack_length=L, + g_delta=g_delta, + dist_ERR_envelope=0, + iterations=0, + history=history_data, + final_system=system, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + + # --- Main loop --- + crack_length = 1.0 + dist_ERR_envelope = 1000 + g_delta = 0 + history = CoupledCriterionHistory([], [], [], [], [], []) + iteration_count = 0 + skier_weight = initial_critical_skier_weight * 1.005 + min_skier_weight = 1e-6 + max_skier_weight = 200 + + # Ensure Max Weight surpasses fracture toughness criterion + max_weight_g_delta = 0 + while max_weight_g_delta < 1: + max_skier_weight = max_skier_weight * 2 + + segments = [ + Segment(length=L / 2 - crack_length / 2, has_foundation=True, m=0), + Segment( + length=crack_length / 2, + has_foundation=False, + m=max_skier_weight, + ), + Segment(length=crack_length / 2, has_foundation=False, m=0), + Segment(length=L / 2 - crack_length / 2, has_foundation=True, m=0), + ] + + system.update_scenario(segments=segments) + + # Calculate fracture toughness criterion + incr_energy = analyzer.incremental_ERR(unit="J/m^2") + max_weight_g_delta = self.fracture_toughness_envelope( + incr_energy[1], incr_energy[2], weak_layer + ) + dist_ERR_envelope = abs(max_weight_g_delta - 1) + + logger.info("Max weight to look at: %.2f kg", max_skier_weight) + segments = [ + Segment( + length=L / 2 - crack_length / 2, + has_foundation=True, + m=0.0, + ), + Segment(length=crack_length / 2, has_foundation=False, m=skier_weight), + Segment(length=crack_length / 2, has_foundation=False, m=0), + Segment(length=L / 2 - crack_length / 2, has_foundation=True, m=0), + ] + + while ( + abs(dist_ERR_envelope) > tolerance_ERR + and iteration_count < max_iterations + and any(s.has_foundation for s in segments) + ): + iteration_count += 1 + iter_start_time = time.time() + logger.info( + "Starting iteration %d of coupled criterion evaluation.", + iteration_count, + ) + + system.update_scenario(segments=segments) + _, z, _ = analyzer.rasterize_solution(mode="uncracked", num=2000) + + # Calculate stress envelope + sigma_kPa = system.fq.sig(z, unit="kPa") + tau_kPa = system.fq.tau(z, unit="kPa") + stress_env = self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + max_dist_stress = np.max(stress_env) + min_dist_stress = np.min(stress_env) + + # Calculate fracture toughness criterion + incr_energy = analyzer.incremental_ERR(unit="J/m^2") + g_delta = self.fracture_toughness_envelope( + incr_energy[1], incr_energy[2], weak_layer + ) + dist_ERR_envelope = abs(g_delta - 1) + + # Update history + history.skier_weights.append(skier_weight) + history.crack_lengths.append(crack_length) + history.incr_energies.append(incr_energy) + history.g_deltas.append(g_delta) + history.dist_maxs.append(max_dist_stress) + history.dist_mins.append(min_dist_stress) + + # --- Exception: pure stress criterion --- + # The fracture toughness is superseded for minimum critical skier weight + if iteration_count == 1 and (g_delta > 1 or dist_ERR_envelope < 0.02): + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=True, + message="Fracture governed by pure stress criterion.", + self_collapse=False, + pure_stress_criteria=True, + critical_skier_weight=skier_weight, + initial_critical_skier_weight=initial_critical_skier_weight, + crack_length=crack_length, + g_delta=g_delta, + dist_ERR_envelope=dist_ERR_envelope, + iterations=iteration_count, + history=history, + final_system=system, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + + # Update skier weight boundaries + if g_delta < 1: + min_skier_weight = skier_weight + else: + max_skier_weight = skier_weight + + # Update skier weight + new_skier_weight = (min_skier_weight + max_skier_weight) / 2 + + # Apply damping to avoid oscillation around goal + if np.abs(dist_ERR_envelope) < 0.5 and damping_ERR > 0: + scaling = (damping_ERR + 1 + (new_skier_weight / skier_weight)) / ( + damping_ERR + 2 + ) + else: + scaling = 1 + + # Find new anticrack length + if abs(dist_ERR_envelope) > tolerance_ERR: + skier_weight = scaling * new_skier_weight + crack_length, segments = self.find_crack_length_for_weight( + system, skier_weight + ) + logger.info("New skier weight: %.2f kg", skier_weight) + logger.info( + "Iteration %d took %.4f seconds.", + iteration_count, + time.time() - iter_start_time, + ) + + if iteration_count < max_iterations and any(s.has_foundation for s in segments): + logger.info("No Exception encountered - Converged successfully.") + if crack_length > 0: + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=True, + message="No Exception encountered - Converged successfully.", + self_collapse=False, + pure_stress_criteria=False, + critical_skier_weight=skier_weight, + initial_critical_skier_weight=initial_critical_skier_weight, + crack_length=crack_length, + g_delta=g_delta, + dist_ERR_envelope=dist_ERR_envelope, + iterations=iteration_count, + history=history, + final_system=system, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + if _recursion_depth < 5: + logger.info("Reached max damping without converging.") + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return self.evaluate_coupled_criterion( + system, + damping_ERR=damping_ERR + 1, + tolerance_ERR=tolerance_ERR, + tolerance_stress=tolerance_stress, + _recursion_depth=_recursion_depth + 1, + ) + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=False, + message="Reached max damping without converging.", + self_collapse=False, + pure_stress_criteria=False, + critical_skier_weight=0, + initial_critical_skier_weight=initial_critical_skier_weight, + crack_length=crack_length, + g_delta=g_delta, + dist_ERR_envelope=dist_ERR_envelope, + iterations=iteration_count, + history=history, + final_system=system, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + if not any(s.has_foundation for s in segments): + analyzer.print_call_stats( + message="evaluate_coupled_criterion Call Statistics" + ) + return CoupledCriterionResult( + converged=False, + message="Reached max iterations without converging.", + self_collapse=False, + pure_stress_criteria=False, + critical_skier_weight=0, + initial_critical_skier_weight=initial_critical_skier_weight, + crack_length=0, + g_delta=0, + dist_ERR_envelope=1, + iterations=iteration_count, + history=history, + final_system=system, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + analyzer.print_call_stats(message="evaluate_coupled_criterion Call Statistics") + return self.evaluate_coupled_criterion( + system, + damping_ERR=damping_ERR + 1, + tolerance_ERR=tolerance_ERR, + tolerance_stress=tolerance_stress, + _recursion_depth=_recursion_depth + 1, + ) + + def evaluate_SSERR( + self, + system: SystemModel, + vertical: bool = False, + print_call_stats: bool = False, + ) -> SSERRResult: + """ + Evaluates the Touchdown Distance in the Steady State and the Steady State + Energy Release Rate. + + Parameters: + ----------- + system: SystemModel + The system model. + vertical: bool, optional + Whether to evaluate the system in a vertical configuration. + Defaults to False. + print_call_stats: bool, optional + Whether to print the call statistics. Defaults to False. + + IMPORTANT: There is a bug in vertical = True, so always slope normal, + i.e. vertical=False should be used. + """ + if vertical: + warnings.warn( + "vertical=True mode is currently buggy β€” results may be invalid. " + "Please set vertical=False until this is fixed.", + UserWarning, + ) + system_copy = copy.deepcopy(system) + segments = [ + Segment(length=5e3, has_foundation=True, m=0.0), + Segment(length=5e3, has_foundation=False, m=0.0), + ] + scenario_config = ScenarioConfig( + system_type="vpst-" if vertical else "pst-", + phi=system.scenario.phi, + cut_length=5e3, + ) + system_copy.config.touchdown = True + system_copy.update_scenario(segments=segments, scenario_config=scenario_config) + touchdown_distance = system_copy.slab_touchdown.touchdown_distance + analyzer = Analyzer(system_copy, printing_enabled=print_call_stats) + G, _, _ = analyzer.differential_ERR(unit="J/m^2") + return SSERRResult( + converged=True, + message="SSERR evaluation successful.", + touchdown_distance=touchdown_distance, + SSERR=G, + ) + + def find_minimum_force( + self, + system: SystemModel, + tolerance_stress: float = 0.0005, + print_call_stats: bool = False, + ) -> FindMinimumForceResult: + """ + Finds the minimum skier weight required to surpass the stress failure envelope. + + This method iteratively adjusts the skier weight until the maximum distance + to the stress envelope converges to 1, indicating the critical state. + + Parameters: + ----------- + system: SystemModel + The system model. + tolerance_stress: float, optional + Tolerance for the stress envelope. Defaults to 0.005. + print_call_stats: bool, optional + Whether to print the call statistics. Defaults to False. + + Returns: + -------- + results: FindMinimumForceResult + An object containing the results of the analysis, including + critical skier weight, and convergence details. + """ + logger.info("Start: Find Minimum force to surpass Stress Env.") + old_segments = copy.deepcopy(system.scenario.segments) + total_length = system.scenario.L + analyzer = Analyzer(system, printing_enabled=print_call_stats) + + # --- Initial uncracked configuration --- + segments = [ + Segment(length=total_length / 2, has_foundation=True, m=0.0), + Segment(length=total_length / 2, has_foundation=True, m=0.0), + ] + system.update_scenario(segments=segments) + _, z_skier, _ = analyzer.rasterize_solution(mode="uncracked", num=2000) + sigma_kPa = system.fq.sig(z_skier, unit="kPa") + tau_kPa = system.fq.tau(z_skier, unit="kPa") + max_dist_stress = np.max( + self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + ) + min_dist_stress = np.min( + self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + ) + + # --- Early Exit: entire domain is cracked --- + if min_dist_stress >= 1: + analyzer.print_call_stats( + message="min_dist_stress >= 1 in find_minimum_force Call Statistics" + ) + return FindMinimumForceResult( + success=True, + critical_skier_weight=0.0, + new_segments=segments, + old_segments=old_segments, + iterations=0, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + + def stress_envelope_residual(skier_weight: float, system: SystemModel) -> float: + logger.info("Eval. Stress Envelope for weight %.2f kg.", skier_weight) + segments = [ + Segment(length=total_length / 2, has_foundation=True, m=skier_weight), + Segment(length=total_length / 2, has_foundation=True, m=0.0), + ] + system.update_scenario(segments=segments) + _, z_skier, _ = analyzer.rasterize_solution(mode="cracked", num=2000) + sigma_kPa = system.fq.sig(z_skier, unit="kPa") + tau_kPa = system.fq.tau(z_skier, unit="kPa") + max_dist = np.max( + self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + ) + return max_dist - 1 + + # Now do root finding with brentq + def root_fn(weight): + return stress_envelope_residual(weight, system) + + # Search interval + w_min = 0.0 + w_max = 300.0 + while True: + try: + critical_weight = brentq(root_fn, w_min, w_max, xtol=tolerance_stress) + break + except ValueError as exc: + w_max = w_max * 2 + if w_max > 10000: + raise ValueError( + "No sign change found in [w_min, w_max]. Cannot use brentq." + ) from exc + + # Final evaluation + logger.info("Final evaluation for skier weight %.2f kg.", critical_weight) + system.update_scenario( + segments=[ + Segment( + length=total_length / 2, has_foundation=True, m=critical_weight + ), + Segment(length=total_length / 2, has_foundation=True, m=0.0), + ] + ) + _, z_skier, _ = analyzer.rasterize_solution(mode="cracked", num=2000) + sigma_kPa = system.fq.sig(z_skier, unit="kPa") + tau_kPa = system.fq.tau(z_skier, unit="kPa") + max_dist_stress = np.max( + self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + ) + min_dist_stress = np.min( + self.stress_envelope(sigma_kPa, tau_kPa, system.weak_layer) + ) + + analyzer.print_call_stats(message="find_minimum_force Call Statistics") + return FindMinimumForceResult( + success=True, + critical_skier_weight=critical_weight, + new_segments=copy.deepcopy(system.scenario.segments), + old_segments=old_segments, + iterations=None, + max_dist_stress=max_dist_stress, + min_dist_stress=min_dist_stress, + ) + + def find_minimum_crack_length( + self, + system: SystemModel, + search_interval: tuple[float, float] | None = None, + target: float = 1, + ) -> tuple[float, List[Segment]]: + """ + Finds the minimum crack length required to surpass the energy release rate envelope. + + Parameters: + ----------- + system: SystemModel + The system model. + + Returns: + -------- + minimum_crack_length: float + The minimum crack length required to surpass the energy release rate envelope [mm] + new_segments: List[Segment] + The updated list of segments + """ + old_segments = copy.deepcopy(system.scenario.segments) + + if search_interval is None: + a = 0 + b = system.scenario.L / 2 + else: + a, b = search_interval + logger.info("Interval for crack length search: %s, %s", a, b) + logger.info( + "Calculation of fracture toughness envelope: %s, %s", + self._fracture_toughness_exceedance(a, system), + self._fracture_toughness_exceedance(b, system), + ) + + # Use root_scalar to find the root + result = root_scalar( + self._fracture_toughness_exceedance, + args=(system, target), + bracket=[a, b], # Interval where the root is expected + method="brentq", # Brent's method + ) + + new_segments = system.scenario.segments + + system.update_scenario(segments=old_segments) + + if result.converged: + return result.root, new_segments + logger.error("Root search did not converge.") + return 0.0, new_segments + + def check_crack_self_propagation( + self, + system: SystemModel, + rm_skier_weight: bool = False, + ) -> tuple[float, bool]: + """ + Evaluates whether a crack will propagate without any additional load. + This method determines if a pre-existing crack will propagate without any + additional load. + + Parameters: + ---------- + system: SystemModel + + Returns + ------- + g_delta_diff: float + The evaluation of the fracture toughness envelope. + can_propagate: bool + True if the criterion is met (g_delta_diff >= 1). + """ + logger.info("Checking for self-propagation of pre-existing crack.") + new_system = copy.deepcopy(system) + logger.debug("Segments: %s", new_system.scenario.segments) + + start_time = time.time() + # No skier weight is applied for self-propagation check + if rm_skier_weight: + for seg in new_system.scenario.segments: + seg.m = 0 + new_system.update_scenario(segments=new_system.scenario.segments) + + analyzer = Analyzer(new_system) + diff_energy = analyzer.differential_ERR(unit="J/m^2") + G_I = diff_energy[1] + G_II = diff_energy[2] + + # Evaluate the fracture toughness criterion + g_delta_diff = self.fracture_toughness_envelope( + G_I, G_II, new_system.weak_layer + ) + can_propagate = g_delta_diff >= 1 + logger.info( + "Self-propagation check finished in %.4f seconds. Result: " + "g_delta_diff=%.4f, can_propagate=%s", + time.time() - start_time, + g_delta_diff, + can_propagate, + ) + + return g_delta_diff, bool(can_propagate) + + def find_crack_length_for_weight( + self, + system: SystemModel, + skier_weight: float, + ) -> tuple[float, List[Segment]]: + """ + Finds the resulting anticrack length and updated segment configurations + for a given skier weight. + + Parameters: + ----------- + system: SystemModel + The system model. + skier_weight: float + The weight of the skier [kg] + + Returns + ------- + new_crack_length: float + The total length of the new cracked segments [mm] + new_segments: List[Segment] + The updated list of segments + """ + logger.info( + "Finding new anticrack length for skier weight %.2f kg.", skier_weight + ) + start_time = time.time() + total_length = system.scenario.L + weak_layer = system.weak_layer + + old_segments = copy.deepcopy(system.scenario.segments) + + initial_segments = [ + Segment(length=total_length / 2, has_foundation=True, m=skier_weight), + Segment(length=total_length / 2, has_foundation=True, m=0), + ] + system.update_scenario(segments=initial_segments) + + analyzer = Analyzer(system) + _, z, _ = analyzer.rasterize_solution(mode="cracked", num=2000) + sigma_kPa = system.fq.sig(z, unit="kPa") + tau_kPa = system.fq.tau(z, unit="kPa") + min_dist_stress = np.min(self.stress_envelope(sigma_kPa, tau_kPa, weak_layer)) + + # Find all points where the stress envelope is crossed + crossings_start_time = time.time() + roots = self._find_stress_envelope_crossings(system, weak_layer) + logger.info( + "Finding stress envelope crossings took %.4f seconds.", + time.time() - crossings_start_time, + ) + + # --- Standard case: if roots exist --- + if len(roots) > 0: + # Reconstruct segments based on the roots + midpoint_load_application = total_length / 2 + segment_boundaries = sorted( + list(set([0] + roots + [midpoint_load_application] + [total_length])) + ) + new_segments = [] + + for i in range(len(segment_boundaries) - 1): + start = segment_boundaries[i] + end = segment_boundaries[i + 1] + midpoint = (start + end) / 2 + + # Check stress at the midpoint of the new potential segment + # to determine if it's cracked (has_foundation=False) + mid_sigma, mid_tau = self._calculate_sigma_tau_at_x(midpoint, system) + stress_check = self.stress_envelope( + np.array([mid_sigma]), np.array([mid_tau]), weak_layer + )[0] + + has_foundation = stress_check <= 1 + + # Re-apply the skier weight to the correct new segment + m = skier_weight if i == 1 else 0 + + new_segments.append( + Segment(length=end - start, has_foundation=has_foundation, m=m) + ) + + # Consolidate mass onto one segment if it was split + mass_segments = [s for s in new_segments if s.m > 0] + if len(mass_segments) > 1: + for s in mass_segments[1:]: + s.m = 0 + + new_crack_length = sum( + seg.length for seg in new_segments if not seg.has_foundation + ) + + logger.info( + "Finished finding new anticrack length in %.4f seconds. New length: %.2f mm.", + time.time() - start_time, + new_crack_length, + ) + + # --- Exception: the entire domain is cracked --- + elif min_dist_stress > 1: + # The entire domain is cracked + new_segments = [ + Segment(length=total_length / 2, has_foundation=False, m=skier_weight), + Segment(length=total_length / 2, has_foundation=False, m=0), + ] + new_crack_length = total_length + + elif not roots: + # No part of the slab is cracked + new_crack_length = 0 + new_segments = initial_segments + + system.update_scenario(segments=old_segments) + + return new_crack_length, new_segments + + def _calculate_sigma_tau_at_x( + self, x_value: float, system: SystemModel + ) -> tuple[float, float]: + """Calculate normal and shear stresses at a given horizontal x-coordinate.""" + # Get the segment index and coordinate within the segment + segment_index = system.scenario.get_segment_idx(x_value) + + start_of_segment = ( + system.scenario.cum_sum_li[segment_index - 1] if segment_index > 0 else 0 + ) + coordinate_in_segment = x_value - start_of_segment + + # Get the constants for the segment + C = system.unknown_constants[:, [segment_index]] + li_segment = system.scenario.li[segment_index] + phi = system.scenario.phi + has_foundation = system.scenario.ki[segment_index] + + # Calculate the displacement field + Z = system.z( + coordinate_in_segment, C, li_segment, phi, has_foundation=has_foundation + ) + + # Calculate the stresses + tau = -system.fq.tau(Z, unit="kPa") # Negated to match sign convention + sigma = system.fq.sig(Z, unit="kPa") + + return sigma, tau + + def _get_stress_envelope_exceedance( + self, x_value: float, system: SystemModel, weak_layer: WeakLayer + ) -> float: + """ + Objective function for the root finder. + Returns the stress envelope evaluation minus 1. + """ + sigma, tau = self._calculate_sigma_tau_at_x(x_value, system) + return ( + self.stress_envelope( + np.array([sigma]), np.array([tau]), weak_layer=weak_layer + )[0] + - 1 + ) + + def _find_stress_envelope_crossings( + self, system: SystemModel, weak_layer: WeakLayer + ) -> List[float]: + """ + Finds the exact x-coordinates where the stress envelope is crossed. + """ + logger.debug("Finding stress envelope crossings.") + start_time = time.time() + analyzer = Analyzer(system) + x_coords, z, _ = analyzer.rasterize_solution(mode="cracked", num=2000) + + sigma_kPa = system.fq.sig(z, unit="kPa") + tau_kPa = system.fq.tau(z, unit="kPa") + + # Calculate the discrete distance to failure + dist_to_stress_envelope = ( + self.stress_envelope(sigma_kPa, tau_kPa, weak_layer=weak_layer) - 1 + ) + + # Find indices where the envelope function transitions + transition_indices = np.where(np.diff(np.sign(dist_to_stress_envelope)))[0] + + # Find root candidates from transitions + root_candidates = [] + for idx in transition_indices: + x_left = x_coords[idx] + x_right = x_coords[idx + 1] + root_candidates.append((x_left, x_right)) + + # Search for roots within the identified candidates + roots = [] + logger.debug( + "Found %d potential crossing regions. Finding exact roots.", + len(root_candidates), + ) + roots_start_time = time.time() + for x_left, x_right in root_candidates: + try: + root_result = root_scalar( + self._get_stress_envelope_exceedance, + args=(system, weak_layer), + bracket=[x_left, x_right], + method="brentq", + ) + if root_result.converged: + roots.append(root_result.root) + except ValueError: + # This can happen if the signs at the bracket edges are not opposite. + # It's safe to ignore in this context. + pass + logger.debug("Root finding took %.4f seconds.", time.time() - roots_start_time) + logger.info( + "Found %d stress envelope crossings in %.4f seconds.", + len(roots), + time.time() - start_time, + ) + return roots + + def _fracture_toughness_exceedance( + self, crack_length: float, system: SystemModel, target: float = 1 + ) -> float: + """ + Objective function to evaluate the fracture toughness function. + """ + length = system.scenario.L + segments = [ + Segment(length=length / 2 - crack_length / 2, has_foundation=True, m=0), + Segment(length=crack_length / 2, has_foundation=False, m=0), + Segment(length=crack_length / 2, has_foundation=False, m=0), + Segment(length=length / 2 - crack_length / 2, has_foundation=True, m=0), + ] + system.update_scenario(segments=segments) + + analyzer = Analyzer(system) + diff_energy = analyzer.differential_ERR(unit="J/m^2") + G_I = diff_energy[1] + G_II = diff_energy[2] + + # Evaluate the fracture toughness function (boundary is equal to 1) + g_delta_diff = self.fracture_toughness_envelope(G_I, G_II, system.weak_layer) + + # Return the difference from the target + return g_delta_diff - target diff --git a/weac/analysis/plotter.py b/weac/analysis/plotter.py new file mode 100644 index 0000000..d086fb0 --- /dev/null +++ b/weac/analysis/plotter.py @@ -0,0 +1,1922 @@ +""" +This module provides plotting functions for visualizing the results of the WEAC model. +""" + +# Standard library imports +import colorsys +import logging +import os +from typing import List, Literal, Optional + +# Third party imports +import matplotlib.colors as mc +import matplotlib.pyplot as plt +import numpy as np +from matplotlib.figure import Figure +from matplotlib.patches import Patch, Polygon, Rectangle +from scipy.optimize import brentq + +from weac.analysis.analyzer import Analyzer +from weac.analysis.criteria_evaluator import ( + CoupledCriterionResult, + CriteriaEvaluator, + FindMinimumForceResult, +) + +# Module imports +from weac.components.layer import WeakLayer +from weac.core.scenario import Scenario +from weac.core.slab import Slab +from weac.core.system_model import SystemModel +from weac.utils.misc import isnotebook + +logger = logging.getLogger(__name__) + +LABELSTYLE = { + "backgroundcolor": "w", + "horizontalalignment": "center", + "verticalalignment": "center", +} + +COLORS = np.array( + [ # TUD color palette + ["#DCDCDC", "#B5B5B5", "#898989", "#535353"], # gray + ["#5D85C3", "#005AA9", "#004E8A", "#243572"], # blue + ["#009CDA", "#0083CC", "#00689D", "#004E73"], # ocean + ["#50B695", "#009D81", "#008877", "#00715E"], # teal + ["#AFCC50", "#99C000", "#7FAB16", "#6A8B22"], # green + ["#DDDF48", "#C9D400", "#B1BD00", "#99A604"], # lime + ["#FFE05C", "#FDCA00", "#D7AC00", "#AE8E00"], # yellow + ["#F8BA3C", "#F5A300", "#D28700", "#BE6F00"], # sand + ["#EE7A34", "#EC6500", "#CC4C03", "#A94913"], # orange + ["#E9503E", "#E6001A", "#B90F22", "#961C26"], # red + ["#C9308E", "#A60084", "#951169", "#732054"], # magenta + ["#804597", "#721085", "#611C73", "#4C226A"], # purple + ] +) + + +def _outline(grid): + """Extract _outline values of a 2D array (matrix, grid).""" + top = grid[0, :-1] + right = grid[:-1, -1] + bot = grid[-1, :0:-1] + left = grid[::-1, 0] + + return np.hstack([top, right, bot, left]) + + +def _significant_digits(decimal: float) -> int: + """Return the number of significant digits for a given decimal.""" + if decimal == 0: + return 1 + try: + sig_digits = -int(np.floor(np.log10(decimal))) + except ValueError: + sig_digits = 3 + return sig_digits + + +def _tight_central_distribution(limit, samples=100, tightness=1.5): + """ + Provide values within a given interval distributed tightly around 0. + + Parameters + ---------- + limit : float + Maximum and minimum of value range. + samples : int, optional + Number of values. Default is 100. + tightness : int, optional + Degree of value densification at center. 1.0 corresponds + to equal spacing. Default is 1.5. + + Returns + ------- + ndarray + Array of values more tightly spaced around 0. + """ + stop = limit ** (1 / tightness) + levels = np.linspace(0, stop, num=int(samples / 2), endpoint=True) ** tightness + return np.unique(np.hstack([-levels[::-1], levels])) + + +def _adjust_lightness(color, amount=0.5): + """ + Adjust color lightness. + + Arguments + ---------- + color : str or tuple + Matplotlib colorname, hex string, or RGB value tuple. + amount : float, optional + Amount of lightening: >1 lightens, <1 darkens. Default is 0.5. + + Returns + ------- + tuple + RGB color tuple. + """ + try: + c = mc.cnames[color] + except KeyError: + c = color + c = colorsys.rgb_to_hls(*mc.to_rgb(c)) + return colorsys.hls_to_rgb(c[0], max(0, min(1, amount * c[1])), c[2]) + + +class MidpointNormalize(mc.Normalize): + """Colormap normalization to a specified midpoint. Default is 0.""" + + def __init__(self, vmin, vmax, midpoint=0, clip=False): + """Initialize normalization.""" + self.midpoint = midpoint + mc.Normalize.__init__(self, vmin, vmax, clip) + + def __call__(self, value, clip=None): + """Apply normalization.""" + x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1] + return np.ma.masked_array(np.interp(value, x, y)) + + +class Plotter: + """ + Modern plotting class for WEAC simulations with support for multiple system comparisons. + + This class provides comprehensive visualization capabilities for weak layer anticrack + nucleation simulations, including single system analysis and multi-system comparisons. + + Features: + - Single and multi-system plotting + - System override functionality for selective plotting + - Comprehensive dashboard creation + - Modern matplotlib styling + - Jupyter notebook integration + - Automatic plot directory management + """ + + def __init__( + self, + plot_dir: str = "plots", + ): + """ + Initialize the plotter. + + Parameters + ---------- + system : SystemModel, optional + Single system model for analysis + systems : List[SystemModel], optional + List of system models for comparison + labels : List[str], optional + Labels for each system in plots + colors : List[str], optional + Colors for each system in plots + plot_dir : str, default "plots" + Directory to save plots + """ + self.labels = LABELSTYLE + self.colors = COLORS + + # Set up plot directory + self.plot_dir = plot_dir + os.makedirs(self.plot_dir, exist_ok=True) + + # Set up matplotlib style + self._setup_matplotlib_style() + + # Cache analyzers for performance + self._analyzers = {} + + def _setup_matplotlib_style(self): + """Set up modern matplotlib styling.""" + plt.style.use("default") + plt.rcParams.update( + { + "figure.figsize": (12, 8), + "figure.dpi": 100, + "savefig.dpi": 300, + "savefig.bbox": "tight", + "font.size": 11, + "axes.titlesize": 14, + "axes.labelsize": 12, + "xtick.labelsize": 10, + "ytick.labelsize": 10, + "legend.fontsize": 10, + "lines.linewidth": 2, + "axes.grid": True, + "grid.alpha": 0.3, + "axes.axisbelow": True, + } + ) + + def _get_analyzer(self, system: SystemModel) -> Analyzer: + """Get cached analyzer for a system.""" + system_id = id(system) + if system_id not in self._analyzers: + self._analyzers[system_id] = Analyzer(system_model=system) + return self._analyzers[system_id] + + def _get_systems_to_plot( + self, + system_model: Optional[SystemModel] = None, + system_models: Optional[List[SystemModel]] = None, + ) -> List[SystemModel]: + """Determine which systems to plot based on override parameters.""" + if system_model is not None and system_models is not None: + raise ValueError( + "Provide either 'system_model' or 'system_models', not both" + ) + if isinstance(system_model, SystemModel): + return [system_model] + if isinstance(system_models, list): + return system_models + raise ValueError( + "Must provide either 'system_model' or 'system_models' as a " + "SystemModel or list of SystemModels" + ) + + def _save_figure(self, filename: str, fig: Optional[Figure] = None): + """Save figure with proper formatting.""" + if fig is None: + fig = plt.gcf() + + filepath = os.path.join(self.plot_dir, f"{filename}.png") + fig.savefig(filepath, dpi=300, bbox_inches="tight", facecolor="white") + + if not isnotebook(): + plt.close(fig) + + def plot_slab_profile( + self, + weak_layers: List[WeakLayer] | WeakLayer, + slabs: List[Slab] | Slab, + filename: str = "slab_profile", + labels: Optional[List[str] | str] = None, + colors: Optional[List[str]] = None, + ): + """ + Plot slab layer profiles for comparison. + + Parameters + ---------- + weak_layers : List[WeakLayer] | WeakLayer + The weak layer or layers to plot. + slabs : List[Slab] | Slab + The slab or slabs to plot. + filename : str, optional + Filename for saving plot + labels : list of str, optional + Labels for each system. + colors : list of str, optional + Colors for each system. + + Returns + ------- + matplotlib.figure.Figure + The generated plot figure. + """ + if isinstance(weak_layers, WeakLayer): + weak_layers = [weak_layers] + if isinstance(slabs, Slab): + slabs = [slabs] + + if labels is None: + labels = [f"System {i + 1}" for i in range(len(weak_layers))] + elif isinstance(labels, str): + labels = [labels] * len(slabs) + elif len(labels) != len(slabs): + raise ValueError("Number of labels must match number of slabs") + + if colors is None: + plot_colors = [self.colors[i, 0] for i in range(len(slabs))] + else: + plot_colors = colors + + # Plot Setup + plt.rcdefaults() + plt.rc("font", family="serif", size=8) + plt.rc("mathtext", fontset="cm") + + fig = plt.figure(figsize=(8 / 3, 4)) + ax1 = fig.gca() + + # Plot 1: Layer thickness and density + max_height = 0 + for i, slab in enumerate(slabs): + total_height = slab.H + weak_layers[i].h + max_height = max(max_height, total_height) + + for i, (weak_layer, slab, label, color) in enumerate( + zip(weak_layers, slabs, labels, plot_colors) + ): + # Plot weak layer + wl_y = [-weak_layer.h, 0] + wl_x = [weak_layer.rho, weak_layer.rho] + ax1.fill_betweenx(wl_y, 0, wl_x, color="red", alpha=0.8, hatch="///") + + # Plot slab layers + x_coords = [] + y_coords = [] + current_height = 0 + + # As slab.layers is top-down + for layer in reversed(slab.layers): + x_coords.extend([layer.rho, layer.rho]) + y_coords.extend([current_height, current_height + layer.h]) + current_height += layer.h + + ax1.fill_betweenx( + y_coords, 0, x_coords, color=color, alpha=0.7, label=label + ) + + # Set axis labels + ax1.set_xlabel(r"$\longleftarrow$ Density $\rho$ (kg/m$^3$)") + ax1.set_ylabel(r"Height above weak layer (mm) $\longrightarrow$") + + ax1.set_title("Slab Density Profile") + + handles, slab_labels = ax1.get_legend_handles_labels() + weak_layer_patch = Patch( + facecolor="red", alpha=0.8, hatch="///", label="Weak Layer" + ) + ax1.legend( + handles=[weak_layer_patch] + handles, labels=["Weak Layer"] + slab_labels + ) + + ax1.grid(True, alpha=0.3) + ax1.set_xlim(500, 0) + ax1.set_ylim(-min(weak_layer.h for weak_layer in weak_layers), max_height) + + if filename: + self._save_figure(filename, fig) + + return fig + + def plot_rotated_slab_profile( + self, + weak_layer: WeakLayer, + slab: Slab, + angle: float = 0, + weight: float = 0, + slab_width: float = 200, + filename: str = "rotated_slab_profile", + title: str = "Rotated Slab Profile", + ): + """ + Plot a rectangular slab profile with layers stacked vertically, colored by density, + and rotated by the specified angle. + + Parameters + ---------- + weak_layer : WeakLayer + The weak layer to plot at the bottom. + slab : Slab + The slab with layers to plot. + angle : float, optional + Rotation angle in degrees. Default is 0. + slab_width : float, optional + Width of the slab rectangle in mm. Default is 200. + filename : str, optional + Filename for saving plot. Default is "rotated_slab_profile". + title : str, optional + Plot title. Default is "Rotated Slab Profile". + + Returns + ------- + matplotlib.figure.Figure + The generated plot figure. + """ + # Plot Setup + plt.rcdefaults() + plt.rc("font", family="serif", size=10) + plt.rc("mathtext", fontset="cm") + + fig = plt.figure(figsize=(8, 6), dpi=300) + ax = fig.gca() + + # Calculate total height + total_height = slab.H + weak_layer.h + + # Create density-based colormap + all_densities = [weak_layer.rho] + [layer.rho for layer in slab.layers] + min_density = min(all_densities) + max_density = max(all_densities) + + # Normalize densities for color mapping + norm = mc.Normalize(vmin=min_density, vmax=max_density) + cmap = plt.get_cmap("viridis") # You can change this to any colormap + + # Function to create sloped layer (parallelogram) + def create_sloped_layer(x, y, width, height, angle_rad): + """Create a layer that follows the slope angle""" + # Calculate horizontal offset for the slope + slope_offset = width * np.sin(angle_rad) + + # Create parallelogram corners + # Bottom edge is horizontal, top edge is shifted by slope_offset + corners = np.array( + [ + [x, y], # Bottom left + [x + width, y + slope_offset], # Bottom right + [x + width, y + height + slope_offset], # Top right (shifted) + [x, y + height], # Top left (shifted) + ] + ) + + return corners + + # Convert angle to radians + angle_rad = np.radians(angle) + + # Start from bottom (weak layer) + current_y = 0 + + # Plot weak layer + wl_corners = create_sloped_layer( + 0, current_y, slab_width, weak_layer.h, angle_rad + ) + wl_color = cmap(norm(weak_layer.rho)) + wl_patch = Polygon( + wl_corners, + facecolor=wl_color, + edgecolor="black", + linewidth=1, + alpha=0.8, + hatch="///", + ) + ax.add_patch(wl_patch) + + # Add density label for weak layer + wl_center = np.mean(wl_corners, axis=0) + ax.text( + wl_center[0], + wl_center[1], + f"{weak_layer.rho:.0f}\nkg/mΒ³", + ha="center", + va="center", + fontsize=8, + fontweight="bold", + ) + + current_y += weak_layer.h + + # Plot slab layers (from bottom to top) + top_layer_corners = None + for _i, layer in enumerate(reversed(slab.layers)): + layer_corners = create_sloped_layer( + 0, current_y, slab_width, layer.h, angle_rad + ) + layer_color = cmap(norm(layer.rho)) + layer_patch = Polygon( + layer_corners, + facecolor=layer_color, + edgecolor="black", + linewidth=1, + alpha=0.8, + ) + ax.add_patch(layer_patch) + + # Add density label for slab layer + layer_center = np.mean(layer_corners, axis=0) + ax.text( + layer_center[0], + layer_center[1], + f"{layer.rho:.0f}\nkg/mΒ³", + ha="center", + va="center", + fontsize=8, + fontweight="bold", + ) + + current_y += layer.h + # Keep track of the top layer corners for arrow placement + top_layer_corners = layer_corners + + # Add weight arrow if weight > 0 and we have layers + if weight > 0 and top_layer_corners is not None: + # Calculate midpoint of top edge of highest layer + # Top edge is between points 2 and 3 (top right and top left) + top_left = top_layer_corners[3] + top_right = top_layer_corners[2] + arrow_start_x = (top_left[0] + top_right[0]) / 2 + arrow_start_y = (top_left[1] + top_right[1]) / 2 + + # Scale arrow based on weight (0-400 maps to 0-100, above 400 = 100) + max_arrow_height = 100 + arrow_height = min(weight * max_arrow_height / 400, max_arrow_height) + arrow_width = arrow_height * 0.3 # Arrow width proportional to height + + # Create arrow pointing downward + arrow_tip_x = arrow_start_x + arrow_tip_y = arrow_start_y + + # Arrow shaft (rectangular part) + shaft_width = arrow_width * 0.3 + shaft_left = arrow_start_x - shaft_width / 2 + shaft_right = arrow_start_x + shaft_width / 2 + shaft_top = arrow_start_y + arrow_height + shaft_bottom = arrow_tip_y + arrow_width * 0.4 + + # Arrow head (triangular part) + head_left = arrow_start_x - arrow_width / 2 + head_right = arrow_start_x + arrow_width / 2 + head_top = shaft_bottom + + # Draw arrow shaft + shaft_corners = np.array( + [ + [shaft_left, shaft_top], + [shaft_right, shaft_top], + [shaft_right, shaft_bottom], + [shaft_left, shaft_bottom], + ] + ) + shaft_patch = Polygon( + shaft_corners, + facecolor="red", + edgecolor="darkred", + linewidth=2, + alpha=0.8, + ) + ax.add_patch(shaft_patch) + + # Draw arrow head + head_corners = np.array( + [ + [head_left, head_top], + [head_right, head_top], + [arrow_tip_x, arrow_tip_y], + ] + ) + head_patch = Polygon( + head_corners, + facecolor="red", + edgecolor="darkred", + linewidth=2, + alpha=0.8, + ) + ax.add_patch(head_patch) + + # Add weight label + ax.text( + arrow_start_x + arrow_width * 0.7, + arrow_start_y - arrow_height / 2, + f"{weight:.0f} kg", + ha="left", + va="center", + fontsize=10, + fontweight="bold", + color="darkred", + bbox={ + "boxstyle": "round,pad=0.3", + "facecolor": "white", + "alpha": 0.8, + }, + ) + + # Calculate plot limits to accommodate rotated rectangle + margin = max(slab_width, total_height) * 0.2 + + # Find the bounds of all rotated rectangles + all_corners = [] + current_y = 0 + + # Weak layer corners + wl_corners = create_sloped_layer( + 0, current_y, slab_width, weak_layer.h, angle_rad + ) + all_corners.extend(wl_corners) + current_y += weak_layer.h + + # Slab layer corners + for layer in reversed(slab.layers): + layer_corners = create_sloped_layer( + 0, current_y, slab_width, layer.h, angle_rad + ) + all_corners.extend(layer_corners) + current_y += layer.h + + all_corners = np.array(all_corners) + min_x, max_x = all_corners[:, 0].min(), all_corners[:, 0].max() + min_y, max_y = all_corners[:, 1].min(), all_corners[:, 1].max() + + # Set axis limits with margin + ax.set_xlim(min_x - margin, max_x + margin) + ax.set_ylim(min_y - margin, max_y + margin) + + # Set labels and title + ax.set_xlabel("Width (mm)") + ax.set_ylabel("Height (mm)") + ax.set_title(f"{title}\nSlope Angle: {angle}Β°") + + # Add colorbar + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + cbar = plt.colorbar(sm, ax=ax) + cbar.set_label("Density (kg/mΒ³)") + + # Add legend + weak_layer_patch = Patch( + facecolor=cmap(norm(weak_layer.rho)), + hatch="///", + edgecolor="black", + label="Weak Layer", + ) + slab_patch = Patch(facecolor="gray", edgecolor="black", label="Slab Layers") + ax.legend(handles=[weak_layer_patch, slab_patch], loc="upper right") + + # Equal aspect ratio and grid + ax.set_aspect("equal") + ax.grid(True, alpha=0.3) + + # Remove axis ticks for cleaner look + ax.tick_params(axis="both", which="major", labelsize=8) + + plt.tight_layout() + + if filename: + self._save_figure(filename, fig) + + return fig + + def plot_section_forces( + self, + system_model: Optional[SystemModel] = None, + system_models: Optional[List[SystemModel]] = None, + filename: str = "section_forces", + labels: Optional[List[str]] = None, + colors: Optional[List[str]] = None, + ): + """ + Plot section forces (N, M, V) for comparison. + + Parameters + ---------- + system_model : SystemModel, optional + Single system to plot (overrides default) + system_models : List[SystemModel], optional + Multiple systems to plot (overrides default) + filename : str, optional + Filename for saving plot + labels : list of str, optional + Labels for each system. + colors : list of str, optional + Colors for each system. + """ + systems_to_plot = self._get_systems_to_plot(system_model, system_models) + + if labels is None: + labels = [f"System {i + 1}" for i in range(len(systems_to_plot))] + if colors is None: + plot_colors = [self.colors[i, 0] for i in range(len(systems_to_plot))] + else: + plot_colors = colors + + fig, axes = plt.subplots(3, 1, figsize=(14, 12)) + + for i, system in enumerate(systems_to_plot): + analyzer = self._get_analyzer(system) + x, z, _ = analyzer.rasterize_solution() + fq = system.fq + + # Convert x to meters for plotting + x_m = x / 1000 + + # Plot axial force N + N = fq.N(z) + axes[0].plot(x_m, N, color=plot_colors[i], label=labels[i], linewidth=2) + + # Plot bending moment M + M = fq.M(z) + axes[1].plot(x_m, M, color=plot_colors[i], label=labels[i], linewidth=2) + + # Plot shear force V + V = fq.V(z) + axes[2].plot(x_m, V, color=plot_colors[i], label=labels[i], linewidth=2) + + # Formatting + axes[0].set_ylabel("N (N)") + axes[0].set_title("Axial Force") + axes[0].legend() + axes[0].grid(True, alpha=0.3) + + axes[1].set_ylabel("M (Nmm)") + axes[1].set_title("Bending Moment") + axes[1].legend() + axes[1].grid(True, alpha=0.3) + + axes[2].set_xlabel("Distance (m)") + axes[2].set_ylabel("V (N)") + axes[2].set_title("Shear Force") + axes[2].legend() + axes[2].grid(True, alpha=0.3) + + plt.tight_layout() + + if filename: + self._save_figure(filename, fig) + + return fig + + def plot_energy_release_rates( + self, + system_model: Optional[SystemModel] = None, + system_models: Optional[List[SystemModel]] = None, + filename: str = "ERR", + labels: Optional[List[str]] = None, + colors: Optional[List[str]] = None, + ): + """ + Plot energy release rates (G_I, G_II) for comparison. + + Parameters + ---------- + system_model : SystemModel, optional + Single system to plot (overrides default) + system_models : List[SystemModel], optional + Multiple systems to plot (overrides default) + filename : str, optional + Filename for saving plot + labels : list of str, optional + Labels for each system. + colors : list of str, optional + Colors for each system. + """ + systems_to_plot = self._get_systems_to_plot(system_model, system_models) + + if labels is None: + labels = [f"System {i + 1}" for i in range(len(systems_to_plot))] + if colors is None: + plot_colors = [self.colors[i, 0] for i in range(len(systems_to_plot))] + else: + plot_colors = colors + + fig, axes = plt.subplots(2, 1, figsize=(14, 10)) + + for i, system in enumerate(systems_to_plot): + analyzer = self._get_analyzer(system) + x, z, _ = analyzer.rasterize_solution() + fq = system.fq + + # Convert x to meters for plotting + x_m = x / 1000 + + # Plot Mode I energy release rate + G_I = fq.Gi(z, unit="kJ/m^2") + axes[0].plot(x_m, G_I, color=plot_colors[i], label=labels[i], linewidth=2) + + # Plot Mode II energy release rate + G_II = fq.Gii(z, unit="kJ/m^2") + axes[1].plot(x_m, G_II, color=plot_colors[i], label=labels[i], linewidth=2) + + # Formatting + axes[0].set_ylabel("G_I (kJ/mΒ²)") + axes[0].set_title("Mode I Energy Release Rate") + axes[0].legend() + axes[0].grid(True, alpha=0.3) + + axes[1].set_xlabel("Distance (m)") + axes[1].set_ylabel("G_II (kJ/mΒ²)") + axes[1].set_title("Mode II Energy Release Rate") + axes[1].legend() + axes[1].grid(True, alpha=0.3) + + plt.tight_layout() + + if filename: + self._save_figure(filename, fig) + + return fig + + def plot_deformed( + self, + xsl: np.ndarray, + xwl: np.ndarray, + z: np.ndarray, + analyzer: Analyzer, + dz: int = 2, + scale: int = 100, + window: float = np.inf, + pad: int = 2, + levels: int = 300, + aspect: int = 2, + field: Literal["w", "u", "principal", "Sxx", "Txz", "Szz"] = "w", + normalize: bool = True, + filename: str = "deformed_slab", + ) -> Figure: + """ + Plot deformed slab with field contours. + + Parameters + ---------- + xsl : np.ndarray + Slab x-coordinates. + xwl : np.ndarray + Weak layer x-coordinates. + z : np.ndarray + Solution vector. + analyzer : Analyzer + Analyzer instance. + dz : int, optional + Element size along z-axis (mm). Default is 2 mm. + scale : int, optional + Deformation scale factor. Default is 100. + window : float, optional + Plot window width. Default is inf. + pad : int, optional + Padding around plot. Default is 2. + levels : int, optional + Number of contour levels. Default is 300. + aspect : int, optional + Aspect ratio. Default is 2. + field : str, optional + Field to plot ('w', 'u', 'principal', 'Sxx', 'Txz', 'Szz'). Default is 'w'. + normalize : bool, optional + Toggle normalization. Default is True. + filename : str, optional + Filename for saving plot. Default is "deformed_slab". + + Returns + ------- + matplotlib.figure.Figure + The generated plot figure. + """ + fig = plt.figure(figsize=(10, 8)) + ax = fig.add_subplot(111) + + zi = analyzer.get_zmesh(dz=dz)["z"] + H = analyzer.sm.slab.H + phi = analyzer.sm.scenario.phi + system_type = analyzer.sm.scenario.system_type + fq = analyzer.sm.fq + + # Compute slab displacements on grid (cm) + Usl = np.vstack([fq.u(z, h0=h0, unit="cm") for h0 in zi]) + Wsl = np.vstack([fq.w(z, unit="cm") for _ in zi]) + Sigmawl = np.where(np.isfinite(xwl), fq.sig(z, unit="kPa"), np.nan) + Tauwl = np.where(np.isfinite(xwl), fq.tau(z, unit="kPa"), np.nan) + + # Put coordinate origin at horizontal center + if system_type in ["skier", "skiers"]: + xsl = xsl - max(xsl) / 2 + xwl = xwl - max(xwl) / 2 + + # Compute slab grid coordinates with vertical origin at top surface (cm) + Xsl, Zsl = np.meshgrid(1e-1 * (xsl), 1e-1 * (zi + H / 2)) + + # Get x-coordinate of maximum deflection w (cm) and derive plot limits + xfocus = xsl[np.max(np.argmax(Wsl, axis=1))] / 10 + xmax = np.min([np.max([Xsl, Xsl + scale * Usl]) + pad, xfocus + window / 2]) + xmin = np.max([np.min([Xsl, Xsl + scale * Usl]) - pad, xfocus - window / 2]) + + # Scale shown weak-layer thickness with to max deflection and add padding + if analyzer.sm.config.touchdown: + zmax = ( + np.max(Zsl) + + (analyzer.sm.weak_layer.h * 1e-1 * scale) + - (analyzer.sm.scenario.crack_h * 1e-1 * scale) + ) + zmax = min(zmax, np.max(Zsl + scale * Wsl)) + else: + zmax = np.max(Zsl + scale * Wsl) + pad + zmin = np.min(Zsl) - pad + + # Compute weak-layer grid coordinates (cm) + Xwl, Zwl = np.meshgrid(1e-1 * xwl, [1e-1 * (zi[-1] + H / 2), zmax]) + + # Assemble weak-layer displacement field (top and bottom) + Uwl = np.vstack([Usl[-1, :], np.zeros(xwl.shape[0])]) + Wwl = np.vstack([Wsl[-1, :], np.zeros(xwl.shape[0])]) + + # Compute stress or displacement fields + match field: + # Horizontal displacements (um) + case "u": + slab = 1e4 * Usl + weak = 1e4 * Usl[-1, :] + label = r"$u$ ($\mu$m)" + # Vertical deflection (um) + case "w": + slab = 1e4 * Wsl + weak = 1e4 * Wsl[-1, :] + label = r"$w$ ($\mu$m)" + # Axial normal stresses (kPa) + case "Sxx": + slab = analyzer.Sxx(z, phi, dz=dz, unit="kPa") + weak = np.zeros(xwl.shape[0]) + label = r"$\sigma_{xx}$ (kPa)" + # Shear stresses (kPa) + case "Txz": + slab = analyzer.Txz(z, phi, dz=dz, unit="kPa") + weak = Tauwl + label = r"$\tau_{xz}$ (kPa)" + # Transverse normal stresses (kPa) + case "Szz": + slab = analyzer.Szz(z, phi, dz=dz, unit="kPa") + weak = Sigmawl + label = r"$\sigma_{zz}$ (kPa)" + # Principal stresses + case "principal": + slab = analyzer.principal_stress_slab( + z, phi, dz=dz, val="max", unit="kPa", normalize=normalize + ) + weak = analyzer.principal_stress_weaklayer( + z, val="min", unit="kPa", normalize=normalize + ) + if normalize: + label = ( + r"$\sigma_\mathrm{I}/\sigma_+$ (slab), " + r"$\sigma_\mathrm{I\!I\!I}/\sigma_-$ (weak layer)" + ) + else: + label = ( + r"$\sigma_\mathrm{I}$ (kPa, slab), " + r"$\sigma_\mathrm{I\!I\!I}$ (kPa, weak layer)" + ) + case _: + raise ValueError( + f"Invalid input '{field}' for field. Valid options are " + "'u', 'w', 'Sxx', 'Txz', 'Szz', or 'principal'" + ) + + # Complement label + label += r" $\longrightarrow$" + + # Assemble weak-layer output on grid + weak = np.vstack([weak, weak]) + + # Normalize colormap + absmax = np.nanmax(np.abs([slab.min(), slab.max(), weak.min(), weak.max()])) + clim = np.round(absmax, _significant_digits(absmax)) + levels = np.linspace(-clim, clim, num=levels + 1, endpoint=True) + # nanmax = np.nanmax([slab.max(), weak.max()]) + # nanmin = np.nanmin([slab.min(), weak.min()]) + # norm = MidpointNormalize(vmin=nanmin, vmax=nanmax) + + # Plot baseline + ax.axhline(zmax, color="k", linewidth=1) + + # Plot outlines of the undeformed and deformed slab + ax.plot(_outline(Xsl), _outline(Zsl), "k--", alpha=0.3, linewidth=1) + ax.plot( + _outline(Xsl + scale * Usl), _outline(Zsl + scale * Wsl), "k", linewidth=1 + ) + + # Plot deformed weak-layer _outline + if system_type in ["-pst", "pst-", "-vpst", "vpst-"]: + nanmask = np.isfinite(xwl) + ax.plot( + _outline(Xwl[:, nanmask] + scale * Uwl[:, nanmask]), + _outline(Zwl[:, nanmask] + scale * Wwl[:, nanmask]), + "k", + linewidth=1, + ) + + cmap = plt.get_cmap("RdBu_r") + cmap.set_over(_adjust_lightness(cmap(1.0), 0.9)) + cmap.set_under(_adjust_lightness(cmap(0.0), 0.9)) + + # Plot fields + ax.contourf( + Xsl + scale * Usl, + Zsl + scale * Wsl, + slab, + levels=levels, + cmap=cmap, + extend="both", + ) + ax.contourf( + Xwl + scale * Uwl, + Zwl + scale * Wwl, + weak, + levels=levels, + cmap=cmap, + extend="both", + ) + + # Plot setup + ax.axis("scaled") + ax.set_xlim([xmin, xmax]) + ax.set_ylim([zmin, zmax]) + ax.set_aspect(aspect) + ax.invert_yaxis() + ax.use_sticky_edges = False + + # Plot labels + ax.set_xlabel(r"lateral position $x$ (cm) $\longrightarrow$") + ax.set_ylabel("depth below surface\n" + r"$\longleftarrow $ $d$ (cm)") + ax.set_title(rf"${scale}\!\times\!$ scaled deformations (cm)", size=10) + + # Show colorbar + ticks = np.linspace(levels[0], levels[-1], num=11, endpoint=True) + fig.colorbar( + ax.contourf( + Xsl + scale * Usl, + Zsl + scale * Wsl, + slab, + levels=levels, + cmap=cmap, + extend="both", + ), + orientation="horizontal", + ticks=ticks, + label=label, + aspect=35, + ) + + # Save figure + self._save_figure(filename, fig) + + return fig + + def plot_stress_envelope( + self, + system_model: SystemModel, + criteria_evaluator: CriteriaEvaluator, + all_envelopes: bool = False, + filename: Optional[str] = None, + ): + """ + Plot stress envelope in Ο„-Οƒ space. + + Parameters + ---------- + system_model : SystemModel + System to plot + criteria_evaluator : CriteriaEvaluator + Criteria evaluator to use for the stress envelope + all_envelopes : bool, optional + Whether to plot all four quadrants of the envelope + filename : str, optional + Filename for saving plot + """ + analyzer = self._get_analyzer(system_model) + _, z, _ = analyzer.rasterize_solution(num=10000) + fq = system_model.fq + + # Calculate stresses + sigma = np.abs(fq.sig(z, unit="kPa")) + tau = fq.tau(z, unit="kPa") + + fig, ax = plt.subplots(figsize=(4, 8 / 3)) + + # Plot stress path + ax.plot(sigma, tau, "b-", linewidth=2, label="Stress Path") + ax.scatter( + sigma[0], tau[0], color="green", s=10, marker="o", label="Start", zorder=5 + ) + ax.scatter( + sigma[-1], tau[-1], color="red", s=10, marker="s", label="End", zorder=5 + ) + + # --- Programmatic Envelope Calculation --- + weak_layer = system_model.weak_layer + + # Define a function to find the root for a given tau + def find_sigma_for_tau(tau_val, sigma_c, method: Optional[str] = None): + # Target function to find the root of: envelope(sigma, tau) - 1 = 0 + def envelope_root_func(sigma_val): + return ( + criteria_evaluator.stress_envelope( + sigma_val, tau_val, weak_layer, method=method + ) + - 1 + ) + + try: + search_upper_bound = sigma_c * 1.1 + sigma_root = brentq( + envelope_root_func, + a=0, + b=search_upper_bound, + xtol=1e-6, + rtol=1e-6, + ) + return sigma_root + except ValueError: + return np.nan + + # Calculate the corresponding sigma for each tau + if all_envelopes: + methods = [ + "mede_s-RG1", + "mede_s-RG2", + "mede_s-FCDH", + "schottner", + "adam_unpublished", + ] + else: + methods = [criteria_evaluator.criteria_config.stress_envelope_method] + + colors = self.colors + colors = np.array(colors) + colors = np.tile(colors, (len(methods), 1)) + + max_sigma = 0 + max_tau = 0 + for i, method in enumerate(methods): + # Calculate tau_c for the given method to define tau_range + config = criteria_evaluator.criteria_config + density = weak_layer.rho + tau_c = 0.0 # fallback + sigma_c = 0.0 + if method == "adam_unpublished": + scaling_factor = config.scaling_factor + order_of_magnitude = config.order_of_magnitude + if scaling_factor > 1: + order_of_magnitude = 0.7 + scaling_factor = max(scaling_factor, 0.55) + + tau_c = 5.09 * (scaling_factor**order_of_magnitude) + sigma_c = 6.16 * (scaling_factor**order_of_magnitude) + elif method == "schottner": + rho_ice = 916.7 + sigma_y = 2000 + sigma_c_adam = 6.16 + tau_c_adam = 5.09 + order_of_magnitude = config.order_of_magnitude + sigma_c = sigma_y * 13 * (density / rho_ice) ** order_of_magnitude + tau_c = tau_c_adam * (sigma_c / sigma_c_adam) + sigma_c = sigma_y * 13 * (density / rho_ice) ** order_of_magnitude + elif method == "mede_s-RG1": + tau_c = 3.53 # This is tau_T from Mede's paper + sigma_c = 7.00 + elif method == "mede_s-RG2": + tau_c = 1.22 # This is tau_T from Mede's paper + sigma_c = 2.33 + elif method == "mede_s-FCDH": + tau_c = 0.61 # This is tau_T from Mede's paper + sigma_c = 1.49 + + tau_range = np.linspace(0, tau_c, 100) + sigma_envelope = np.array( + [find_sigma_for_tau(t, sigma_c, method) for t in tau_range] + ) + + # Remove nan values where no root was found + valid_points = ~np.isnan(sigma_envelope) + valid_tau_range = tau_range[valid_points] + sigma_envelope = sigma_envelope[valid_points] + + max_sigma = max(max_sigma, np.max(sigma_envelope)) + max_tau = max(max_tau, np.max(np.abs(valid_tau_range))) + ax.plot( + sigma_envelope, + valid_tau_range, + "--", + linewidth=2, + label=method, + color=colors[i, 0], + ) + ax.plot( + -sigma_envelope, valid_tau_range, "--", linewidth=2, color=colors[i, 0] + ) + ax.plot( + -sigma_envelope, + -valid_tau_range, + "--", + linewidth=2, + color=colors[i, 0], + ) + ax.plot( + sigma_envelope, -valid_tau_range, "--", linewidth=2, color=colors[i, 0] + ) + ax.scatter(0, tau_c, color="black", s=10, marker="o") + ax.text(0, tau_c, r"$\tau_c$", color="black", ha="center", va="bottom") + ax.scatter(sigma_c, 0, color="black", s=10, marker="o") + ax.text(sigma_c, 0, r"$\sigma_c$", color="black", ha="left", va="center") + + # Formatting + ax.set_xlabel("Compressive Strength Οƒ (kPa)") + ax.set_ylabel("Shear Strength Ο„ (kPa)") + ax.set_title("Weak Layer Stress Envelope") + ax.legend() + ax.grid(True, alpha=0.3) + ax.axhline(y=0, color="k", linewidth=0.5) + ax.axvline(x=0, color="k", linewidth=0.5) + + max_tau = max(max_tau, float(np.max(np.abs(tau)))) + max_sigma = max(max_sigma, float(np.max(np.abs(sigma)))) + ax.set_xlim(0, max_sigma * 1.1) + ax.set_ylim(-max_tau * 1.1, max_tau * 1.1) + + plt.tight_layout() + + if filename: + self._save_figure(filename, fig) + + return fig + + def plot_err_envelope( + self, + system_model: SystemModel, + criteria_evaluator: CriteriaEvaluator, + filename: str = "err_envelope", + ) -> Figure: + """Plot the ERR envelope.""" + analyzer = self._get_analyzer(system_model) + + incr_energy = analyzer.incremental_ERR(unit="J/m^2") + G_I = incr_energy[1] + G_II = incr_energy[2] + + fig, ax = plt.subplots(figsize=(4, 8 / 3)) + + # Plot stress path + ax.scatter( + np.abs(G_I), + np.abs(G_II), + color="blue", + s=50, + marker="o", + label="Incremental ERR", + zorder=5, + ) + + G_Ic = system_model.weak_layer.G_Ic + G_IIc = system_model.weak_layer.G_IIc + ax.scatter(0, G_IIc, color="black", s=100, marker="o", zorder=5) + ax.text( + 0.01, + G_IIc + 0.02, + r"$G_{IIc}$", + color="black", + ha="left", + va="center", + ) + ax.scatter(G_Ic, 0, color="black", s=100, marker="o", zorder=5) + ax.text( + G_Ic + 0.01, + 0.01, + r"$G_{Ic}$", + color="black", + ) + + # --- Programmatic Envelope Calculation --- + weak_layer = system_model.weak_layer + + # Define a function to find the root for a given G_II + def find_GI_for_GII(GII_val): + # Target function to find the root of: envelope(sigma, tau) - 1 = 0 + def envelope_root_func(GI_val): + return ( + criteria_evaluator.fracture_toughness_envelope( + GI_val, + GII_val, + weak_layer, + ) + - 1 + ) + + try: + GI_root = brentq(envelope_root_func, a=0, b=50, xtol=1e-6, rtol=1e-6) + return GI_root + except ValueError: + return np.nan + + # Generate a range of G values in the positive quadrant + GII_max = system_model.weak_layer.G_IIc * 1.1 + GII_range = np.linspace(0, GII_max, 100) + + GI_envelope = np.array([find_GI_for_GII(t) for t in GII_range]) + + # Remove nan values where no root was found + valid_points = ~np.isnan(GI_envelope) + valid_GII_range = GII_range[valid_points] + GI_envelope = GI_envelope[valid_points] + + ax.plot( + GI_envelope, + valid_GII_range, + "--", + linewidth=2, + label="Fracture Toughness Envelope", + color="red", + ) + + # Formatting + ax.set_xlabel("GI (J/mΒ²)") + ax.set_ylabel("GII (J/mΒ²)") + ax.set_title("Fracture Toughness Envelope") + ax.legend() + ax.grid(True, alpha=0.3) + ax.axhline(y=0, color="k", linewidth=0.5) + ax.axvline(x=0, color="k", linewidth=0.5) + ax.set_xlim(0, max(np.abs(GI_envelope)) * 1.1) + ax.set_ylim(0, max(np.abs(valid_GII_range)) * 1.1) + + plt.tight_layout() + + self._save_figure(filename, fig) + + return fig + + def plot_analysis( + self, + system: SystemModel, + criteria_evaluator: CriteriaEvaluator, + min_force_result: FindMinimumForceResult, + min_crack_length: float, + coupled_criterion_result: CoupledCriterionResult, + dz: int = 2, + deformation_scale: float = 100.0, + window: int = np.inf, + levels: int = 300, + filename: str = "analysis", + ) -> Figure: + """ + Plot deformed slab with field contours. + + Parameters + ---------- + field : str, default 'w' + Field to plot ('w', 'u', 'principal', 'sigma', 'tau') + system_model : SystemModel, optional + System to plot (uses first system if not specified) + filename : str, optional + Filename for saving plot + """ + fig = plt.figure(figsize=(12, 10)) + ax = fig.add_subplot(111) + + logger.debug("System Segments: %s", system.scenario.segments) + analyzer = Analyzer(system) + xsl, z, xwl = analyzer.rasterize_solution(mode="cracked", num=200) + + zi = analyzer.get_zmesh(dz=dz)["z"] + H = analyzer.sm.slab.H + h = system.weak_layer.h + system_type = analyzer.sm.scenario.system_type + fq = analyzer.sm.fq + + # Generate a window size which fits the plots + window = min(window, np.max(xwl) - np.min(xwl), 10000) + + # Calculate scaling factors for proper aspect ratio and relative heights + # 7:1 aspect ratio: vertical extent = window / 7 + total_vertical_extent = window / 7.0 + + # Slab should appear 2x taller than weak layer + # So slab gets 2/3 of vertical space, weak layer gets 1/3 + slab_display_height = (2 / 3) * total_vertical_extent + weak_layer_display_height = (1 / 3) * total_vertical_extent + + # Calculate separate scaling factors for coordinates + slab_z_scale = slab_display_height / H + weak_layer_z_scale = weak_layer_display_height / h + + # Deformation scaling (separate from coordinate scaling) + scale = deformation_scale + + # Compute slab displacements on grid (cm) + Usl = np.vstack([fq.u(z, h0=h0, unit="cm") for h0 in zi]) + Wsl = np.vstack([fq.w(z, unit="cm") for _ in zi]) + Sigmawl = np.where(np.isfinite(xwl), fq.sig(z, unit="kPa"), np.nan) + Tauwl = np.where(np.isfinite(xwl), fq.tau(z, unit="kPa"), np.nan) + + # Put coordinate origin at horizontal center + if system_type in ["skier", "skiers"]: + xsl = xsl - max(xsl) / 2 + xwl = xwl - max(xwl) / 2 + + # Compute slab grid coordinates with vertical origin at top surface (cm) + Xsl, Zsl = np.meshgrid(1e-1 * (xsl), 1e-1 * slab_z_scale * (zi - H / 2)) + + # Get x-coordinate of maximum deflection w (cm) and derive plot limits + xmax = np.min([np.max([Xsl, Xsl + scale * Usl]), 1e-1 * window / 2]) + xmin = np.max([np.min([Xsl, Xsl + scale * Usl]), -1e-1 * window / 2]) + + # Compute weak-layer grid coordinates (cm) + # Position weak layer below the slab + Xwl, Zwl = np.meshgrid( + 1e-1 * xwl, + [ + 0, # Top of weak layer (at bottom of slab) + 1e-1 * weak_layer_z_scale * h, # Bottom of weak layer + ], + ) + + # Assemble weak-layer displacement field (top and bottom) + Uwl = np.vstack([Usl[-1, :], np.zeros(xwl.shape[0])]) + Wwl = np.vstack([Wsl[-1, :], np.zeros(xwl.shape[0])]) + + stress_envelope = criteria_evaluator.stress_envelope( + Sigmawl, Tauwl, system.weak_layer + ) + stress_envelope[np.isnan(stress_envelope)] = np.nanmax(stress_envelope) + + # Assemble weak-layer output on grid + weak = np.vstack([stress_envelope, stress_envelope]) + + # Normalize colormap + levels = np.linspace(0, 1, num=levels + 1, endpoint=True) + + # Plot outlines of the undeformed and deformed slab + ax.plot( + _outline(Xsl), + _outline(Zsl), + linestyle="--", + color="yellow", + alpha=0.3, + linewidth=1, + ) + ax.plot( + _outline(Xsl + scale * Usl), + _outline(Zsl + scale * Wsl), + color="blue", + linewidth=1, + ) + + # Plot deformed weak-layer _outline + nanmask = np.isfinite(xwl) + ax.plot( + _outline(Xwl[:, nanmask] + scale * Uwl[:, nanmask]), + _outline(Zwl[:, nanmask] + scale * Wwl[:, nanmask]), + "k", + linewidth=1, + ) + + cmap = plt.get_cmap("RdBu_r") + cmap.set_over(_adjust_lightness(cmap(1.0), 0.9)) + cmap.set_under(_adjust_lightness(cmap(0.0), 0.9)) + + ax.contourf( + Xwl + scale * Uwl, + Zwl + scale * Wwl, + weak, + levels=levels, + cmap=cmap, + extend="both", + ) + + # Plot setup + ax.axis("scaled") + ax.set_xlim([xmin, xmax]) + ax.invert_yaxis() + ax.use_sticky_edges = False + + # Set up custom y-axis ticks to show real scaled heights + # Calculate the actual extent of the plot + slab_top = 1e-1 * slab_z_scale * (zi[0] - H / 2) # Top of slab + slab_bottom = 1e-1 * slab_z_scale * (zi[-1] - H / 2) # Bottom of slab + weak_layer_bottom = 1e-1 * weak_layer_z_scale * h # Bottom of weak layer + + # Create tick positions and labels + y_ticks = [] + y_labels = [] + + # Slab ticks (show actual slab heights in mm) + num_slab_ticks = 5 + slab_tick_positions = np.linspace(slab_bottom, slab_top, num_slab_ticks) + slab_height_ticks = np.linspace( + 0, -H, num_slab_ticks + ) # Actual slab heights in mm + + for pos, height in zip(slab_tick_positions, slab_height_ticks): + y_ticks.append(pos) + y_labels.append(f"{height:.0f}") + + # Weak layer ticks (show actual weak layer heights in mm) + num_wl_ticks = 3 + wl_tick_positions = np.linspace(0, weak_layer_bottom, num_wl_ticks) + wl_height_ticks = np.linspace( + 0, h, num_wl_ticks + ) # Actual weak layer heights in mm + + for pos, height in zip(wl_tick_positions, wl_height_ticks): + y_ticks.append(pos) + y_labels.append(f"{height:.0f}") + + # Set the custom ticks + ax.set_yticks(y_ticks) + ax.set_yticklabels(y_labels) + + # Add grid lines for better readability + ax.grid(True, alpha=0.3) + + # Add horizontal line to separate slab and weak layer + ax.axhline(y=slab_bottom, color="black", linewidth=1, alpha=0.5, linestyle="--") + + # === ADD ANALYSIS ANNOTATIONS === + + # 1. Vertical lines for min_crack_length (centered at x=0) + min_crack_length_cm = min_crack_length / 10 # Convert mm to cm + ax.plot( + [-min_crack_length_cm / 2, -min_crack_length_cm / 2], + [0, weak_layer_bottom], + color="orange", + linewidth=1, + alpha=0.7, + label=f"Crack Propagation: Β±{min_crack_length / 2:.0f}mm", + ) + ax.plot( + [min_crack_length_cm / 2, min_crack_length_cm / 2], + [0, weak_layer_bottom], + color="orange", + linewidth=1, + alpha=0.7, + ) + + base_square_size = (1e-1 * window) / 25 # Base size for scaling + segment_position = 0 # Track cumulative position + square_spacing = 2.0 # Space above slab for squares + + # Collect weight information for legend + weight_legend_items = [] + + for segment in system.scenario.segments: + segment_position += segment.length + if segment.m > 0: # If there's a weight at this segment + # Convert position to cm and center at x=0 + square_x = (segment_position / 10) - (1e-1 * max(xsl)) + square_y = slab_top - square_spacing # Position above slab + + # Calculate square side length based on cube root of weight (volume scaling) + actual_side_length = base_square_size * (segment.m / 100) ** (1 / 3) + + # Draw actual skier weight square (filled, blue) + actual_square = Rectangle( + (square_x - actual_side_length / 2, square_y - actual_side_length), + actual_side_length, + actual_side_length, + facecolor="blue", + alpha=0.7, + edgecolor="blue", + linewidth=1, + ) + ax.add_patch(actual_square) + + # Add to weight legend + weight_legend_items.append( + (f"Actual: {segment.m:.0f} kg", "blue", True) + ) + + # Draw critical weight square (outline only, green) + critical_weight = min_force_result.critical_skier_weight + critical_side_length = base_square_size * (critical_weight / 100) ** ( + 1 / 3 + ) + critical_square = Rectangle( + ( + square_x - critical_side_length / 2, + square_y - critical_side_length, + ), + critical_side_length, + critical_side_length, + facecolor="none", + alpha=0.7, + edgecolor="green", + linewidth=1, + ) + ax.add_patch(critical_square) + + # Add to weight legend (only once) + if not any("Critical" in item[0] for item in weight_legend_items): + weight_legend_items.append( + (f"Critical: {critical_weight:.0f} kg", "green", False) + ) + + # 3. Coupled criterion result square (centered at x=0) + coupled_weight = coupled_criterion_result.critical_skier_weight + coupled_side_length = base_square_size * (coupled_weight / 100) ** (1 / 3) + coupled_square = Rectangle( + (-coupled_side_length / 2, slab_top - square_spacing - coupled_side_length), + coupled_side_length, + coupled_side_length, + facecolor="none", + alpha=0.7, + edgecolor="red", + linewidth=1, + ) + ax.add_patch(coupled_square) + + # Add to weight legend + weight_legend_items.append((f"Coupled: {coupled_weight:.0f} kg", "red", False)) + + # 4. Vertical line for coupled criterion result (spans weak layer only) + cc_crack_length = coupled_criterion_result.crack_length / 10 + ax.plot( + [cc_crack_length / 2, cc_crack_length / 2], + [0, weak_layer_bottom], + color="red", + linewidth=1, + alpha=0.7, + ) + ax.plot( + [-cc_crack_length / 2, -cc_crack_length / 2], + [0, weak_layer_bottom], + color="red", + linewidth=1, + alpha=0.7, + label=f"Crack Nucleation: Β±{coupled_criterion_result.crack_length / 2:.0f}mm", + ) + + # Calculate and set proper y-axis limits to include squares + # Find the maximum extent of squares and text above the slab + max_weight = max( + [segment.m for segment in system.scenario.segments if segment.m > 0] + + [ + min_force_result.critical_skier_weight, + coupled_criterion_result.critical_skier_weight, + ] + ) + max_square_size = base_square_size * (max_weight / 100) ** (1 / 3) + + # Calculate plot limits for inverted y-axis + # Top of plot (smallest y-value): above the squares and text + plot_top = slab_top - 3 * max_square_size - 5 # Include text space + + # Bottom of plot (largest y-value): below weak layer + plot_bottom = weak_layer_bottom + 1.0 + + # Set y-limits [bottom, top] for inverted axis + ax.set_ylim([plot_bottom, plot_top]) + + weight_legend_handles = [] + weight_legend_labels = [] + + for label, color, filled in weight_legend_items: + if filled: + # Filled square for actual weights + patch = Patch(facecolor=color, edgecolor=color, alpha=0.7) + else: + # Outline only square for critical/coupled weights + patch = Patch(facecolor="none", edgecolor=color, alpha=0.7, linewidth=1) + + weight_legend_handles.append(patch) + weight_legend_labels.append(label) + + # Plot labels + ax.set_xlabel(r"lateral position $x$ (cm) $\longrightarrow$") + ax.set_ylabel("Layer Height (mm)\n" + r"$\longleftarrow $ Slab | Weak Layer") + + # Add primary legend for annotations (crack lengths) + legend1 = ax.legend(loc="upper right", fontsize=8) + + # Add the first legend back (matplotlib only shows the last legend by default) + ax.add_artist(legend1) + + # Show colorbar + ticks = np.linspace(levels[0], levels[-1], num=11, endpoint=True) + fig.colorbar( + ax.contourf( + Xwl + scale * Uwl, + Zwl + scale * Wwl, + weak, + levels=levels, + cmap=cmap, + extend="both", + ), + orientation="horizontal", + ticks=ticks, + label="Stress Criterion: Failure > 1", + aspect=35, + ) + + # Save figure + self._save_figure(filename, fig) + + return fig + + # === PLOT WRAPPERS =========================================================== + + def plot_displacements( + self, + analyzer: Analyzer, + x: np.ndarray, + z: np.ndarray, + filename: str = "displacements", + ) -> Figure: + """Wrap for displacements plot.""" + data = [ + [x / 10, analyzer.sm.fq.u(z, unit="mm"), r"$u_0\ (\mathrm{mm})$"], + [x / 10, -analyzer.sm.fq.w(z, unit="mm"), r"$-w\ (\mathrm{mm})$"], + [x / 10, analyzer.sm.fq.psi(z, unit="deg"), r"$\psi\ (^\circ)$ "], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + ax1label=r"Displacements", + ax1data=data, + filename=filename, + ) + + def plot_stresses( + self, + analyzer: Analyzer, + x: np.ndarray, + z: np.ndarray, + filename: str = "stresses", + ) -> Figure: + """Wrap stress plot.""" + data = [ + [x / 10, analyzer.sm.fq.tau(z, unit="kPa"), r"$\tau$"], + [x / 10, analyzer.sm.fq.sig(z, unit="kPa"), r"$\sigma$"], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + ax1label=r"Stress (kPa)", + ax1data=data, + filename=filename, + ) + + def plot_stress_criteria( + self, analyzer: Analyzer, x: np.ndarray, stress: np.ndarray + ) -> Figure: + """Wrap plot of stress and energy criteria.""" + data = [[x / 10, stress, r"$\sigma/\sigma_\mathrm{c}$"]] + self._plot_data( + scenario=analyzer.sm.scenario, + ax1label=r"Criteria", + ax1data=data, + filename="crit", + ) + + def plot_ERR_comp( + self, + analyzer: Analyzer, + da: np.ndarray, + Gdif: np.ndarray, + Ginc: np.ndarray, + mode: int = 0, + ) -> Figure: + """Wrap energy release rate plot.""" + data = [ + [da / 10, 1e3 * Gdif[mode, :], r"$\mathcal{G}$"], + [da / 10, 1e3 * Ginc[mode, :], r"$\bar{\mathcal{G}}$"], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + xlabel=r"Crack length $\Delta a$ (cm)", + ax1label=r"Energy release rate (J/m$^2$)", + ax1data=data, + filename="err", + vlines=False, + ) + + def plot_ERR_modes( + self, analyzer: Analyzer, da: np.ndarray, G: np.ndarray, kind: str = "inc" + ) -> Figure: + """Wrap energy release rate plot.""" + label = r"$\bar{\mathcal{G}}$" if kind == "inc" else r"$\mathcal{G}$" + data = [ + [da / 10, 1e3 * G[2, :], label + r"$_\mathrm{I\!I}$"], + [da / 10, 1e3 * G[1, :], label + r"$_\mathrm{I}$"], + [da / 10, 1e3 * G[0, :], label + r"$_\mathrm{I+I\!I}$"], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + xlabel=r"Crack length $a$ (cm)", + ax1label=r"Energy release rate (J/m$^2$)", + ax1data=data, + filename="modes", + vlines=False, + ) + + def plot_fea_disp( + self, analyzer: Analyzer, x: np.ndarray, z: np.ndarray, fea: np.ndarray + ) -> Figure: + """Wrap displacements plot.""" + data = [ + [fea[:, 0] / 10, -np.flipud(fea[:, 1]), r"FEA $u_0$"], + [fea[:, 0] / 10, np.flipud(fea[:, 2]), r"FEA $w_0$"], + # [fea[:, 0]/10, -np.flipud(fea[:, 3]), r'FEA $u(z=-h/2)$'], + # [fea[:, 0]/10, np.flipud(fea[:, 4]), r'FEA $w(z=-h/2)$'], + [fea[:, 0] / 10, np.flipud(np.rad2deg(fea[:, 5])), r"FEA $\psi$"], + [x / 10, analyzer.sm.fq.u(z, z0=0), r"$u_0$"], + [x / 10, -analyzer.sm.fq.w(z), r"$-w$"], + [x / 10, np.rad2deg(analyzer.sm.fq.psi(z)), r"$\psi$"], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + ax1label=r"Displacements (mm)", + ax1data=data, + filename="fea_disp", + labelpos=-50, + ) + + def plot_fea_stress( + self, analyzer: Analyzer, xb: np.ndarray, zb: np.ndarray, fea: np.ndarray + ) -> Figure: + """Wrap stress plot.""" + data = [ + [fea[:, 0] / 10, 1e3 * np.flipud(fea[:, 2]), r"FEA $\sigma_2$"], + [fea[:, 0] / 10, 1e3 * np.flipud(fea[:, 3]), r"FEA $\tau_{12}$"], + [xb / 10, analyzer.sm.fq.tau(zb, unit="kPa"), r"$\tau$"], + [xb / 10, analyzer.sm.fq.sig(zb, unit="kPa"), r"$\sigma$"], + ] + self._plot_data( + scenario=analyzer.sm.scenario, + ax1label=r"Stress (kPa)", + ax1data=data, + filename="fea_stress", + labelpos=-50, + ) + + # === BASE PLOT FUNCTION ====================================================== + + def _plot_data( + self, + scenario: Scenario, + filename: str, + ax1data, + ax1label, + ax2data=None, + ax2label=None, + labelpos=None, + vlines=True, + xlabel=r"Horizontal position $x$ (cm)", + ) -> Figure: + """Plot data. Base function.""" + # Figure setup + plt.rcdefaults() + plt.rc("font", family="serif", size=10) + plt.rc("mathtext", fontset="cm") + + # Create figure + fig = plt.figure(figsize=(4, 8 / 3)) + ax1 = fig.gca() + + # Axis limits + ax1.autoscale(axis="x", tight=True) + + # Set axis labels + ax1.set_xlabel(xlabel + r" $\longrightarrow$") + ax1.set_ylabel(ax1label + r" $\longrightarrow$") + + # Plot x-axis + ax1.axhline(0, linewidth=0.5, color="gray") + + ki = scenario.ki + li = scenario.li + mi = scenario.mi + + # Plot vertical separators + if vlines: + ax1.axvline(0, linewidth=0.5, color="gray") + for i, f in enumerate(ki): + if not f: + ax1.axvspan( + sum(li[:i]) / 10, + sum(li[: i + 1]) / 10, + facecolor="gray", + alpha=0.05, + zorder=100, + ) + for i, m in enumerate(mi, start=1): + if m > 0: + ax1.axvline(sum(li[:i]) / 10, linewidth=0.5, color="gray") + else: + ax1.autoscale(axis="y", tight=True) + + # Calculate labelposition + if not labelpos: + x = ax1data[0][0] + labelpos = int(0.95 * len(x[~np.isnan(x)])) + + # Fill left y-axis + i = 0 + for x, y, label in ax1data: + i += 1 + if label == "" or "FEA" in label: + # line, = ax1.plot(x, y, 'k:', linewidth=1) + ax1.plot(x, y, linewidth=3, color="white") + (line,) = ax1.plot(x, y, ":", linewidth=1) # , color='black' + thislabelpos = -2 + x, y = x[~np.isnan(x)], y[~np.isnan(x)] + xtx = (x[thislabelpos - 1] + x[thislabelpos]) / 2 + ytx = (y[thislabelpos - 1] + y[thislabelpos]) / 2 + ax1.text(xtx, ytx, label, color=line.get_color(), **LABELSTYLE) + else: + # Plot line + ax1.plot(x, y, linewidth=3, color="white") + (line,) = ax1.plot(x, y, linewidth=1) + # Line label + x, y = x[~np.isnan(x)], y[~np.isnan(x)] + if len(x) > 0: + xtx = (x[labelpos - 10 * i - 1] + x[labelpos - 10 * i]) / 2 + ytx = (y[labelpos - 10 * i - 1] + y[labelpos - 10 * i]) / 2 + ax1.text(xtx, ytx, label, color=line.get_color(), **LABELSTYLE) + + # Fill right y-axis + if ax2data: + # Create right y-axis + ax2 = ax1.twinx() + # Set axis label + ax2.set_ylabel(ax2label + r" $\longrightarrow$") + # Fill + for x, y, label in ax2data: + # Plot line + ax2.plot(x, y, linewidth=3, color="white") + (line,) = ax2.plot(x, y, linewidth=1, color=COLORS[8, 0]) + # Line label + x, y = x[~np.isnan(x)], y[~np.isnan(x)] + xtx = (x[labelpos - 1] + x[labelpos]) / 2 + ytx = (y[labelpos - 1] + y[labelpos]) / 2 + ax2.text(xtx, ytx, label, color=line.get_color(), **LABELSTYLE) + + # Save figure + if filename: + self._save_figure(filename, fig) + + return fig diff --git a/weac/components/__init__.py b/weac/components/__init__.py new file mode 100644 index 0000000..0c199bb --- /dev/null +++ b/weac/components/__init__.py @@ -0,0 +1,21 @@ +""" +Component Classes for Inputs of the WEAC model. +""" + +from .config import Config +from .criteria_config import CriteriaConfig +from .layer import Layer, WeakLayer +from .model_input import ModelInput +from .segment import Segment +from .scenario_config import ScenarioConfig, SystemType + +__all__ = [ + "Config", + "WeakLayer", + "Layer", + "Segment", + "CriteriaConfig", + "ScenarioConfig", + "ModelInput", + "SystemType", +] diff --git a/weac/components/config.py b/weac/components/config.py new file mode 100644 index 0000000..590c974 --- /dev/null +++ b/weac/components/config.py @@ -0,0 +1,33 @@ +""" +Configuration for the WEAC simulation. +These settings control runtime parameters for WEAC. +In general, developers maintain these defaults; end users should see a stable configuration. + +We utilize the pydantic library to define the configuration. + +Pydantic syntax is for a field: +field_name: type = Field(..., gt=0, description="Description") +- typing, default value, constraints, description +""" + +from pydantic import BaseModel, Field + + +class Config(BaseModel): + """ + Configuration for the WEAC simulation. + + Attributes + ---------- + touchdown : bool + Whether slab touchdown on the collapsed weak layer is considered. + """ + + touchdown: bool = Field( + default=False, description="Whether to include slab touchdown in the analysis" + ) + + +if __name__ == "__main__": + config = Config() + print(config.model_dump_json(indent=2)) diff --git a/weac/components/criteria_config.py b/weac/components/criteria_config.py new file mode 100644 index 0000000..90e8161 --- /dev/null +++ b/weac/components/criteria_config.py @@ -0,0 +1,86 @@ +""" +Module for configuring failure-mode interaction criteria and stress failure envelope selection. + +Main fields: +- fn, fm: interaction exponents for normal (sigma) and shear (tau) stresses (> 0). +- gn, gm: interaction exponents for mode-I (G_I) and mode-II (G_II) energy release rates (> 0). +- stress_envelope_method: one of + {"adam_unpublished", "schottner", "mede_s-RG1", "mede_s-RG2", "mede_s-FCDH"}. +- scaling_factor, order_of_magnitude: positive scalars applied to the stress envelope. + +Typical usage: + from weac.components.criteria_config import CriteriaConfig + + config = CriteriaConfig( + stress_envelope_method="schottner", + scaling_factor=1.0, + order_of_magnitude=1.0, + ) + +See also: +- weac.analysis.criteria_evaluator for how these parameters influence failure checks. +""" + +from typing import Literal + +from pydantic import BaseModel, Field + + +class CriteriaConfig(BaseModel): + """ + Parameters defining the interaction between different failure modes. + + Attributes + ---------- + fn : float + Failure mode interaction exponent for normal stress (sigma). Default is 2.0. + fm : float + Failure mode interaction exponent for shear stress (tau). Default is 2.0. + gn : float + Failure mode interaction exponent for closing energy release rate (G_I). Default is 5.0. + gm : float + Failure mode interaction exponent for shearing energy release rate (G_II). Default is 2.22. + stress_envelope_method : str + Method to calculate the stress failure envelope. Default is "adam_unpublished". + scaling_factor : float + Scaling factor for stress envelope. Default is 1.0. + order_of_magnitude : float + Order of magnitude for stress envelope. Default is 1.0. + """ + + fn: float = Field( + default=2.0, + gt=0, + description="Failure mode interaction exponent for normal stress (sigma)", + ) + fm: float = Field( + default=2.0, + gt=0, + description="Failure mode interaction exponent for shear stress (tau)", + ) + gn: float = Field( + default=1 / 0.2, + gt=0, + description="Failure mode interaction exponent for closing energy release rate (G_I)", + ) + gm: float = Field( + default=1 / 0.45, + gt=0, + description="Failure mode interaction exponent for shearing energy release rate (G_II)", + ) + stress_envelope_method: Literal[ + "adam_unpublished", "schottner", "mede_s-RG1", "mede_s-RG2", "mede_s-FCDH" + ] = Field( + default="adam_unpublished", + description="Method to calculate the stress failure envelope", + ) + scaling_factor: float = Field( + default=1, + gt=0, + description="Scaling factor for stress envelope", + ) + order_of_magnitude: float = Field( + default=1, + gt=0, + description="Order of magnitude for stress envelope", + ) diff --git a/weac/components/layer.py b/weac/components/layer.py new file mode 100644 index 0000000..d9e90db --- /dev/null +++ b/weac/components/layer.py @@ -0,0 +1,284 @@ +""" +Mechanical properties of snow-pack layers. + +* `Layer` - a regular slab layer (no foundation springs) +* `WeakLayer` - a slab layer that also acts as a Winkler-type foundation +""" + +from typing import Literal + +import numpy as np +from pydantic import BaseModel, ConfigDict, Field, model_validator + +from weac.constants import CB0, CB1, CG0, CG1, NU, RHO_ICE +from weac.utils.snow_types import GrainType, HandHardness + + +def _collapse_height(h: float) -> float: + """ + Based on data from Herwijnen (van Herwijnen, 2016) + `Estimating the effective elastic modulus and specific fracture energy of + snowpack layers from field experiments` + Data collection 2005 - 2016. + + Arguments: + ---------- + h : float + Height/Thickness of the layer [mm]. + """ + return 4.70 * (1 - np.exp(-h / 7.78)) + + +def _bergfeld_youngs_modulus(rho: float, C_0: float = CB0, C_1: float = CB1) -> float: + """Young's modulus from Bergfeld et al. (2023) - returns MPa. + + Arguments + --------- + rho : float or ndarray + Density (kg/m^3). + C0 : float, optional + Multiplicative constant of Young modulus parametrization + according to Bergfeld et al. (2023). Default is 6.5. + C1 : float, optional + Exponent of Young modulus parameterization according to + Bergfeld et al. (2023). Default is 4.4. + """ + return C_0 * 1e3 * (rho / RHO_ICE) ** C_1 + + +def _scapozza_youngs_modulus(rho: float) -> float: + """Young's modulus from Scapozzo et al. (2019) - return MPa + `rho` in [kg/m^3]""" + rho = rho * 1e-12 # Convert to [t/mm^3] + rho_0 = RHO_ICE * 1e-12 # Density of ice in [t/mm^3] + return 5.07e3 * (rho / rho_0) ** 5.13 + + +def _gerling_youngs_modulus(rho: float, C_0: float = CG0, C_1: float = CG1) -> float: + """Young's modulus according to Gerling et al. (2017). + + Arguments + --------- + rho : float or ndarray + Density (kg/m^3). + C0 : float, optional + Multiplicative constant of Young modulus parametrization + according to Gerling et al. (2017). Default is 6.0. + C1 : float, optional + Exponent of Young modulus parameterization according to + Gerling et al. (2017). Default is 4.6. + """ + return C_0 * 1e-10 * rho**C_1 + + +def _sigrist_tensile_strength(rho, unit: Literal["kPa", "MPa"] = "kPa"): + """ + Estimate the tensile strength of a slab layer from its density. + + Uses the density parametrization of Sigrist (2006). + + Arguments + --------- + rho : ndarray, float + Layer density (kg/m^3). + unit : str, optional + Desired output unit of the layer strength. Default is 'kPa'. + + Returns + ------- + ndarray + Tensile strength in specified unit. + """ + convert = {"kPa": 1, "MPa": 1e-3} + # Sigrist's equation is given in kPa + return convert[unit] * 240 * (rho / RHO_ICE) ** 2.44 + + +class Layer(BaseModel): + """ + Regular slab layer (no foundation springs). + + Attributes + ---------- + rho : float + Density of the layer [kg m⁻³]. + h : float + Height/Thickness of the layer [mm]. + nu : float + Poisson's ratio [-] Defaults to `weac.constants.NU`). + E : float, optional + Young's modulus E [MPa]. If omitted it is derived from ``rho``. + G : float, optional + Shear modulus G [MPa]. If omitted it is derived from ``E`` and ``nu``. + """ + + # has to be provided + rho: float = Field(default=150, gt=0, description="Density of the Slab [kg m⁻³]") + h: float = Field( + default=200, gt=0, description="Height/Thickness of the slab [mm]" + ) + + # derived if not provided + nu: float = Field(default=NU, ge=0, lt=0.5, description="Poisson's ratio [-]") + E: float = Field(default=0.0, ge=0, description="Young's modulus [MPa]") + G: float = Field(default=0.0, ge=0, description="Shear modulus [MPa]") + tensile_strength: float = Field( + default=0.0, ge=0, description="Tensile strength [kPa]" + ) + tensile_strength_method: Literal["sigrist"] = Field( + default="sigrist", + description="Method to calculate the tensile strength", + ) + E_method: Literal["bergfeld", "scapazzo", "gerling"] = Field( + default="bergfeld", + description="Method to calculate the Young's modulus", + ) + grain_type: GrainType | None = Field(default=None, description="Grain type") + grain_size: float | None = Field(default=None, description="Grain size [mm]") + hand_hardness: HandHardness | None = Field( + default=None, description="Hand hardness" + ) + + def model_post_init(self, _ctx): # pylint: disable=arguments-differ + if self.E_method == "bergfeld": + object.__setattr__(self, "E", self.E or _bergfeld_youngs_modulus(self.rho)) + elif self.E_method == "scapazzo": + object.__setattr__(self, "E", self.E or _scapozza_youngs_modulus(self.rho)) + elif self.E_method == "gerling": + object.__setattr__(self, "E", self.E or _gerling_youngs_modulus(self.rho)) + else: + raise ValueError(f"Invalid E_method: {self.E_method}") + object.__setattr__(self, "G", self.G or self.E / (2 * (1 + self.nu))) + if self.tensile_strength_method == "sigrist": + object.__setattr__( + self, + "tensile_strength", + self.tensile_strength + or _sigrist_tensile_strength(self.rho, unit="kPa"), + ) + else: + raise ValueError( + f"Invalid tensile_strength_method: {self.tensile_strength_method}" + ) + + @model_validator(mode="after") + def validate_positive_E_G(self): + """Validate that E and G are positive.""" + if self.E <= 0: + raise ValueError("E must be positive") + if self.G <= 0: + raise ValueError("G must be positive") + return self + + +class WeakLayer(BaseModel): + """ + Weak layer that also behaves as a Winkler foundation. + + Attributes + ---------- + rho : float + Density of the layer [kg m⁻³]. + h : float + Height/Thickness of the layer [mm]. + nu : float + Poisson's ratio [-] Defaults to `weac.constants.NU`). + E : float, optional + Young's modulus E [MPa]. If omitted it is derived from ``rho``. + G : float, optional + Shear modulus G [MPa]. If omitted it is derived from ``E`` and ``nu``. + kn : float, optional + Normal (compression) spring stiffness kβ‚™ [N mm⁻³]. If omitted it is + computed as ``E_plane / t`` where + ``E_plane = E / (1 - nuΒ²)``. + kt : float, optional + Shear spring stiffness kβ‚œ [N mm⁻³]. If omitted it is ``G / t``. + G_c : float + Total fracture energy Gc [J/m^2]. Default 1.0 J/m^2. + G_Ic : float + Mode-I fracture toughness GIc [J/m^2]. Default 0.56 J/m^2. + G_IIc : float + Mode-II fracture toughness GIIc [J/m^2]. Default 0.79 J/m^2. + """ + + rho: float = Field(default=125, gt=0, description="Density of the Slab [kg m⁻³]") + h: float = Field(default=20, gt=0, description="Height/Thickness of the slab [mm]") + collapse_height: float = Field( + default=0.0, ge=0, description="Collapse height [mm]" + ) + nu: float = Field(default=NU, ge=0, lt=0.5, description="Poisson's ratio [-]") + + E: float = Field(default=0.0, ge=0, description="Young's modulus [MPa]") + G: float = Field(default=0.0, ge=0, description="Shear modulus [MPa]") + # Winkler springs (can be overridden by caller) + kn: float = Field(default=0.0, description="Normal stiffness [N mm⁻³]") + kt: float = Field(default=0.0, description="Shear stiffness [N mm⁻³]") + # fracture-mechanics parameters + G_c: float = Field( + default=1.0, gt=0, description="Total fracture energy Gc [J/m^2]" + ) + G_Ic: float = Field( + default=0.56, gt=0, description="Mode-I fracture toughness GIc [J/m^2]" + ) + G_IIc: float = Field( + default=0.79, gt=0, description="Mode-II fracture toughness GIIc [J/m^2]" + ) + sigma_c: float = Field(default=6.16, gt=0, description="Tensile strength [kPa]") + tau_c: float = Field(default=5.09, gt=0, description="Shear strength [kPa]") + E_method: Literal["bergfeld", "scapazzo", "gerling"] = Field( + default="bergfeld", + description="Method to calculate the Young's modulus", + ) + grain_type: GrainType | None = Field(default=None, description="Grain type") + grain_size: float | None = Field(default=None, description="Grain size [mm]") + hand_hardness: HandHardness | None = Field( + default=None, description="Hand hardness" + ) + + model_config = ConfigDict( + frozen=True, + extra="forbid", + ) + + def model_post_init(self, _ctx): # pylint: disable=arguments-differ + if self.E_method == "bergfeld": + object.__setattr__(self, "E", self.E or _bergfeld_youngs_modulus(self.rho)) + elif self.E_method == "scapazzo": + object.__setattr__(self, "E", self.E or _scapozza_youngs_modulus(self.rho)) + elif self.E_method == "gerling": + object.__setattr__(self, "E", self.E or _gerling_youngs_modulus(self.rho)) + else: + raise ValueError(f"Invalid E_method: {self.E_method}") + object.__setattr__( + self, "collapse_height", self.collapse_height or _collapse_height(self.h) + ) + + # Validate that collapse height is smaller than layer height + if self.collapse_height >= self.h: + raise ValueError( + f"Collapse height ({self.collapse_height:.2f} mm) must be smaller than " + f"layer height ({self.h:.2f} mm). Consider reducing collapse_height or " + f"increasing layer thickness." + ) + + object.__setattr__(self, "G", self.G or self.E / (2 * (1 + self.nu))) + E_plane = self.E / (1 - self.nu**2) # plane-strain Young + object.__setattr__(self, "kn", self.kn or E_plane / self.h) + object.__setattr__(self, "kt", self.kt or self.G / self.h) + + @model_validator(mode="after") + def validate_positive_E_G(self): + """Validate that E and G are positive.""" + if self.E <= 0: + raise ValueError("E must be positive") + if self.G <= 0: + raise ValueError("G must be positive") + return self + + +if __name__ == "__main__": + ly1 = Layer(rho=180, h=120) # E,G,k auto-computed + ly2 = Layer(rho=250, h=80, E=50.0) # override E, derive G + wl = WeakLayer(rho=170, h=30) # full set incl. kn, kt + + print(wl.model_dump()) diff --git a/weac/components/model_input.py b/weac/components/model_input.py new file mode 100644 index 0000000..70282c7 --- /dev/null +++ b/weac/components/model_input.py @@ -0,0 +1,103 @@ +""" +This module defines the input data model for the WEAC simulation. + +We utilize the pydantic library instead of dataclasses to define the input +data model. The advantages of pydantic are: +1. validate the input data for the WEAC simulation, compared to __post_init__ methods. +2. generate JSON schemas for the input data, which is good for API endpoints. +3. generate the documentation for the input data. + +Pydantic syntax is for a field: +field_name: type = Field(..., gt=0, description="Description") +- typing, default value, conditions, description +""" + +import json +import logging +from typing import List + +from pydantic import BaseModel, ConfigDict, Field, model_validator + +from weac.components.layer import Layer, WeakLayer +from weac.components.scenario_config import ScenarioConfig +from weac.components.segment import Segment + +logger = logging.getLogger(__name__) + + +class ModelInput(BaseModel): + """ + Comprehensive input data model for a WEAC simulation. + + Attributes + ---------- + scenario_config : ScenarioConfig + Scenario configuration. + weak_layer : WeakLayer + Weak layer properties. + layers : List[Layer] + List of snow slab layers. + segments : List[Segment] + List of segments defining the slab geometry and loading. + """ + + model_config = ConfigDict( + extra="forbid", + ) + + weak_layer: WeakLayer = Field( + default_factory=lambda: WeakLayer(rho=125, h=20, E=1.0), + description="Weak layer", + ) + layers: List[Layer] = Field( + default_factory=lambda: [Layer(rho=250, h=100)], description="List of layers" + ) + scenario_config: ScenarioConfig = Field( + default_factory=ScenarioConfig, description="Scenario configuration" + ) + segments: List[Segment] = Field( + default_factory=lambda: [ + Segment(length=5000, has_foundation=True, m=100), + Segment(length=5000, has_foundation=True, m=0), + ], + description="Segments", + ) + + @model_validator(mode="after") + def _validate_non_empty_components(self): + """Post-initialization checks.""" + # Check that the last segment does not have a mass + if not self.segments: + raise ValueError("At least one segment is required") + if not self.layers: + raise ValueError("At least one layer is required") + if self.segments[-1].m != 0: + raise ValueError("The last segment must have a mass of 0") + return self + + +if __name__ == "__main__": + # Example usage requiring all mandatory fields for proper instantiation + example_scenario_config = ScenarioConfig(phi=30, system_type="skiers") + # example_weak_layer = WeakLayer( + # rho=200, h=10 + # ) # grain_size, temp, E, G_I have defaults + + example_layers = [ + Layer(rho=250, h=100), # grain_size, temp have defaults + Layer(rho=280, h=150), + ] + example_segments = [ + Segment(length=5000, has_foundation=True, m=80), + Segment(length=3000, has_foundation=False, m=0), + ] + + model_input = ModelInput( + scenario_config=example_scenario_config, + layers=example_layers, + segments=example_segments, + ) + print(model_input.model_dump_json(indent=2)) + print("\n\n") + schema_json = json.dumps(ModelInput.model_json_schema(), indent=2) + print(schema_json) diff --git a/weac/components/scenario_config.py b/weac/components/scenario_config.py new file mode 100644 index 0000000..17fccaa --- /dev/null +++ b/weac/components/scenario_config.py @@ -0,0 +1,72 @@ +""" +This module defines the ScenarioConfig class, which contains the configuration for a given scenario. +""" + +from typing import Literal + +from pydantic import BaseModel, Field + + +SystemType = Literal[ + "skier", "skiers", "pst-", "-pst", "rot", "trans", "vpst-", "-vpst" +] + + +class ScenarioConfig(BaseModel): + """ + Configuration for the overall scenario, such as slope angle. + + Attributes + ---------- + phi : float, optional + Slope angle in degrees (counterclockwise positive). + system_type : SystemType + Type of system. Allowed values are: + - skier: single skier in-between two segments + - skiers: multiple skiers spread over the slope + - pst-: positive PST: down-slope + slab-normal cuts + - -pst: negative PST: up-slope + slab-normal cuts + - rot: rotation: rotation of the slab + - trans: translation: translation of the slab + - vpst-: positive VPST: down-slope + vertical cuts + - -vpst: negative VPST: up-slope + vertical cuts + cut_length : float, optional + Cut length for PST/VPST [mm]. + stiffness_ratio : float, optional + Stiffness ratio between collapsed and uncollapsed weak layer. + surface_load : float, optional + Surface line-load on slab [N/mm] (force per mm of out-of-plane width). + """ + + system_type: SystemType = Field( + default="skiers", + description="Type of system, '-pst', 'pst-', ....; \n" + "skier: single skier in-between two segments, \n" + "skiers: multiple skiers spread over the slope, \n" + "pst-: positive PST: down-slope + slab-normal cuts, \n" + "-pst: negative PST: up-slope + slab-normal cuts, \n" + "rot: rotation: rotation of the slab, \n" + "trans: translation: translation of the slab, \n" + "vpst-: positive VPST: down-slope + vertical cuts, \n" + "-vpst: negative VPST: up-slope + vertical cuts, \n", + ) + phi: float = Field( + default=0.0, + ge=-90.0, + le=90.0, + description="Slope angle in degrees (counterclockwise positive)", + ) + cut_length: float = Field( + default=0.0, ge=0, description="Cut length of performed PST or VPST [mm]" + ) + stiffness_ratio: float = Field( + default=1000.0, + gt=0.0, + description="Stiffness ratio between collapsed and uncollapsed weak layer", + ) + surface_load: float = Field( + default=0.0, + ge=0.0, + description="Surface line-load on slab [N/mm], e.g. evenly spaced weights, " + "Adam et al. (2024)", + ) diff --git a/weac/components/segment.py b/weac/components/segment.py new file mode 100644 index 0000000..ace1b19 --- /dev/null +++ b/weac/components/segment.py @@ -0,0 +1,31 @@ +""" +This module defines the Segment class, which represents a segment of the snowpack. +""" + +from pydantic import BaseModel, Field + + +class Segment(BaseModel): + """ + Defines a snow-slab segment: its length, foundation support, and applied loads. + + Attributes + ---------- + length: float + Segment length in millimeters [mm]. + has_foundation: bool + Whether the segment is supported (foundation present) or cracked/free-hanging + (no foundation). + m: float + Skier mass at the segment's right edge [kg]. + """ + + length: float = Field(default=5e3, ge=0, description="Segment length in [mm]") + has_foundation: bool = Field( + default=True, + description="Whether the segment is supported (foundation present) or " + "cracked/free-hanging (no foundation)", + ) + m: float = Field( + default=0, ge=0, description="Skier mass at the segment's right edge in [kg]" + ) diff --git a/weac/constants.py b/weac/constants.py new file mode 100644 index 0000000..cb011ac --- /dev/null +++ b/weac/constants.py @@ -0,0 +1,37 @@ +""" +Constants for the WEAC simulation. +""" + +from typing import Final + +G_MM_S2: Final[float] = 9810.0 # gravitational acceleration (mm s⁻²) +NU: Final[float] = 0.25 # Global Poisson's ratio +SHEAR_CORRECTION_FACTOR: Final[float] = 5.0 / 6.0 # Shear-correction factor (slabs) +STIFFNESS_COLLAPSE_FACTOR: Final[float] = ( + 1000.0 # Stiffness ratio between collapsed and uncollapsed weak layer. +) +ROMBERG_TOL: Final[float] = 1e-3 # Romberg integration tolerance +LSKI_MM: Final[float] = 1000.0 # Effective out-of-plane length of skis (mm) +EPS: Final[float] = 1e-9 # Global numeric tolerance for float comparisons + +RHO_ICE: Final[float] = 916.7 # Density of ice (kg/m^3) +CB0: Final[float] = ( + 6.5 + # Multiplicative constant of Young modulus + # parametrization according to Bergfeld et al. (2023) +) +CB1: Final[float] = ( + 4.4 + # Exponent of Young modulus parameterization + # according to Bergfeld et al. (2023) +) +CG0: Final[float] = ( + 6.0 + # Multiplicative constant of Young modulus + # parametrization according to Gerling et al. (2017) +) +CG1: Final[float] = ( + 4.5 + # Exponent of Young modulus parameterization + # according to Gerling et al. (2017) +) diff --git a/weac/core/__init__.py b/weac/core/__init__.py new file mode 100644 index 0000000..2b23fca --- /dev/null +++ b/weac/core/__init__.py @@ -0,0 +1,10 @@ +""" +Core modules for the WEAC model. +""" + +from .eigensystem import Eigensystem +from .scenario import Scenario +from .slab import Slab +from .system_model import SystemModel + +__all__ = ["Eigensystem", "Scenario", "Slab", "SystemModel"] diff --git a/weac/core/eigensystem.py b/weac/core/eigensystem.py new file mode 100644 index 0000000..c1781d6 --- /dev/null +++ b/weac/core/eigensystem.py @@ -0,0 +1,405 @@ +""" +This module provides the Eigensystem class, which is used to solve +the eigenvalue problem for a layered beam on an elastic foundation. +""" + +import logging +from typing import Optional + +import numpy as np +from numpy.typing import NDArray + +from weac.components import WeakLayer +from weac.constants import SHEAR_CORRECTION_FACTOR +from weac.core.slab import Slab +from weac.utils.misc import decompose_to_normal_tangential + +logger = logging.getLogger(__name__) + + +class Eigensystem: + """ + Calculates system properties and solves the eigenvalue problem + for a layered beam on an elastic foundation (Winkler model). + + Attributes + ---------- + weak_layer: WeakLayer + slab: Slab + + System properties + ----------------- + A11: float # extensional stiffness + B11: float # coupling stiffness + D11: float # bending stiffness + kA55: float # shear stiffness + K0: float # foundation stiffness + + Eigenvalues and Eigenvectors + ---------------------------- + ewC: NDArray[np.complex128] # shape (k): Complex Eigenvalues + ewR: NDArray[np.float64] # shape (k): Real Eigenvalues + evC: NDArray[np.complex128] # shape (6, k): Complex Eigenvectors + evR: NDArray[np.float64] # shape (6, k): Real Eigenvectors + sR: NDArray[np.float64] # shape (k): Real positive eigenvalue shifts + # (for numerical robustness) + sC: NDArray[np.float64] # shape (k): Complex positive eigenvalue shifts + # (for numerical robustness) + """ + + # Input data + weak_layer: WeakLayer + slab: Slab + + # System properties + A11: float # extensional stiffness + B11: float # coupling stiffness + D11: float # bending stiffness + kA55: float # shear stiffness + K0: float # foundation stiffness + + K: NDArray # System Matrix + + # Eigenvalues and Eigenvectors + ewC: NDArray[np.complex128] # shape (k): Complex Eigenvalues + ewR: NDArray[np.float64] # shape (k): Real Eigenvalues + evC: NDArray[np.complex128] # shape (6, k): Complex Eigenvectors + evR: NDArray[np.float64] # shape (6, k): Real Eigenvectors + sR: NDArray[ + np.float64 + ] # shape (k): Real positive eigenvalue shifts (for numerical robustness) + sC: NDArray[ + np.float64 + ] # shape (k): Complex positive eigenvalue shifts (for numerical robustness) + + def __init__(self, weak_layer: WeakLayer, slab: Slab): + self.slab = slab + self.weak_layer = weak_layer + + self.calc_eigensystem() + + def calc_eigensystem(self): + """Calculate the fundamental system of the problem.""" + self._calc_laminate_stiffness_parameters() + self.K = self.assemble_system_matrix(kn=None, kt=None) + self.ewC, self.ewR, self.evC, self.evR, self.sR, self.sC = ( + self.calc_eigenvalues_and_eigenvectors(self.K) + ) + + def _calc_laminate_stiffness_parameters(self): + """ + Provide ABD matrix. + + Return plane-strain laminate stiffness matrix (ABD matrix). + """ + # Append z_{1} at top of surface layer + zis = np.concatenate(([-self.slab.H / 2], self.slab.zi_bottom)) + + # Initialize stiffness components + A11, B11, D11, kA55 = 0, 0, 0, 0 + # Add layerwise contributions + for i in range(len(zis) - 1): + E = self.slab.Ei[i] + G = self.slab.Gi[i] + nu = self.slab.nui[i] + A11 += E / (1 - nu**2) * (zis[i + 1] - zis[i]) + B11 += 1 / 2 * E / (1 - nu**2) * (zis[i + 1] ** 2 - zis[i] ** 2) + D11 += 1 / 3 * E / (1 - nu**2) * (zis[i + 1] ** 3 - zis[i] ** 3) + kA55 += SHEAR_CORRECTION_FACTOR * G * (zis[i + 1] - zis[i]) + + self.A11 = A11 + self.B11 = B11 + self.D11 = D11 + self.kA55 = kA55 + self.K0 = B11**2 - A11 * D11 + + def assemble_system_matrix( + self, kn: Optional[float], kt: Optional[float] + ) -> NDArray[np.float64]: + """ + Assemble first-order ODE system matrix K. + + Using the solution vector z = [u, u', w, w', psi, psi'] + the ODE system is written in the form Az' + Bz = d + and rearranged to z' = -(A^-1)Bz + (A^-1)d = Kz + q + + Returns + ------- + NDArray[np.float64] + System matrix K (6x6). + """ + kn = kn or self.weak_layer.kn + kt = kt or self.weak_layer.kt + H = self.slab.H # total slab thickness + h = self.weak_layer.h # weak layer thickness + + # Abbreviations + K21 = kt * (-2 * self.D11 + self.B11 * (H + h)) / (2 * self.K0) + K24 = ( + 2 * self.D11 * kt * h + - self.B11 * kt * h * (H + h) + + 4 * self.B11 * self.kA55 + ) / (4 * self.K0) + K25 = ( + -2 * self.D11 * H * kt + + self.B11 * H * kt * (H + h) + + 4 * self.B11 * self.kA55 + ) / (4 * self.K0) + K43 = kn / self.kA55 + K61 = kt * (2 * self.B11 - self.A11 * (H + h)) / (2 * self.K0) + K64 = ( + -2 * self.B11 * kt * h + + self.A11 * kt * h * (H + h) + - 4 * self.A11 * self.kA55 + ) / (4 * self.K0) + K65 = ( + 2 * self.B11 * H * kt + - self.A11 * H * kt * (H + h) + - 4 * self.A11 * self.kA55 + ) / (4 * self.K0) + + # System matrix + K = [ + [0, 1, 0, 0, 0, 0], + [K21, 0, 0, K24, K25, 0], + [0, 0, 0, 1, 0, 0], + [0, 0, K43, 0, 0, -1], + [0, 0, 0, 0, 0, 1], + [K61, 0, 0, K64, K65, 0], + ] + + return np.array(K, dtype=np.float64) + + def calc_eigenvalues_and_eigenvectors( + self, system_matrix: NDArray[np.float64] + ) -> tuple[ + NDArray[np.complex128], + NDArray[np.float64], + NDArray[np.complex128], + NDArray[np.float64], + NDArray[np.float64], + NDArray[np.float64], + ]: + """ + Calculate eigenvalues and eigenvectors of the system matrix. + + Parameters: + ----------- + system_matrix: NDArray # system_matrix size (6x6) of the eigenvalue problem + + Return: + ------- + ewC: NDArray[np.complex128] # shape (k): Complex Eigenvalues + ewR: NDArray[np.float64] # shape (g): Real Eigenvalues + evC: NDArray[np.complex128] # shape (6, k): Complex Eigenvectors + evR: NDArray[np.float64] # shape (6, g): Real Eigenvectors + sR: NDArray[np.float64] # shape (k): Real positive eigenvalue shifts + # (for numerical robustness) + sC: NDArray[np.float64] # shape (g): Complex positive eigenvalue shifts + # (for numerical robustness) + """ + # Calculate eigenvalues (ew) and eigenvectors (ev) + ew, ev = np.linalg.eig(system_matrix) + # Classify real and complex eigenvalues + real = (ew.imag == 0) & (ew.real != 0) # real eigenvalues + cmplx = ew.imag > 0 # positive complex conjugates + # Eigenvalues + ewC = ew[cmplx] + ewR = ew[real].real + # Eigenvectors + evC = ev[:, cmplx] + evR = ev[:, real].real + # Prepare positive eigenvalue shifts for numerical robustness + # 1. Keep small-positive eigenvalues away from zero, to not have a near-singular matrix + sR, sC = np.zeros(ewR.shape), np.zeros(ewC.shape) + sR[ewR > 0], sC[ewC > 0] = -1, -1 + return ewC, ewR, evC, evR, sR, sC + + def zh(self, x: float, length: float = 0, has_foundation: bool = True) -> NDArray: + """ + Compute bedded or free complementary solution at position x. + + Arguments + --------- + x : float + Horizontal coordinate (mm). + length : float, optional + Segment length (mm). Default is 0. + has_foundation : bool + Indicates whether segment has foundation or not. Default + is True. + + Returns + ------- + zh : ndarray + Complementary solution matrix (6x6) at position x. + """ + if has_foundation: + zh = np.concatenate( + [ + # Real + self.evR * np.exp(self.ewR * (x + length * self.sR)), + # Complex + np.exp(self.ewC.real * (x + length * self.sC)) + * ( + self.evC.real * np.cos(self.ewC.imag * x) + - self.evC.imag * np.sin(self.ewC.imag * x) + ), + # Complex + np.exp(self.ewC.real * (x + length * self.sC)) + * ( + self.evC.imag * np.cos(self.ewC.imag * x) + + self.evC.real * np.sin(self.ewC.imag * x) + ), + ], + axis=1, + ) + else: + # Abbreviations + H14 = 3 * self.B11 / self.A11 * x**2 + H24 = 6 * self.B11 / self.A11 * x + H54 = -3 * x**2 + 6 * self.K0 / (self.A11 * self.kA55) + # Complementary solution matrix of free segments + zh = np.array( + [ + [0, 0, 0, H14, 1, x], + [0, 0, 0, H24, 0, 1], + [1, x, x**2, x**3, 0, 0], + [0, 1, 2 * x, 3 * x**2, 0, 0], + [0, -1, -2 * x, H54, 0, 0], + [0, 0, -2, -6 * x, 0, 0], + ] + ) + + return zh + + def zp( + self, x: float, phi: float = 0, has_foundation=True, qs: float = 0 + ) -> NDArray: + """ + Compute bedded or free particular integrals at position x. + + Arguments + --------- + x : float + Horizontal coordinate (mm). + phi : float + Inclination (degrees). + has_foundation : bool + Indicates whether segment has foundation (True) or not + (False). Default is True. + qs : float + additional surface load weight + + Returns + ------- + zp : ndarray + Particular integral vector (6x1) at position x. + """ + # Get weight and surface loads + qw_n, qw_t = decompose_to_normal_tangential(f=self.slab.qw, phi=phi) + qs_n, qs_t = decompose_to_normal_tangential(f=qs, phi=phi) + + # Weak Layer properties + kn = self.weak_layer.kn + kt = self.weak_layer.kt + h = self.weak_layer.h + + # Slab properties + H = self.slab.H + z_cog = self.slab.z_cog + + # Laminate stiffnesses + A11 = self.A11 + B11 = self.B11 + kA55 = self.kA55 + K0 = self.K0 + + # Assemble particular integral vectors + if has_foundation: + zp = np.array( + [ + [ + (qw_t + qs_t) / kt + + H * qw_t * (H + h - 2 * z_cog) / (4 * kA55) + + H * qs_t * (2 * H + h) / (4 * kA55) + ], + [0], + [(qw_n + qs_n) / kn], + [0], + [-(qw_t * (H + h - 2 * z_cog) + qs_t * (2 * H + h)) / (2 * kA55)], + [0], + ] + ) + else: + zp = np.array( + [ + [ + (-3 * (qw_t + qs_t) / A11 - B11 * (qw_n + qs_n) * x / K0) + / 6 + * x**2 + ], + [(-2 * (qw_t + qs_t) / A11 - B11 * (qw_n + qs_n) * x / K0) / 2 * x], + [-A11 * (qw_n + qs_n) * x**4 / (24 * K0)], + [-A11 * (qw_n + qs_n) * x**3 / (6 * K0)], + [ + A11 * (qw_n + qs_n) * x**3 / (6 * K0) + + ( + (z_cog - B11 / A11) * qw_t + - H * qs_t / 2 + - (qw_n + qs_n) * x + ) + / kA55 + ], + [(qw_n + qs_n) * (A11 * x**2 / (2 * K0) - 1 / kA55)], + ] + ) + + return zp + + def get_load_vector(self, phi: float, qs: float = 0) -> NDArray: + """ + Compute system load vector q. + + Using the solution vector z = [u, u', w, w', psi, psi'] + the ODE system is written in the form Az' + Bz = d + and rearranged to z' = -(A ^ -1)Bz + (A ^ -1)d = Kz + q + + Arguments + --------- + phi : float + Inclination [deg]. Counterclockwise positive. + qs : float + Surface Load [N/mm] + + Returns + ------- + ndarray + System load vector q (6x1). + """ + # Get weight and surface loads + qw_n, qw_t = decompose_to_normal_tangential(f=self.slab.qw, phi=phi) + qs_n, qs_t = decompose_to_normal_tangential(f=qs, phi=phi) + + return np.array( + [ + [0], + [ + ( + self.B11 * (self.slab.H * qs_t - 2 * qw_t * self.slab.z_cog) + + 2 * self.D11 * (qw_t + qs_t) + ) + / (2 * self.K0) + ], + [0], + [-(qw_n + qs_n) / self.kA55], + [0], + [ + -( + self.A11 * (self.slab.H * qs_t - 2 * qw_t * self.slab.z_cog) + + 2 * self.B11 * (qw_t + qs_t) + ) + / (2 * self.K0) + ], + ] + ) diff --git a/weac/core/field_quantities.py b/weac/core/field_quantities.py new file mode 100644 index 0000000..1f17782 --- /dev/null +++ b/weac/core/field_quantities.py @@ -0,0 +1,273 @@ +""" +This module defines the FieldQuantities class, which is responsible for calculating +and providing access to various physical quantities within the slab. +""" + +from typing import Literal + +import numpy as np + +from weac.core.eigensystem import Eigensystem + +LengthUnit = Literal["m", "cm", "mm", "um"] +AngleUnit = Literal["deg", "rad"] +StressUnit = Literal["Pa", "kPa", "MPa", "GPa"] +EnergyUnit = Literal["J/m^2", "kJ/m^2", "N/mm"] +Unit = Literal[LengthUnit, AngleUnit, StressUnit, EnergyUnit] + +_UNIT_FACTOR: dict[str, float] = { + "m": 1e-3, + "cm": 1e-1, + "mm": 1, + "um": 1e3, + "rad": 1, + "deg": 180 / np.pi, + "Pa": 1e6, + "kPa": 1e3, + "MPa": 1, + "GPa": 1e-3, + "J/m^2": 1e3, # joule per square meter + "kJ/m^2": 1, # kilojoule per square meter + "N/mm": 1, # newton per millimeter +} + + +class FieldQuantities: # pylint: disable=too-many-instance-attributes, too-many-public-methods + """ + Convenience accessors for a 6xN solution matrix Z = + [u, u', w, w', ψ, ψ']α΅€. All functions are *vectorized* along the second + axis (x-coordinate), so they return an `ndarray` of length N. + """ + + def __init__(self, eigensystem: Eigensystem): + self.es = eigensystem + + @staticmethod + def _unit_factor(unit: Unit, /) -> float: + """Return multiplicative factor associated with *unit*.""" + try: + return _UNIT_FACTOR[unit] + except KeyError as exc: + raise ValueError( + f"Unsupported unit: {unit!r}, supported units are {_UNIT_FACTOR}" + ) from exc + + def u( + self, + Z: np.ndarray, + h0: float = 0, + unit: LengthUnit = "mm", + ) -> float | np.ndarray: + """Horizontal displacement *u = uβ‚€ + hβ‚€ ψ* at depth hβ‚€.""" + return self._unit_factor(unit) * (Z[0, :] + h0 * self.psi(Z)) + + def du_dx(self, Z: np.ndarray, h0: float) -> float | np.ndarray: + """Derivative u' = uβ‚€' + hβ‚€ ψ'.""" + return Z[1, :] + h0 * self.dpsi_dx(Z) + + def w(self, Z: np.ndarray, unit: LengthUnit = "mm") -> float | np.ndarray: + """Center-line deflection *w*.""" + return self._unit_factor(unit) * Z[2, :] + + def dw_dx(self, Z: np.ndarray) -> float | np.ndarray: + """First derivative w'.""" + return Z[3, :] + + def psi( + self, + Z: np.ndarray, + unit: AngleUnit = "rad", + ) -> float | np.ndarray: + """Rotation ψ of the mid-plane.""" + factor = self._unit_factor(unit) + return factor * Z[4, :] + + def dpsi_dx(self, Z: np.ndarray) -> float | np.ndarray: + """First derivative Οˆβ€².""" + return Z[5, :] + + def N(self, Z: np.ndarray) -> float | np.ndarray: + """Axial normal force N = A11 u' + B11 psi' in the slab [N]""" + return self.es.A11 * Z[1, :] + self.es.B11 * Z[5, :] + + def M(self, Z: np.ndarray) -> float | np.ndarray: + """Bending moment M = B11 u' + D11 psi' in the slab [Nmm]""" + return self.es.B11 * Z[1, :] + self.es.D11 * Z[5, :] + + def V(self, Z: np.ndarray) -> float | np.ndarray: + """Vertical shear force V = kA55(w' + psi) [N]""" + return self.es.kA55 * (Z[3, :] + Z[4, :]) + + def sig(self, Z: np.ndarray, unit: StressUnit = "MPa") -> float | np.ndarray: + """Weak-layer normal stress""" + return -self._unit_factor(unit) * self.es.weak_layer.kn * self.w(Z) + + def tau(self, Z: np.ndarray, unit: StressUnit = "MPa") -> float | np.ndarray: + """Weak-layer shear stress""" + return ( + -self._unit_factor(unit) + * self.es.weak_layer.kt + * ( + self.dw_dx(Z) * self.es.weak_layer.h / 2 + - self.u(Z, h0=self.es.slab.H / 2) + ) + ) + + def eps(self, Z: np.ndarray) -> float | np.ndarray: + """Weak-layer normal strain""" + return -self.w(Z) / self.es.weak_layer.h + + def gamma(self, Z: np.ndarray) -> float | np.ndarray: + """Weak-layer shear strain.""" + return ( + self.dw_dx(Z) / 2 - self.u(Z, h0=self.es.slab.H / 2) / self.es.weak_layer.h + ) + + def Gi(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarray: + """Mode I differential energy release rate at crack tip. + + Arguments + --------- + Ztip : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T + at the crack tip. + unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional + Desired output unit. Default is kJ/m^2. + """ + return ( + self._unit_factor(unit) * self.sig(Ztip) ** 2 / (2 * self.es.weak_layer.kn) + ) + + def Gii(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarray: + """Mode II differential energy release rate at crack tip. + + Arguments + --------- + Ztip : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T + at the crack tip. + unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional + Desired output unit. Default is kJ/m^2 = N/mm. + """ + return ( + self._unit_factor(unit) * self.tau(Ztip) ** 2 / (2 * self.es.weak_layer.kt) + ) + + def dz_dx(self, z: np.ndarray, phi: float, qs: float = 0) -> np.ndarray: + """First derivative z'(x) = K*z(x) + q of the solution vector. + + z'(x) = [u'(x) u''(x) w'(x) w''(x) psi'(x), psi''(x)]^T + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray + First derivative z'(x) for the solution vector (6x1). + """ + K = self.es.K + q = self.es.get_load_vector(phi=phi, qs=qs) + return np.dot(K, z) + q + + def dz_dxdx(self, z: np.ndarray, phi: float, qs: float) -> np.ndarray: + """ + Get second derivative z''(x) = K*z'(x) of the solution vector. + + z''(x) = [u''(x) u'''(x) w''(x) w'''(x) psi''(x), psi'''(x)]^T + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray + Second derivative z''(x) = (K*z(x) + q)' = K*z'(x) = K*(K*z(x) + q) + of the solution vector (6x1). + """ + K = self.es.K + q = self.es.get_load_vector(phi=phi, qs=qs) + dz_dx = np.dot(K, z) + q + return np.dot(K, dz_dx) + + def du0_dxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray: + """ + Get second derivative of the horiz. centerline displacement u0''(x). + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray, float + Second derivative of the horizontal centerline displacement + u0''(x) (1/mm). + """ + return self.dz_dx(z, phi, qs)[1, :] + + def dpsi_dxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray: + """ + Get second derivative of the cross-section rotation psi''(x). + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray, float + Second derivative of the cross-section rotation psi''(x) (1/mm^2). + """ + return self.dz_dx(z, phi, qs)[5, :] + + def du0_dxdxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray: + """ + Get third derivative of the horiz. centerline displacement u0'''(x). + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray, float + Third derivative of the horizontal centerline displacement + u0'''(x) (1/mm^2). + """ + return self.dz_dxdx(z, phi, qs)[1, :] + + def dpsi_dxdxdx(self, z: np.ndarray, phi: float, qs: float) -> float | np.ndarray: + """ + Get third derivative of the cross-section rotation psi'''(x). + + Parameters + ---------- + z : ndarray + Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. + phi : float + Inclination (degrees). Counterclockwise positive. + + Returns + ------- + ndarray, float + Third derivative of the cross-section rotation psi'''(x) (1/mm^3). + """ + return self.dz_dxdx(z, phi, qs)[5, :] diff --git a/weac/core/scenario.py b/weac/core/scenario.py new file mode 100644 index 0000000..6e2887f --- /dev/null +++ b/weac/core/scenario.py @@ -0,0 +1,200 @@ +""" +This module defines the Scenario class, which encapsulates the physical setup of the model. +""" + +import logging +from typing import List, Sequence, Union + +import numpy as np + +from weac.components import ScenarioConfig, Segment, SystemType, WeakLayer +from weac.core.slab import Slab +from weac.utils.misc import decompose_to_normal_tangential + +logger = logging.getLogger(__name__) + + +class Scenario: + """ + Sets up the scenario on which the eigensystem is solved. + + Parameters + --------- + scenario_config: ScenarioConfig + segments: List[Segment] + weak_layer: WeakLayer + slab: Slab + + Attributes + ---------- + li : List[float] + length of segment i [mm] + ki : List[bool] + booleans indicating foundation support for segment i + mi : List[float] + skier masses (kg) on boundary of segment i and i+1 [kg] + + system_type : SystemType + phi : float + Angle of slab in positive in counter-clockwise direction [deg] + L : float + Length of the model [mm] + crack_h: float + Height of the crack [mm] + """ + + # Inputs + scenario_config: ScenarioConfig + segments: List[Segment] + weak_layer: WeakLayer + slab: Slab + + # Attributes + li: np.ndarray # length of segment i [mm] + ki: np.ndarray # booleans indicating foundation support for segment i + mi: np.ndarray # skier masses (kg) on boundary of segment i and i+1 [kg] + + cum_sum_li: np.ndarray # cumulative sum of segment lengths [mm] + + system_type: SystemType + phi: float # Angle in [deg] + surface_load: float # Surface Line-Load [N/mm] + qw: float # Weight Line-Load [N/mm] + qn: float # Total Normal Line-Load [N/mm] + qt: float # Total Tangential Line-Load [N/mm] + L: float # Length of the model [mm] + crack_h: float # Height of the crack [mm] + cut_length: float # Length of the cut [mm] + + def __init__( + self, + scenario_config: ScenarioConfig, + segments: List[Segment], + weak_layer: WeakLayer, + slab: Slab, + ): + self.scenario_config = scenario_config + self.segments = segments + self.weak_layer = weak_layer + self.slab = slab + + self.system_type = scenario_config.system_type + self.phi = scenario_config.phi + self.surface_load = scenario_config.surface_load + self.cut_length = scenario_config.cut_length + + self._setup_scenario() + self._calc_normal_load() + self._calc_tangential_load() + self._calc_crack_height() + + def refresh_from_config(self): + """Pull changed values out of scenario_config + and recompute derived attributes.""" + self.system_type = self.scenario_config.system_type + self.phi = self.scenario_config.phi + self.surface_load = self.scenario_config.surface_load + self.cut_length = self.scenario_config.cut_length + + self._setup_scenario() + self._calc_normal_load() + self._calc_tangential_load() + self._calc_crack_height() + + def get_segment_idx( + self, x: Union[float, Sequence[float], np.ndarray] + ) -> Union[int, np.ndarray]: + """ + Get the segment index for a given x-coordinate or coordinates. + + Parameters + ---------- + x: Union[float, Sequence[float], np.ndarray] + A single x-coordinate or a sequence of x-coordinates. + + Returns + ------- + Union[int, np.ndarray] + The segment index or an array of indices. + """ + x_arr = np.asarray(x) + indices = np.digitize(x_arr, self.cum_sum_li) + + if np.any(x_arr > self.L): + raise ValueError(f"Coordinate {x_arr} exceeds the slab length.") + + if x_arr.ndim == 0: + return int(indices) + + return indices + + def _setup_scenario(self): + self.li = np.array([seg.length for seg in self.segments]) + self.ki = np.array([seg.has_foundation for seg in self.segments]) + # masses that act *between* segments: take all but the last one + self.mi = np.array([seg.m for seg in self.segments[:-1]]) + self.cum_sum_li = np.cumsum(self.li) + + # Add dummy segment if only one segment provided + if len(self.li) == 1: + self.li = np.append(self.li, 0) + self.ki = np.append(self.ki, True) + self.mi = np.append(self.mi, 0) + + # Calculate the total slab length + self.L = np.sum(self.li) + + def _calc_tangential_load(self): + """ + Total Tangential Load (Surface Load + Weight Load) + + Returns: + -------- + qt : float + Tangential Component of Load [N/mm] + """ + # Surface Load & Weight Load + qw = self.slab.qw + qs = self.surface_load + + # Normal components of forces + phi = self.phi + _, qwt = decompose_to_normal_tangential(qw, phi) + _, qst = decompose_to_normal_tangential(qs, phi) + qt = qwt + qst + self.qt = qt + + def _calc_normal_load(self): + """ + Total Normal Load (Surface Load + Weight Load) + + Returns: + -------- + qn : float + Normal Component of Load [N/mm] + """ + # Surface Load & Weight Load + qw = self.slab.qw + qs = self.surface_load + + # Normal components of forces + phi = self.phi + qwn, _ = decompose_to_normal_tangential(qw, phi) + qsn, _ = decompose_to_normal_tangential(qs, phi) + qn = qwn + qsn + self.qn = qn + + def _calc_crack_height(self): + """ + Crack Height: Difference between collapsed weak layer and + Weak Layer (Winkler type) under slab load + + Example: + if the collapse layer has a height of 5 and the non-collapsed layer + has a height of 15 the collapse height is 10 + """ + self.crack_h = self.weak_layer.collapse_height - self.qn / self.weak_layer.kn + if self.crack_h < 0: + raise ValueError( + f"Crack height is negative: {self.crack_h} decrease the surface load" + ) diff --git a/weac/core/slab.py b/weac/core/slab.py new file mode 100644 index 0000000..100949d --- /dev/null +++ b/weac/core/slab.py @@ -0,0 +1,149 @@ +""" +This module defines the Slab class, which represents the snow slab and its properties. +""" + +from typing import List + +import numpy as np + +from weac.components import Layer +from weac.constants import EPS, G_MM_S2 + + +class Slab: # pylint: disable=too-many-instance-attributes,too-few-public-methods + """ + Parameters of all layers assembled into a slab, + provided as np.ndarray for easier access. + + Coordinate frame: + - z-axis points downward (first index: top layer, last index: bottom layer) + - z = 0 is set at the mid-point of the slab's thickness + + Attributes + ---------- + zi_mid: np.ndarray + z-coordinate of the layer i mid-point + zi_bottom: np.ndarray + z-coordinate of the layer i (boundary towards bottom) + rhoi: np.ndarray + densities of the layer i [t/mm^3] + hi: np.ndarray + thickness of the layer i [mm] + Ei: np.ndarray + Young's modulus of the layer i [MPa] + Gi: np.ndarray + Shear Modulus of the layer i [MPa] + nui: np.ndarray + Poisson Ratio of the layer i [-] + H: float + Total slab thickness (i.e. assembled layers) [mm] + z_cog: float + z-coordinate of Center of Gravity [mm] + qw: float + Weight Load of the slab [N/mm] + """ + + # Input data + layers: List[Layer] + + rhoi: np.ndarray # densities of the layer i [t/mm^3] + hi: np.ndarray # thickness of the layer i [mm] + Ei: np.ndarray # Young's modulus of the layer i [MPa] + Gi: np.ndarray # Shear Modulus of the layer i [MPa] + nui: np.ndarray # Poisson Ratio of the layer i [-] + + # Derived Values + z0: float # z-coordinate of the top of the slab + zi_mid: np.ndarray # z-coordinate of the layer i mid-point + zi_bottom: np.ndarray # z-coordinate of the layer i (boundary towards bottom) + H: float # Total slab thickness (i.e. assembled layers) [mm] + z_cog: float # z-coordinate of Center of Gravity [mm] + qw: float # Weight Load of the slab [N/mm] + + def __init__(self, layers: List[Layer]) -> None: + self.layers = layers + self._calc_slab_params() + + def calc_vertical_center_of_gravity(self, phi: float): + """ + Vertical PSTs use triangular slabs (with horizontal cuts on the slab ends) + Calculate center of gravity of triangular slab segments for vertical PSTs. + + Parameters + ---------- + phi : float + Slope angle [deg] + + Returns + ------- + x_cog : float + Horizontal coordinate of center of gravity [mm] + z_cog : float + Vertical coordinate of center of gravity [mm] + w : float + Weight of the slab segment that is cut off or added [t] + """ + # Convert slope angle to radians + phi = np.deg2rad(phi) + + # Catch flat-field case + if abs(phi) < EPS: + x_cog = 0 + z_cog = 0 + w = 0 + else: + n = len(self.hi) + rho = self.rhoi # [t/mm^3] + hi = self.hi # [mm] + H = self.H # [mm] + # Layer coordinates z_i (top to bottom) + z = np.array([-H / 2 + sum(hi[0:j]) for j in range(n + 1)]) + zi = z[:-1] + zii = z[1:] + # Center of gravity of all layers (top to bottom) derived from + # triangular slab geometry + zsi = zi + hi / 3 * (3 / 2 * H - zi - 2 * zii) / (H - zi - zii) + # Surface area of all layers (top to bottom), area = height * base / 2 + # where base varies with slope angle + Ai = hi / 2 * (H - zi - zii) * np.tan(phi) + # Center of gravity in vertical direction + z_cog = sum(zsi * rho * Ai) / sum(rho * Ai) + # Center of gravity in horizontal direction + x_cog = (H / 2 - z_cog) * np.tan(phi / 2) + # Weight of added or cut off slab segments (t) + w = sum(Ai * rho) + + # Return center of gravity and weight of slab segment + return x_cog, z_cog, w + + def _calc_slab_params(self) -> None: + rhoi = ( + np.array([ly.rho for ly in self.layers]) * 1e-12 + ) # Layer densities (kg/m^3 -> t/mm^3) + hi = np.array([ly.h for ly in self.layers]) # Layer thickness + Ei = np.array([ly.E for ly in self.layers]) + Gi = np.array([ly.G for ly in self.layers]) + nui = np.array([ly.nu for ly in self.layers]) + + H = hi.sum() + # Vectorized midpoint coordinates per layer (top to bottom) + # previously: zi_mid = [float(H / 2 - sum(hi[j:n]) + hi[j] / 2) for j in range(n)] + suffix_cumsum = np.cumsum(hi[::-1])[::-1] + zi_mid = H / 2 - suffix_cumsum + hi / 2 + zi_bottom = np.cumsum(hi) - H / 2 + z_cog = sum(zi_mid * hi * rhoi) / sum(hi * rhoi) + + qw = sum(rhoi * G_MM_S2 * hi) # Line load [N/mm] + + self.rhoi = rhoi + self.hi = hi + self.Ei = Ei + self.Gi = Gi + self.nui = nui + + self.zi_mid = zi_mid + self.zi_bottom = zi_bottom + self.z0 = -H / 2 # z-coordinate of the top of the slab + self.H = H + self.z_cog = z_cog + self.qw = qw diff --git a/weac/core/slab_touchdown.py b/weac/core/slab_touchdown.py new file mode 100644 index 0000000..7e07af3 --- /dev/null +++ b/weac/core/slab_touchdown.py @@ -0,0 +1,363 @@ +""" +This module handles the calculation of slab touchdown events. +Handling the touchdown situation in a PST. +""" + +import logging +from typing import Literal, Optional + +from scipy.optimize import brentq + +from weac.components.layer import WeakLayer +from weac.components.scenario_config import ScenarioConfig +from weac.components.segment import Segment +from weac.constants import STIFFNESS_COLLAPSE_FACTOR +from weac.core.eigensystem import Eigensystem +from weac.core.field_quantities import FieldQuantities +from weac.core.scenario import Scenario +from weac.core.unknown_constants_solver import UnknownConstantsSolver + +logger = logging.getLogger(__name__) + + +class SlabTouchdown: # pylint: disable=too-many-instance-attributes,too-few-public-methods + """ + Handling the touchdown situation in a PST. + Calculations follow paper Rosendahl et al. (2024) + `The effect of slab touchdown on anticrack arrest in propagation saw tests` + + Types of Touchdown: + `A_free_hanging` : Slab is free hanging (not in contact with the collapsed weak layer) + touchdown_distance `=` cut_length -> the unsupported segment (touchdown_distance) + equals the cut length + `B_point_contact` : End of slab is in contact with the collapsed weak layer + touchdown_distance `=` cut_length -> the unsupported segment (touchdown_distance) + equals the cut length + `C_in_contact` : more of the slab is in contact with the collapsed weak layer + touchdown_distance `<` cut_length -> the unsupported segment (touchdown_distance) + is strictly smaller than the cut length + + The Module does: + 1. Calculation of Zones of modes `[A_free_hanging, B_point_contact, C_in_contact]`:: + + |+++++++++++++++++++|-------A-------|-------B-------|--------C-------- [...] + | supported segment | free-hanging | point contact | in contact + 0 `l_AB` `l_BC` + through calculation of boundary touchdown_distance `l_AB` and `l_BC` + + Parameters: + ----------- + scenario: `Scenario` + eigensystem: `Eigensystem` + + Attributes: + ----------- + l_AB : float + Length of the crack for transition of stage A to stage B [mm] + l_BC : float + Length of the crack for transition of stage B to stage C [mm] + touchdown_mode : Literal["A_free_hanging", "B_point_contact", "C_in_contact"] + Type of touchdown mode + touchdown_distance : float + Length of the touchdown segment [mm] + collapsed_weak_layer_kR : Optional[float] + Rotational spring stiffness of the collapsed weak layer segment + """ + + # Inputs + scenario: Scenario + eigensystem: Eigensystem + + # Attributes + collapsed_weak_layer: WeakLayer # WeakLayer with modified stiffness + collapsed_eigensystem: Eigensystem + straight_scenario: Scenario + l_AB: float + l_BC: float + touchdown_mode: Literal[ + "A_free_hanging", "B_point_contact", "C_in_contact" + ] # Three types of contact with collapsed weak layer + touchdown_distance: float + collapsed_weak_layer_kR: Optional[float] = None + + def __init__(self, scenario: Scenario, eigensystem: Eigensystem): + self.scenario = scenario + self.eigensystem = eigensystem + + # Create a new scenario config with phi=0 (flat slab) while preserving other settings + self.flat_config = ScenarioConfig( + phi=0.0, # Flat slab for collapsed scenario + system_type=self.scenario.scenario_config.system_type, + cut_length=self.scenario.scenario_config.cut_length, + stiffness_ratio=self.scenario.scenario_config.stiffness_ratio, + surface_load=self.scenario.scenario_config.surface_load, + ) + + self.collapsed_eigensystem = self._create_collapsed_eigensystem() + + self._setup_touchdown_system() + + def _setup_touchdown_system(self): + """Calculate touchdown""" + self._calc_touchdown_mode() + self._calc_touchdown_distance() + + def _calc_touchdown_mode(self): + """Calculate touchdown-mode from thresholds""" + # Calculate stage transitions + try: + self.l_AB = self._calc_l_AB() + except ValueError: + self.l_AB = self.scenario.L + try: + self.l_BC = self._calc_l_BC() + except ValueError: + self.l_BC = self.scenario.L + # Assign stage + touchdown_mode = "A_free_hanging" + if self.scenario.cut_length <= self.l_AB: + touchdown_mode = "A_free_hanging" + elif self.l_AB < self.scenario.cut_length <= self.l_BC: + touchdown_mode = "B_point_contact" + elif self.l_BC < self.scenario.cut_length: + touchdown_mode = "C_in_contact" + self.touchdown_mode = touchdown_mode + + def _calc_touchdown_distance(self): + """Calculate touchdown distance""" + if self.touchdown_mode in ["A_free_hanging"]: + self.touchdown_distance = self.scenario.cut_length + elif self.touchdown_mode in ["B_point_contact"]: + self.touchdown_distance = self.scenario.cut_length + elif self.touchdown_mode in ["C_in_contact"]: + self.touchdown_distance = self._calc_touchdown_distance_in_mode_C() + self.collapsed_weak_layer_kR = self._calc_collapsed_weak_layer_kR() + + def _calc_l_AB(self): + """ + Calc transition lengths l_AB + + Returns + ------- + l_AB : float + Length of the crack for transition of stage A to stage B [mm] + """ + # Unpack variables + bs = -(self.eigensystem.B11**2 / self.eigensystem.A11 - self.eigensystem.D11) + ss = self.eigensystem.kA55 + L = self.scenario.L + crack_h = self.scenario.crack_h + qn = self.scenario.qn + + # Create polynomial expression + def polynomial(x: float) -> float: + # Spring stiffness of uncollapsed eigensystem of length L - x + straight_scenario = self._generate_straight_scenario(L - x) + kRl = self._substitute_stiffness( + straight_scenario, self.eigensystem, "rot" + ) # rotational stiffness + kNl = self._substitute_stiffness( + straight_scenario, self.eigensystem, "trans" + ) # pulling stiffness + c1 = 1 / (8 * bs) + c2 = 1 / (2 * kRl) + c3 = 1 / (2 * ss) + c4 = 1 / kNl + c5 = -crack_h / qn + return c1 * x**4 + c2 * x**3 + c3 * x**2 + c4 * x + c5 + + # Find root + l_AB = brentq(polynomial, L / 1000, 999 / 1000 * L) + + return l_AB + + def _calc_l_BC(self) -> float: + """ + Calc transition lengths l_BC + + Returns + ------- + l_BC : float + Length of the crack for transition of stage B to stage C [mm] + """ + # Unpack variables + bs = -(self.eigensystem.B11**2 / self.eigensystem.A11 - self.eigensystem.D11) + ss = self.eigensystem.kA55 + L = self.scenario.L + crack_h = self.scenario.crack_h + qn = self.scenario.qn + + # Create polynomial function + def polynomial(x: float) -> float: + # Spring stiffness of uncollapsed eigensystem of length L - x + straight_scenario = self._generate_straight_scenario(L - x) + kRl = self._substitute_stiffness(straight_scenario, self.eigensystem, "rot") + kNl = self._substitute_stiffness( + straight_scenario, self.eigensystem, "trans" + ) + c1 = ss**2 * kRl * kNl * qn + c2 = 6 * ss**2 * bs * kNl * qn + c3 = 30 * bs * ss * kRl * kNl * qn + c4 = 24 * bs * qn * (2 * ss**2 * kRl + 3 * bs * ss * kNl) + c5 = 72 * bs * (bs * qn * (ss**2 + kRl * kNl) - ss**2 * kRl * kNl * crack_h) + c6 = 144 * bs * ss * (bs * kRl * qn - bs * ss * kNl * crack_h) + c7 = -144 * bs**2 * ss * kRl * kNl * crack_h + return ( + c1 * x**6 + c2 * x**5 + c3 * x**4 + c4 * x**3 + c5 * x**2 + c6 * x + c7 + ) + + # Find root + l_BC = brentq(polynomial, L / 1000, 999 / 1000 * L) + + return l_BC + + def _create_collapsed_eigensystem(self) -> Eigensystem: + """ + Create the collapsed weak layer and eigensystem with modified stiffness values. + This centralizes all collapsed-related logic within the SlabTouchdown class. + """ + # Create collapsed weak layer with increased stiffness + self.collapsed_weak_layer = self.scenario.weak_layer.model_copy( + update={ + "kn": self.scenario.weak_layer.kn * STIFFNESS_COLLAPSE_FACTOR, + "kt": self.scenario.weak_layer.kt * STIFFNESS_COLLAPSE_FACTOR, + } + ) + + # Create eigensystem for the collapsed weak layer + return Eigensystem( + weak_layer=self.collapsed_weak_layer, slab=self.scenario.slab + ) + + def _calc_touchdown_distance_in_mode_C(self) -> float: + """ + Calculate the length of the touchdown element in mode C + when the slab is in contact. + """ + # Unpack variables + bs = -(self.eigensystem.B11**2 / self.eigensystem.A11 - self.eigensystem.D11) + ss = self.eigensystem.kA55 + L = self.scenario.L + cut_length = self.scenario.cut_length + crack_h = self.scenario.crack_h + qn = self.scenario.qn + + # Spring stiffness of uncollapsed eigensystem of length L - cut_length + straight_scenario = self._generate_straight_scenario(L - cut_length) + kRl = self._substitute_stiffness(straight_scenario, self.eigensystem, "rot") + kNl = self._substitute_stiffness(straight_scenario, self.eigensystem, "trans") + + def polynomial(x: float) -> float: + logger.debug("Eval. Slab Geometry with Touchdown Distance x=%.2f mm", x) + # Spring stiffness of collapsed eigensystem of length cut_length - x + straight_scenario = self._generate_straight_scenario(cut_length - x) + kRr = self._substitute_stiffness( + straight_scenario, self.collapsed_eigensystem, "rot" + ) + # define constants + c1 = ss**2 * kRl * kNl * qn + c2 = 6 * ss * kNl * qn * (bs * ss + kRl * kRr) + c3 = 30 * bs * ss * kNl * qn * (kRl + kRr) + c4 = ( + 24 + * bs + * qn + * (2 * ss**2 * kRl + 3 * bs * ss * kNl + 3 * kRl * kRr * kNl) + ) + c5 = ( + 72 + * bs + * ( + bs * qn * (ss**2 + kNl * (kRl + kRr)) + + ss * kRl * (2 * kRr * qn - ss * kNl * crack_h) + ) + ) + c6 = ( + 144 + * bs + * ss + * (bs * qn * (kRl + kRr) - kNl * crack_h * (bs * ss + kRl * kRr)) + ) + c7 = -144 * bs**2 * ss * kNl * crack_h * (kRl + kRr) + return ( + c1 * x**6 + c2 * x**5 + c3 * x**4 + c4 * x**3 + c5 * x**2 + c6 * x + c7 + ) + + # Find root + touchdown_distance = brentq( + polynomial, cut_length / 1000, 999 / 1000 * cut_length + ) + + return touchdown_distance + + def _calc_collapsed_weak_layer_kR(self) -> float: + """ + Calculate the rotational stiffness of the collapsed weak layer + """ + straight_scenario = self._generate_straight_scenario( + self.scenario.cut_length - self.touchdown_distance + ) + kR = self._substitute_stiffness( + straight_scenario, self.collapsed_eigensystem, "rot" + ) + return kR + + def _generate_straight_scenario(self, L: float) -> Scenario: + """ + Generate a straight scenario with a given length. + """ + segments = [Segment(length=L, has_foundation=True, m=0)] + straight_scenario = Scenario( + scenario_config=self.flat_config, + segments=segments, + weak_layer=self.scenario.weak_layer, + slab=self.scenario.slab, + ) + return straight_scenario + + def _substitute_stiffness( + self, + scenario: Scenario, + eigensystem: Eigensystem, + dof: Literal["rot", "trans"] = "rot", + ) -> float: + """ + Calc substitute stiffness for beam on elastic foundation. + + Arguments + --------- + dof : string + Type of substitute spring, either 'rot' or 'trans'. Defaults to 'rot'. + + Returns + ------- + has_foundation : stiffness of substitute spring. + """ + + unknown_constants = UnknownConstantsSolver.solve_for_unknown_constants( + scenario=scenario, eigensystem=eigensystem, system_type=dof + ) + + # Calculate field quantities at x=0 (left end) + Zh0 = eigensystem.zh(x=0, length=scenario.L, has_foundation=True) + zp0 = eigensystem.zp(x=0, phi=0, has_foundation=True, qs=0) + C_at_x0 = unknown_constants[:, 0].reshape(-1, 1) # Ensure column vector + z_at_x0 = Zh0 @ C_at_x0 + zp0 + + # Calculate stiffness based on field quantities + fq = FieldQuantities(eigensystem=eigensystem) + + stiffness = None + if dof in ["rot"]: + # For rotational stiffness: has_foundation = M / psi + # Uses M = 1.0 for the moment of inertia. + psi_val = fq.psi(z_at_x0)[0] # Extract scalar value from the result + stiffness = abs(1 / psi_val) if abs(psi_val) > 1e-12 else 1e12 + elif dof in ["trans"]: + # For translational stiffness: has_foundation = V / w + # Uses w = 1.0 for the weight of the slab. + w_val = fq.w(z_at_x0)[0] # Extract scalar value from the result + stiffness = abs(1 / w_val) if abs(w_val) > 1e-12 else 1e12 + if stiffness is None: + raise ValueError(f"Stiffness for {dof} is None") + return stiffness diff --git a/weac/core/system_model.py b/weac/core/system_model.py new file mode 100644 index 0000000..621e9f8 --- /dev/null +++ b/weac/core/system_model.py @@ -0,0 +1,413 @@ +""" +This module defines the system model for the WEAC simulation. +The system model is the heart of the WEAC simulation. All data sources +are bundled into the system model. The system model initializes and +calculates all the parameterizations and passes relevant data to the +different components. + +We utilize the pydantic library to define the system model. +""" + +import copy +import logging +from collections.abc import Sequence +from functools import cached_property +from typing import List, Optional, Union + +import numpy as np + +# from weac.constants import G_MM_S2, LSKI_MM +from weac.components import ( + Config, + Layer, + ModelInput, + ScenarioConfig, + Segment, + WeakLayer, +) +from weac.core.eigensystem import Eigensystem +from weac.core.field_quantities import FieldQuantities +from weac.core.scenario import Scenario +from weac.core.slab import Slab +from weac.core.slab_touchdown import SlabTouchdown +from weac.core.unknown_constants_solver import UnknownConstantsSolver + +logger = logging.getLogger(__name__) + + +class SystemModel: + """ + The heart of the WEAC simulation system for avalanche release modeling. + + This class orchestrates all components of the WEAC simulation, including slab mechanics, + weak layer properties, touchdown calculations, and the solution of unknown constants + for beam-on-elastic-foundation problems. + + The SystemModel follows a lazy evaluation pattern using cached properties, meaning + expensive calculations (eigensystem, touchdown, unknown constants) are only computed + when first accessed and then cached for subsequent use. + + **Extracting Unknown Constants:** + + The primary output of the SystemModel is the `unknown_constants` matrix, which contains + the solution constants for the beam segments: + + ```python + # Basic usage + system = SystemModel(model_input=model_input, config=config) + constants = system.unknown_constants # Shape: (6, N) where N = number of segments + + # Each column represents the 6 constants for one segment: + # constants[:, i] = [C1, C2, C3, C4, C5, C6] for segment i + # These constants define the beam deflection solution within that segment + ``` + + **Calculation Flow:** + + 1. **Eigensystem**: Computes eigenvalues/eigenvectors for the beam-foundation system + 2. **Slab Touchdown** (if enabled): Calculates touchdown behavior and updates segment lengths + 3. **Unknown Constants**: Solves the linear system for beam deflection constants + + **Touchdown Behavior:** + + When `config.touchdown=True`, the system automatically: + - Calculates touchdown mode (A: free-hanging, B: point contact, C: in contact) + - Determines touchdown length based on slab-foundation interaction + - **Redefines scenario segments** to use touchdown length instead of crack length + - This matches the behavior of the original WEAC implementation + + **Performance Notes:** + + - First access to `unknown_constants` triggers all necessary calculations + - Subsequent accesses return cached results instantly + - Use `update_*` methods to modify parameters and invalidate caches as needed + + **Example Usage:** + + ```python + from weac.components import ModelInput, Layer, Segment, Config + from weac.core.system_model import SystemModel + + # Define system components + layers = [Layer(rho=200, h=150), Layer(rho=300, h=100)] + segments = [Segment(length=10000, has_foundation=True, m=0), + Segment(length=4000, has_foundation=False, m=0)] + + # Create system + system = SystemModel(model_input=model_input, config=Config(touchdown=True)) + + # Solve system and extract results + constants = system.unknown_constants # Solution constants (6 x N_segments) + touchdown_info = system.slab_touchdown # Touchdown analysis (if enabled) + eigensystem = system.eigensystem # Eigenvalue problem solution + ``` + + Attributes: + config: Configuration settings including touchdown enable/disable + slab: Slab properties (thickness, material properties per layer) + weak_layer: Weak layer properties (stiffness, thickness, etc.) + scenario: Scenario definition (segments, loads, boundary conditions) + eigensystem: Eigenvalue problem solution (computed lazily) + slab_touchdown: Touchdown analysis results (computed lazily if enabled) + unknown_constants: Solution constants matrix (computed lazily) + """ + + config: Config + slab: Slab + weak_layer: WeakLayer + eigensystem: Eigensystem + fq: FieldQuantities + + scenario: Scenario + slab_touchdown: Optional[SlabTouchdown] + unknown_constants: np.ndarray + uncracked_unknown_constants: np.ndarray + + def __init__(self, model_input: ModelInput, config: Optional[Config] = None): + if config is None: + config = Config() + self.config = config + self.weak_layer = model_input.weak_layer + self.slab = Slab(layers=model_input.layers) + self.scenario = Scenario( + scenario_config=model_input.scenario_config, + segments=model_input.segments, + weak_layer=self.weak_layer, + slab=self.slab, + ) + logger.info("Scenario setup") + + # At this point only the system is initialized + # The solution to the system (unknown_constants) are only computed + # when required by the user (at runtime) + + # Cached properties are invalidated via __dict__.pop in the *invalidate_* helpers. + + @cached_property + def fq(self) -> FieldQuantities: + """Compute the field quantities.""" + return FieldQuantities(eigensystem=self.eigensystem) + + @cached_property + def eigensystem(self) -> Eigensystem: # heavy + """Solve for the eigensystem.""" + logger.info("Solving for Eigensystem") + return Eigensystem(weak_layer=self.weak_layer, slab=self.slab) + + @cached_property + def slab_touchdown(self) -> Optional[SlabTouchdown]: + """ + Solve for the slab touchdown. + Modifies the scenario object in place by replacing the undercut segment + with a new segment of length equal to the touchdown distance if the system is + a PST or VPST. + """ + if self.config.touchdown: + logger.info("Solving for Slab Touchdown") + slab_touchdown = SlabTouchdown( + scenario=self.scenario, eigensystem=self.eigensystem + ) + logger.info( + "Original cut_length: %s, touchdown_distance: %s", + self.scenario.cut_length, + slab_touchdown.touchdown_distance, + ) + + new_segments = copy.deepcopy(self.scenario.segments) + if self.scenario.system_type in ("pst-", "vpst-"): + new_segments[-1].length = slab_touchdown.touchdown_distance + elif self.scenario.system_type in ("-pst", "-vpst"): + new_segments[0].length = slab_touchdown.touchdown_distance + + # Create new scenario with updated segments + self.scenario = Scenario( + scenario_config=self.scenario.scenario_config, + segments=new_segments, + weak_layer=self.weak_layer, + slab=self.slab, + ) + logger.info( + "Updated scenario with new segment lengths: %s", + [seg.length for seg in new_segments], + ) + + return slab_touchdown + return None + + @cached_property + def unknown_constants(self) -> np.ndarray: + """ + Solve for the unknown constants matrix defining beam deflection in each segment. + + This is the core solution of the WEAC beam-on-elastic-foundation problem. + The unknown constants define the deflection, slope, moment, and shear force + distributions within each beam segment. + + Returns: + -------- + np.ndarray: Solution constants matrix of shape (6, N_segments) + Each column contains the 6 constants for one segment: + [C1, C2, C3, C4, C5, C6] + + These constants are used in the general solution: + u(x) = Ξ£ Ci * Ο†i(x) + up(x) + + Where Ο†i(x) are the homogeneous solutions and up(x) + is the particular solution. + + Notes: + - For touchdown systems, segment lengths are automatically adjusted + based on touchdown calculations before solving + - The solution accounts for boundary conditions, load transmission + between segments, and foundation support + - Results are cached after first computation for performance + + Example: + ```python + system = SystemModel(model_input, config) + C = system.unknown_constants # Shape: (6, 2) for 2-segment system + + # Constants for first segment + segment_0_constants = C[:, 0] + + # Use with eigensystem to compute field quantities + x = 1000 # Position in mm + segment_length = system.scenario.li[0] + ``` + """ + if self.slab_touchdown is not None: + logger.info("Solving for Unknown Constants") + return UnknownConstantsSolver.solve_for_unknown_constants( + scenario=self.scenario, + eigensystem=self.eigensystem, + system_type=self.scenario.system_type, + touchdown_distance=self.slab_touchdown.touchdown_distance, + touchdown_mode=self.slab_touchdown.touchdown_mode, + collapsed_weak_layer_kR=self.slab_touchdown.collapsed_weak_layer_kR, + ) + logger.info("Solving for Unknown Constants") + return UnknownConstantsSolver.solve_for_unknown_constants( + scenario=self.scenario, + eigensystem=self.eigensystem, + system_type=self.scenario.system_type, + touchdown_distance=None, + touchdown_mode=None, + collapsed_weak_layer_kR=None, + ) + + @cached_property + def uncracked_unknown_constants(self) -> np.ndarray: + """ + Solve for the uncracked unknown constants. + This is the solution for the case where the slab is cracked nowhere. + """ + new_segments = copy.deepcopy(self.scenario.segments) + for _, seg in enumerate(new_segments): + seg.has_foundation = True + uncracked_scenario = Scenario( + scenario_config=self.scenario.scenario_config, + segments=new_segments, + weak_layer=self.weak_layer, + slab=self.slab, + ) + + logger.info("Solving for Uncracked Unknown Constants") + if self.slab_touchdown is not None: + return UnknownConstantsSolver.solve_for_unknown_constants( + scenario=uncracked_scenario, + eigensystem=self.eigensystem, + system_type=self.scenario.system_type, + touchdown_distance=self.slab_touchdown.touchdown_distance, + touchdown_mode=self.slab_touchdown.touchdown_mode, + collapsed_weak_layer_kR=self.slab_touchdown.collapsed_weak_layer_kR, + ) + return UnknownConstantsSolver.solve_for_unknown_constants( + scenario=uncracked_scenario, + eigensystem=self.eigensystem, + system_type=self.scenario.system_type, + touchdown_distance=None, + touchdown_mode=None, + collapsed_weak_layer_kR=None, + ) + + # Changes that affect the *weak layer* -> rebuild everything + def update_weak_layer(self, weak_layer: WeakLayer): + """Update the weak layer.""" + self.weak_layer = weak_layer + self.scenario = Scenario( + scenario_config=self.scenario.scenario_config, + segments=self.scenario.segments, + weak_layer=weak_layer, + slab=self.slab, + ) + self._invalidate_eigensystem() + + # Changes that affect the *slab* -> rebuild everything + def update_layers(self, new_layers: List[Layer]): + """Update the layers.""" + slab = Slab(layers=new_layers) + self.slab = slab + self.scenario = Scenario( + scenario_config=self.scenario.scenario_config, + segments=self.scenario.segments, + weak_layer=self.weak_layer, + slab=slab, + ) + self._invalidate_eigensystem() + + # Changes that affect the *scenario* -> only rebuild C constants + def update_scenario( + self, + segments: Optional[List[Segment]] = None, + scenario_config: Optional[ScenarioConfig] = None, + ): + """ + Update fields on `scenario_config` (if present) or on the + Scenario object itself, then refresh and invalidate constants. + """ + logger.debug("Updating Scenario...") + if segments is None: + segments = self.scenario.segments + if scenario_config is None: + scenario_config = self.scenario.scenario_config + self.scenario = Scenario( + scenario_config=scenario_config, + segments=segments, + weak_layer=self.weak_layer, + slab=self.slab, + ) + if self.config.touchdown: + self._invalidate_slab_touchdown() + self._invalidate_constants() + + def toggle_touchdown(self, touchdown: bool): + """Toggle the touchdown.""" + if self.config.touchdown != touchdown: + self.config.touchdown = touchdown + self._invalidate_slab_touchdown() + self._invalidate_constants() + + def _invalidate_eigensystem(self): + """Invalidate the eigensystem.""" + self.__dict__.pop("eigensystem", None) + self.__dict__.pop("slab_touchdown", None) + self.__dict__.pop("fq", None) + self._invalidate_constants() + + def _invalidate_slab_touchdown(self): + """Invalidate the slab touchdown.""" + self.__dict__.pop("slab_touchdown", None) + + def _invalidate_constants(self): + """Invalidate the constants.""" + self.__dict__.pop("unknown_constants", None) + self.__dict__.pop("uncracked_unknown_constants", None) + + def z( + self, + x: Union[float, Sequence[float], np.ndarray], + C: np.ndarray, + length: float, + phi: float, + has_foundation: bool = True, + qs: float = 0, + ) -> np.ndarray: + """ + Assemble solution vector at positions x. + + Arguments + --------- + x : float or sequence + Horizontal coordinate (mm). Can be sequence of length N. + C : ndarray + Vector of constants (6xN) at positions x. + length : float + Segment length (mm). + phi : float + Inclination (degrees). + has_foundation : bool + Indicates whether segment has foundation (True) or not + (False). Default is True. + qs : float + Surface Load [N/mm] + + Returns + ------- + z : ndarray + Solution vector (6xN) at position x. + """ + if isinstance(x, (list, tuple, np.ndarray)): + z = np.concatenate( + [ + np.dot(self.eigensystem.zh(xi, length, has_foundation), C) + + self.eigensystem.zp(xi, phi, has_foundation, qs) + for xi in x + ], + axis=1, + ) + else: + z = np.dot( + self.eigensystem.zh(x, length, has_foundation), C + ) + self.eigensystem.zp(x, phi, has_foundation, qs) + + return z diff --git a/weac/core/unknown_constants_solver.py b/weac/core/unknown_constants_solver.py new file mode 100644 index 0000000..f361810 --- /dev/null +++ b/weac/core/unknown_constants_solver.py @@ -0,0 +1,444 @@ +""" +This module defines the system model for the WEAC simulation. The system +model is the heart of the WEAC simulation. All data sources are bundled into +the system model. The system model initializes and calculates all the +parameterizations and passes relevant data to the different components. + +We utilize the pydantic library to define the system model. +""" + +import logging +from typing import Literal, Optional + +import numpy as np +from numpy.linalg import LinAlgError + +from weac.components import SystemType +from weac.constants import G_MM_S2 +from weac.core.eigensystem import Eigensystem +from weac.core.field_quantities import FieldQuantities +from weac.core.scenario import Scenario + +# from weac.constants import G_MM_S2, LSKI_MM +from weac.utils.misc import decompose_to_normal_tangential, get_skier_point_load + +logger = logging.getLogger(__name__) + + +class UnknownConstantsSolver: + """ + This class solves the unknown constants for the WEAC simulation. + """ + + @classmethod + def solve_for_unknown_constants( + cls, + scenario: Scenario, + eigensystem: Eigensystem, + system_type: SystemType, + touchdown_distance: Optional[float] = None, + touchdown_mode: Optional[ + Literal["A_free_hanging", "B_point_contact", "C_in_contact"] + ] = None, + collapsed_weak_layer_kR: Optional[float] = None, + ) -> np.ndarray: + """ + Compute free constants *C* for system. \\ + Assemble LHS from supported and unsupported segments in the form:: + + [ ] [ zh1 0 0 ... 0 0 0 ][ ] [ ] [ ] (left) + [ ] [ zh1 zh2 0 ... 0 0 0 ][ ] [ ] [ ] (mid) + [ ] [ 0 zh2 zh3 ... 0 0 0 ][ ] [ ] [ ] (mid) + [z0] = [ ... ... ... ... ... ... ... ][ C ] + [ zp ] = [ rhs ] (mid) + [ ] [ 0 0 0 ... zhL zhM 0 ][ ] [ ] [ ] (mid) + [ ] [ 0 0 0 ... 0 zhM zhN ][ ] [ ] [ ] (mid) + [ ] [ 0 0 0 ... 0 0 zhN ][ ] [ ] [ ] (right) + + and solve for constants C. + + Returns + ------- + C : ndarray + Matrix(6xN) of solution constants for a system of N + segements. Columns contain the 6 constants of each segement. + """ + logger.debug("Starting solve unknown constants") + phi = scenario.phi + qs = scenario.surface_load + li = scenario.li + ki = scenario.ki + mi = scenario.mi + + # Determine size of linear system of equations + nS = len(li) # Number of beam segments + nDOF = 6 # Number of free constants per segment + logger.debug("Number of segments: %s, DOF per segment: %s", nS, nDOF) + + # Assemble position vector + pi = np.full(nS, "m") + pi[0], pi[-1] = "length", "r" + + # Initialize matrices + Zh0 = np.zeros([nS * 6, nS * nDOF]) + Zp0 = np.zeros([nS * 6, 1]) + rhs = np.zeros([nS * 6, 1]) + logger.debug( + "Initialized Zh0 shape: %s, Zp0 shape: %s, rhs shape: %s", + Zh0.shape, + Zp0.shape, + rhs.shape, + ) + + # LHS: Transmission & Boundary Conditions between segments + for i in range(nS): + # Length, foundation and position of segment i + length, has_foundation, pos = li[i], ki[i], pi[i] + + logger.debug( + "Assembling segment %s: length=%s, has_foundation=%s, pos=%s", + i, + length, + has_foundation, + pos, + ) + # Matrix of Size one of: (l: [9,6], m: [12,6], r: [9,6]) + Zhi = cls._setup_conditions( + zl=eigensystem.zh(x=0, length=length, has_foundation=has_foundation), + zr=eigensystem.zh( + x=length, length=length, has_foundation=has_foundation + ), + eigensystem=eigensystem, + has_foundation=has_foundation, + pos=pos, + touchdown_mode=touchdown_mode, + system_type=system_type, + collapsed_weak_layer_kR=collapsed_weak_layer_kR, + ) + # Vector of Size one of: (l: [9,1], m: [12,1], r: [9,1]) + zpi = cls._setup_conditions( + zl=eigensystem.zp(x=0, phi=phi, has_foundation=has_foundation, qs=qs), + zr=eigensystem.zp( + x=length, phi=phi, has_foundation=has_foundation, qs=qs + ), + eigensystem=eigensystem, + has_foundation=has_foundation, + pos=pos, + touchdown_mode=touchdown_mode, + system_type=system_type, + collapsed_weak_layer_kR=collapsed_weak_layer_kR, + ) + + # Rows for left-hand side assembly + start = 0 if i == 0 else 3 + stop = 6 if i == nS - 1 else 9 + # Assemble left-hand side + Zh0[(6 * i - start) : (6 * i + stop), i * nDOF : (i + 1) * nDOF] = Zhi + Zp0[(6 * i - start) : (6 * i + stop)] += zpi + logger.debug( + "Segment %s: Zhi shape: %s, zpi shape: %s", i, Zhi.shape, zpi.shape + ) + + # Loop through loads to assemble right-hand side + for i, m in enumerate(mi, start=1): + # Get skier point-load + F = get_skier_point_load(m) + Fn, Ft = decompose_to_normal_tangential(f=F, phi=phi) + # Right-hand side for transmission from segment i-1 to segment i + rhs[6 * i : 6 * i + 3] = np.vstack([Ft, -Ft * scenario.slab.H / 2, Fn]) + logger.debug("Load %s: m=%s, F=%s, Fn=%s, Ft=%s", i, m, F, Fn, Ft) + logger.debug("RHS %s", rhs[6 * i : 6 * i + 3]) + # Set RHS so that Complementary Integral vanishes at boundaries + if system_type not in ["pst-", "-pst", "rested"]: + logger.debug("Pre RHS %s", rhs[:3]) + rhs[:3] = cls._boundary_conditions( + eigensystem.zp(x=0, phi=phi, has_foundation=ki[0], qs=qs), + eigensystem, + False, + "mid", + system_type, + touchdown_mode, + collapsed_weak_layer_kR, + ) + logger.debug("Post RHS %s", rhs[:3]) + rhs[-3:] = cls._boundary_conditions( + eigensystem.zp(x=li[-1], phi=phi, has_foundation=ki[-1], qs=qs), + eigensystem, + False, + "mid", + system_type, + touchdown_mode, + collapsed_weak_layer_kR, + ) + logger.debug("Post RHS %s", rhs[-3:]) + logger.debug("Set complementary integral vanishing at boundaries.") + + # Set rhs for vertical faces + if system_type in ["vpst-", "-vpst"]: + # Calculate center of gravity and mass of added or cut off slab segement + x_cog, z_cog, m = scenario.slab.calc_vertical_center_of_gravity(phi) + logger.debug( + "Vertical center of gravity: x_cog=%s, z_cog=%s, m=%s", x_cog, z_cog, m + ) + # Convert slope angle to radians + phi = np.deg2rad(phi) + # Translate into section forces and moments + N = -G_MM_S2 * m * np.sin(phi) + M = -G_MM_S2 * m * (x_cog * np.cos(phi) + z_cog * np.sin(phi)) + V = G_MM_S2 * m * np.cos(phi) + # Add to right-hand side + rhs[:3] = np.vstack([N, M, V]) # left end + rhs[-3:] = np.vstack([N, M, V]) # right end + logger.debug("Vertical faces: N=%s, M=%s, V=%s", N, M, V) + + # Loop through segments to set touchdown conditions at rhs + for i in range(nS): + # Length, foundation and position of segment i + length, has_foundation, pos = li[i], ki[i], pi[i] + # Set displacement BC in stage B + if not has_foundation and bool(touchdown_mode in ["B_point_contact"]): + if i == 0: + rhs[:3] = np.vstack([0, 0, scenario.crack_h]) + if i == (nS - 1): + rhs[-3:] = np.vstack([0, 0, scenario.crack_h]) + # Set normal force and displacement BC for stage C + if not has_foundation and bool(touchdown_mode in ["C_in_contact"]): + N = scenario.qt * (scenario.cut_length - touchdown_distance) + if i == 0: + rhs[:3] = np.vstack([-N, 0, scenario.crack_h]) + if i == (nS - 1): + rhs[-3:] = np.vstack([N, 0, scenario.crack_h]) + + # Rhs for substitute spring stiffness + if system_type in ["rot"]: + # apply arbitrary moment of 1 at left boundary + rhs = rhs * 0 + rhs[1] = 1 + if system_type in ["trans"]: + # apply arbitrary force of 1 at left boundary + rhs = rhs * 0 + rhs[2] = 1 + + # Solve z0 = Zh0*C + Zp0 = rhs for constants, i.e. Zh0*C = rhs - Zp0 + try: + C = np.linalg.solve(Zh0, rhs - Zp0) + except LinAlgError as e: + zh_shape = Zh0.shape + rhs_shape = rhs.shape + zp_shape = Zp0.shape + rank = int(np.linalg.matrix_rank(Zh0)) + min_dim = min(zh_shape) + try: + cond_val = float(np.linalg.cond(Zh0)) + cond_text = f"{cond_val:.3e}" + except np.linalg.LinAlgError: # Fallback if condition number fails + cond_val = float("inf") + cond_text = "inf" + rank_status = "singular" if rank < min_dim else "full-rank" + msg_format = ( + "Failed to solve linear system (np.linalg.solve) with diagnostics: " + "Zh0.shape=%s, rhs.shape=%s, Zp0.shape=%s, " + "rank(Zh0)=%s/%s (%s), cond(Zh0)=%s. " + "Original error: %s" + ) + msg_args = ( + zh_shape, + rhs_shape, + zp_shape, + rank, + min_dim, + rank_status, + cond_text, + e, + ) + logger.error(msg_format, *msg_args) + raise LinAlgError(msg_format % msg_args) from e + # Sort (nDOF = 6) constants for each segment into columns of a matrix + return C.reshape([-1, nDOF]).T + + @classmethod + def _setup_conditions( + cls, + zl: np.ndarray, + zr: np.ndarray, + eigensystem: Eigensystem, + has_foundation: bool, + pos: Literal["l", "r", "m", "left", "right", "mid"], + system_type: SystemType, + touchdown_mode: Optional[ + Literal["A_free_hanging", "B_point_contact", "C_in_contact"] + ] = None, + collapsed_weak_layer_kR: Optional[float] = None, + ) -> np.ndarray: + """ + Provide boundary or transmission conditions for beam segments. + + Arguments + --------- + zl : ndarray + Solution vector (6x1) or (6x6) at left end of beam segement. + zr : ndarray + Solution vector (6x1) or (6x6) at right end of beam segement. + has_foundation : boolean + Indicates whether segment has foundation(True) or not (False). + Default is False. + pos: {'left', 'mid', 'right', 'l', 'm', 'r'}, optional + Determines whether the segement under consideration + is a left boundary segement (left, l), one of the + center segement (mid, m), or a right boundary + segement (right, r). Default is 'mid'. + + Returns + ------- + conditions : ndarray + `zh`: Matrix of Size one of: (`l: [9,6], m: [12,6], r: [9,6]`) + + `zp`: Vector of Size one of: (`l: [9,1], m: [12,1], r: [9,1]`) + """ + fq = FieldQuantities(eigensystem=eigensystem) + if pos in ("l", "left"): + bcs = cls._boundary_conditions( + zl, + eigensystem, + has_foundation, + pos, + system_type, + touchdown_mode, + collapsed_weak_layer_kR, + ) # Left boundary condition + conditions = np.array( + [ + bcs[0], + bcs[1], + bcs[2], + fq.u(zr, h0=0), # ui(xi = li) + fq.w(zr), # wi(xi = li) + fq.psi(zr), # psii(xi = li) + fq.N(zr), # Ni(xi = li) + fq.M(zr), # Mi(xi = li) + fq.V(zr), # Vi(xi = li) + ] + ) + elif pos in ("m", "mid"): + conditions = np.array( + [ + -fq.u(zl, h0=0), # -ui(xi = 0) + -fq.w(zl), # -wi(xi = 0) + -fq.psi(zl), # -psii(xi = 0) + -fq.N(zl), # -Ni(xi = 0) + -fq.M(zl), # -Mi(xi = 0) + -fq.V(zl), # -Vi(xi = 0) + fq.u(zr, h0=0), # ui(xi = li) + fq.w(zr), # wi(xi = li) + fq.psi(zr), # psii(xi = li) + fq.N(zr), # Ni(xi = li) + fq.M(zr), # Mi(xi = li) + fq.V(zr), # Vi(xi = li) + ] + ) + elif pos in ("r", "right"): + bcs = cls._boundary_conditions( + zr, + eigensystem, + has_foundation, + pos, + system_type, + touchdown_mode, + collapsed_weak_layer_kR, + ) # Right boundary condition + conditions = np.array( + [ + -fq.u(zl, h0=0), # -ui(xi = 0) + -fq.w(zl), # -wi(xi = 0) + -fq.psi(zl), # -psii(xi = 0) + -fq.N(zl), # -Ni(xi = 0) + -fq.M(zl), # -Mi(xi = 0) + -fq.V(zl), # -Vi(xi = 0) + bcs[0], + bcs[1], + bcs[2], + ] + ) + logger.debug("Boundary Conditions at pos %s: %s", pos, conditions.shape) # pylint: disable=E0606 + return conditions + + @classmethod + def _boundary_conditions( + cls, + z, + eigensystem: Eigensystem, + has_foundation: bool, + pos: Literal["l", "r", "m", "left", "right", "mid"], + system_type: SystemType, + touchdown_mode: Optional[ + Literal["A_free_hanging", "B_point_contact", "C_in_contact"] + ] = None, + collapsed_weak_layer_kR: Optional[float] = None, + ): + """ + Provide equations for free (pst) or infinite (skiers) ends. + + Arguments + --------- + z : ndarray + Solution vector (6x1) at a certain position x. + l : float, optional + Length of the segment in consideration. Default is zero. + has_foundation : boolean + Indicates whether segment has foundation(True) or not (False). + Default is False. + pos : {'left', 'mid', 'right', 'l', 'm', 'r'}, optional + Determines whether the segement under consideration + is a left boundary segement (left, l), one of the + center segement (mid, m), or a right boundary + segement (right, r). Default is 'mid'. + + Returns + ------- + bc : ndarray + Boundary condition vector (lenght 3) at position x. + """ + fq = FieldQuantities(eigensystem=eigensystem) + # Set boundary conditions for PST-systems + if system_type in ["pst-", "-pst"]: + if not has_foundation: + if touchdown_mode in ["A_free_hanging"]: + # Free end + bc = np.array([fq.N(z), fq.M(z), fq.V(z)]) + elif touchdown_mode in ["B_point_contact"] and pos in ["r", "right"]: + # Touchdown right + bc = np.array([fq.N(z), fq.M(z), fq.w(z)]) + elif touchdown_mode in ["B_point_contact"] and pos in ["l", "left"]: + # Touchdown left + bc = np.array([fq.N(z), fq.M(z), fq.w(z)]) + elif touchdown_mode in ["C_in_contact"] and pos in ["r", "right"]: + # Spring stiffness + kR = collapsed_weak_layer_kR + # Touchdown right + bc = np.array([fq.N(z), fq.M(z) + kR * fq.psi(z), fq.w(z)]) + elif touchdown_mode in ["C_in_contact"] and pos in ["l", "left"]: + # Spring stiffness + kR = collapsed_weak_layer_kR + # Touchdown left + bc = np.array([fq.N(z), fq.M(z) - kR * fq.psi(z), fq.w(z)]) + else: + # Touchdown not enabled + bc = np.array([fq.N(z), fq.M(z), fq.V(z)]) + else: + # Free end + bc = np.array([fq.N(z), fq.M(z), fq.V(z)]) + # Set boundary conditions for PST-systems with vertical faces + elif system_type in ["-vpst", "vpst-"]: + bc = np.array([fq.N(z), fq.M(z), fq.V(z)]) + # Set boundary conditions for SKIER-systems + elif system_type in ["skier", "skiers"]: + # Infinite end (vanishing complementary solution) + bc = np.array([fq.u(z, h0=0), fq.w(z), fq.psi(z)]) + # Set boundary conditions for substitute spring calculus + elif system_type in ["rot", "trans"]: + bc = np.array([fq.N(z), fq.M(z), fq.V(z)]) + else: + raise ValueError( + f"Boundary conditions not defined for system of type {system_type}." + ) + + return bc diff --git a/weac/eigensystem.py b/weac/eigensystem.py deleted file mode 100644 index 0e9c2d7..0000000 --- a/weac/eigensystem.py +++ /dev/null @@ -1,658 +0,0 @@ -"""Base class for the elastic analysis of layered snow slabs.""" -# pylint: disable=invalid-name,too-many-instance-attributes -# pylint: disable=too-many-arguments,too-many-locals - -# Third party imports -import numpy as np - -# Project imports -from weac.tools import bergfeld, calc_center_of_gravity, load_dummy_profile - - -class Eigensystem: - """ - Base class for a layered beam on an elastic foundation. - - Provides geometry, material and loading attributes, and methods - for the assembly of a fundamental system. - - Attributes - ---------- - g : float - Gravitational constant (mm/s^2). Default is 9180. - lski : float - Effective out-of-plance length of skis (mm). Default is 1000. - tol : float - Relative Romberg integration toleranc. Default is 1e-3. - system : str - Type of boundary value problem. Default is 'pst-'. - weak : dict - Dictionary that holds the weak layer properties Young's - modulus (MPa) and Poisson's ratio. Defaults are 0.25 - and 0.25, respectively. - t : float - Weak-layer thickness (mm). Default is 30. - kn : float - Compressive foundation (weak-layer) stiffness (N/mm^3). - kt : float - Shear foundation (weak-layer) stiffness (N/mm^3). - tc : float - Weak-layer thickness after collapse (mm). - slab : ndarray - Matrix that holds the elastic properties of all slab layers. - Columns are density (kg/m^3), layer heigth (mm), Young's - modulus (MPa), shear modulus (MPa), and Poisson's ratio. - k : float - Shear correction factor of the slab. Default is 5/6. - h : float - Slab thickness (mm). Default is 300. - zs : float - Z-coordinate of the center of gravity of the slab (mm). - A11 : float - Extensional stiffness of the slab (N/mm). - B11 : float - Bending-extension coupling stiffness of the slab (N). - D11 : float - Bending stiffness of the slab (Nmm). - kA55 : float - Shear stiffness of the slab (N/mm). - K0 : float - Characteristic stiffness value (N). - ewC : ndarray - List of complex eigenvalues. - ewR : ndarray - List of real eigenvalues. - evC : ndarray - Matrix with eigenvectors corresponding to complex - eigenvalues as columns. - evR : ndarray - Matrix with eigenvectors corresponding to real - eigenvalues as columns. - sC : float - X-coordinate shift (mm) of complex parts of the solution. - Used for numerical stability. - sR : float - X-coordinate shift (mm) of real parts of the solution. - Used for numerical stability. - sysmat : ndarray - System matrix. - lC : float - Cracklength whose maximum deflection equals the - weak-layer thickness (mm). - lS : float - Cracklength when touchdown exerts maximum support - on the slab (mm). Corresponds to the longest possible - unbedded length. - ratio : float - Increment factor for the weak-layer stiffness from intact - to collapsed state. - beta : float - Describes the stiffnesses of weak-layer and slab. - """ - - def __init__(self, system="pst-", touchdown=False): - """ - Initialize eigensystem with user input. - - Arguments - --------- - system : {'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'}, optional - Type of system to analyse: PST cut from the right (pst-), - PST cut form the left (-pst), PST with vertical faces cut - from the right (vpst-), PST with vertical faces cut from the - left (-vpst), one skier on infinite slab (skier) or multiple - skiers on infinite slab (skiers). Default is 'pst-'. - layers : list, optional - 2D list of layer densities and thicknesses. Columns are - density (kg/m^3) and thickness (mm). One row corresponds - to one layer. Default is [[240, 200], ]. - """ - # Assign global attributes - self.g = 9810 # Gravitaiton (mm/s^2) - self.lski = 1000 # Effective out-of-plane length of skis (mm) - self.tol = 1e-3 # Relative Romberg integration tolerance - self.system = system # 'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers' - - # Initialize weak-layer attributes that will be filled later - self.weak = False # Weak-layer properties dictionary - self.t = False # Weak-layer thickness (mm) - self.kn = False # Weak-layer compressive stiffness - self.kt = False # Weak-layer shear stiffness - - # Initialize slab attributes - self.p = 0 # Surface line load (N/mm) - self.slab = False # Slab properties dictionary - self.k = False # Slab shear correction factor - self.h = False # Total slab height (mm) - self.zs = False # Z-coordinate of slab center of gravity (mm) - self.phi = False # Slab inclination (Β°) - self.A11 = False # Slab extensional stiffness - self.B11 = False # Slab bending-extension coupling stiffness - self.D11 = False # Slab bending stiffness - self.kA55 = False # Slab shear stiffness - self.K0 = False # Stiffness determinant - - # Inizialize eigensystem attributes - self.ewC = False # Complex eigenvalues - self.ewR = False # Real eigenvalues - self.evC = False # Complex eigenvectors - self.evR = False # Real eigenvectors - self.sC = False # Stability shift of complex eigenvalues - self.sR = False # Stability shift of real eigenvalues - - # Initialize touchdown attributes - self.touchdown = touchdown # Flag whether touchdown is possible - self.a = False # Cracklength - self.tc = False # Weak-layer collapse height (mm) - self.ratio = False # Stiffness ratio of collapsed to uncollapsed weak-layer - self.betaU = False # Ratio of slab to bedding stiffness (uncollapsed) - self.betaC = False # Ratio of slab to bedding stiffness (collapsed) - self.mode = False # Touchdown-mode can be either A, B, C or D - self.td = False # Touchdown length - - def set_foundation_properties( - self, t: float = 30.0, E: float = 0.25, nu: float = 0.25, update: bool = False - ): - """ - Set material properties and geometry of foundation (weak layer). - - Arguments - --------- - t : float, optional - Weak-layer thickness (mm). Default is 30. - cf : float - Fraction by which the weak-layer thickness is reduced - due to collapse. Default is 0.5. - E : float, optional - Weak-layer Young modulus (MPa). Default is 0.25. - nu : float, optional - Weak-layer Poisson ratio. Default is 0.25. - update : bool, optional - If true, recalculate the fundamental system after - foundation properties have changed. - """ - # Geometry - self.t = t # Weak-layer thickness (mm) - - # Material properties - self.weak = { - "nu": nu, # Poisson's ratio (-) - "E": E, # Young's modulus (MPa) - } - - # Recalculate the fundamental system after properties have changed - if update: - self.calc_fundamental_system() - - def set_beam_properties(self, layers, C0=6.5, C1=4.4, nu=0.25, update=False): - """ - Set material and properties geometry of beam (slab). - - Arguments - --------- - layers : list or str - 2D list of top-to-bottom layer densities and thicknesses. - Columns are density (kg/m^3) and thickness (mm). One row - corresponds to one layer. If entered as str, last split - must be available in database. - C0 : float, optional - Multiplicative constant of Young modulus parametrization - according to Bergfeld et al. (2023). Default is 6.5. - C1 : float, optional - Exponent of Young modulus parameterization according to - Bergfeld et al. (2023). Default is 4.6. - nu : float, optional - Possion's ratio. Default is 0.25 - update : bool, optional - If true, recalculate the fundamental system after - foundation properties have changed. - """ - if isinstance(layers, str): - # Read layering and Young's modulus from database - layers, E = load_dummy_profile(layers.split()[-1]) - else: - # Compute Young's modulus from density parametrization - layers = np.array(layers) - E = bergfeld(layers[:, 0], C0=C0, C1=C1) # Young's modulus - - # Derive other elastic properties - nu = nu * np.ones(layers.shape[0]) # Global poisson's ratio - G = E / (2 * (1 + nu)) # Shear modulus - self.k = 5 / 6 # Shear correction factor - - # Compute total slab thickness and center of gravity - self.h, self.zs = calc_center_of_gravity(layers) - - # Assemble layering into matrix (top to bottom) - # Columns are density (kg/m^3), layer thickness (mm) - # Young's modulus (MPa), shear modulus (MPa), and - # Poisson's ratio - self.slab = np.vstack([layers.T, E, G, nu]).T - - # Recalculate the fundamental system after properties have changed - if update: - self.calc_fundamental_system() - - def set_surface_load(self, p): - """ - Set surface line load. - - Define a distributed surface load (N/mm) that acts - in vertical (gravity) direction on the top surface - of the slab. - - Arguments - --------- - p : float - Surface line load (N/mm) that acts in vertical - (gravity) direction onm the top surface of the - slab. - """ - self.p = p - - def calc_foundation_stiffness(self): - """Compute foundation normal and shear stiffness.""" - # Elastic moduli (MPa) under plane-strain conditions - G = self.weak["E"] / (2 * (1 + self.weak["nu"])) # Shear modulus - E = self.weak["E"] / (1 - self.weak["nu"] ** 2) # Young's modulus - - # Foundation (weak layer) stiffnesses (N/mm^3) - self.kn = E / self.t # Normal stiffness - self.kt = G / self.t # Shear stiffness - - def get_ply_coordinates(self): - """ - Calculate ply (layer) z-coordinates. - - Returns - ------- - ndarray - Ply (layer) z-coordinates (top to bottom) in coordinate system with - downward pointing z-axis (z-list will be negative to positive). - - """ - # Get list of ply (layer) thicknesses and prepend 0 - t = np.concatenate(([0], self.slab[:, 1])) - # Calculate and return ply z-coordiantes - return np.cumsum(t) - self.h / 2 - - def calc_laminate_stiffness_matrix(self): - """ - Provide ABD matrix. - - Return plane-strain laminate stiffness matrix (ABD matrix). - """ - # Get ply coordinates (z-list is top to bottom, negative to positive) - z = self.get_ply_coordinates() - # Initialize stiffness components - A11, B11, D11, kA55 = 0, 0, 0, 0 - # Add layerwise contributions - for i in range(len(z) - 1): - E, G, nu = self.slab[i, 2:5] - A11 = A11 + E / (1 - nu**2) * (z[i + 1] - z[i]) - B11 = B11 + 1 / 2 * E / (1 - nu**2) * (z[i + 1] ** 2 - z[i] ** 2) - D11 = D11 + 1 / 3 * E / (1 - nu**2) * (z[i + 1] ** 3 - z[i] ** 3) - kA55 = kA55 + self.k * G * (z[i + 1] - z[i]) - - self.A11 = A11 - self.B11 = B11 - self.D11 = D11 - self.kA55 = kA55 - self.K0 = B11**2 - A11 * D11 - - def calc_system_matrix(self): - """ - Assemble first-order ODE system matrix K. - - Using the solution vector z = [u, u', w, w', psi, psi'] - the ODE system is written in the form Az' + Bz = d - and rearranged to z' = -(A ^ -1)Bz + (A ^ -1)d = Kz + q - - Returns - ------- - ndarray - System matrix K (6x6). - """ - kn = self.kn - kt = self.kt - - # Abbreviations (MIT t/2 im GGW, MIT w' in Kinematik) - K21 = kt * (-2 * self.D11 + self.B11 * (self.h + self.t)) / (2 * self.K0) - K24 = ( - 2 * self.D11 * kt * self.t - - self.B11 * kt * self.t * (self.h + self.t) - + 4 * self.B11 * self.kA55 - ) / (4 * self.K0) - K25 = ( - -2 * self.D11 * self.h * kt - + self.B11 * self.h * kt * (self.h + self.t) - + 4 * self.B11 * self.kA55 - ) / (4 * self.K0) - K43 = kn / self.kA55 - K61 = kt * (2 * self.B11 - self.A11 * (self.h + self.t)) / (2 * self.K0) - K64 = ( - -2 * self.B11 * kt * self.t - + self.A11 * kt * self.t * (self.h + self.t) - - 4 * self.A11 * self.kA55 - ) / (4 * self.K0) - K65 = ( - 2 * self.B11 * self.h * kt - - self.A11 * self.h * kt * (self.h + self.t) - - 4 * self.A11 * self.kA55 - ) / (4 * self.K0) - - # System matrix - K = [ - [0, 1, 0, 0, 0, 0], - [K21, 0, 0, K24, K25, 0], - [0, 0, 0, 1, 0, 0], - [0, 0, K43, 0, 0, -1], - [0, 0, 0, 0, 0, 1], - [K61, 0, 0, K64, K65, 0], - ] - - return np.array(K) - - def get_load_vector(self, phi): - """ - Compute sytem load vector q. - - Using the solution vector z = [u, u', w, w', psi, psi'] - the ODE system is written in the form Az' + Bz = d - and rearranged to z' = -(A ^ -1)Bz + (A ^ -1)d = Kz + q - - Arguments - --------- - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray - System load vector q (6x1). - """ - qn, qt = self.get_weight_load(phi) - pn, pt = self.get_surface_load(phi) - return np.array( - [ - [0], - [ - ( - self.B11 * (self.h * pt - 2 * qt * self.zs) - + 2 * self.D11 * (qt + pt) - ) - / (2 * self.K0) - ], - [0], - [-(qn + pn) / self.kA55], - [0], - [ - -( - self.A11 * (self.h * pt - 2 * qt * self.zs) - + 2 * self.B11 * (qt + pt) - ) - / (2 * self.K0) - ], - ] - ) - - def calc_eigensystem(self): - """Calculate eigenvalues and eigenvectors of the system matrix.""" - # Calculate eigenvalues (ew) and eigenvectors (ev) - ew, ev = np.linalg.eig(self.calc_system_matrix()) - # Classify real and complex eigenvalues - real = (ew.imag == 0) & (ew.real != 0) # real eigenvalues - cmplx = ew.imag > 0 # positive complex conjugates - # Eigenvalues - self.ewC = ew[cmplx] - self.ewR = ew[real].real - # Eigenvectors - self.evC = ev[:, cmplx] - self.evR = ev[:, real].real - # Prepare positive eigenvalue shifts for numerical robustness - self.sR, self.sC = np.zeros(self.ewR.shape), np.zeros(self.ewC.shape) - self.sR[self.ewR > 0], self.sC[self.ewC > 0] = -1, -1 - - def calc_fundamental_system(self): - """Calculate the fundamental system of the problem.""" - self.calc_foundation_stiffness() - self.calc_laminate_stiffness_matrix() - self.calc_eigensystem() - - def get_weight_load(self, phi): - """ - Calculate line loads from slab mass. - - Arguments - --------- - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - qn : float - Line load (N/mm) at center of gravity in normal direction. - qt : float - Line load (N/mm) at center of gravity in tangential direction. - """ - # Convert units - phi = np.deg2rad(phi) # Convert inclination to rad - rho = self.slab[:, 0] * 1e-12 # Convert density to t/mm^3 - # Sum up layer weight loads - q = sum(rho * self.g * self.slab[:, 1]) # Line load (N/mm) - # Split into components - qn = q * np.cos(phi) # Normal direction - qt = -q * np.sin(phi) # Tangential direction - - return qn, qt - - def get_surface_load(self, phi): - """ - Calculate surface line loads. - - Arguments - --------- - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - pn : float - Surface line load (N/mm) in normal direction. - pt : float - Surface line load (N/mm) in tangential direction. - """ - # Convert units - phi = np.deg2rad(phi) # Convert inclination to rad - # Split into components - pn = self.p * np.cos(phi) # Normal direction - pt = -self.p * np.sin(phi) # Tangential direction - - return pn, pt - - def get_skier_load(self, m, phi): - """ - Calculate skier point load. - - Arguments - --------- - m : float - Skier weight (kg). - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - Fn : float - Skier load (N) in normal direction. - Ft : float - Skier load (N) in tangential direction. - """ - phi = np.deg2rad(phi) # Convert inclination to rad - F = 1e-3 * np.array(m) * self.g / self.lski # Total skier load (N) - Fn = F * np.cos(phi) # Normal skier load (N) - Ft = -F * np.sin(phi) # Tangential skier load (N) - - return Fn, Ft - - def zh(self, x, l=0, bed=True): - """ - Compute bedded or free complementary solution at position x. - - Arguments - --------- - x : float - Horizontal coordinate (mm). - l : float, optional - Segment length (mm). Default is 0. - bed : bool - Indicates whether segment has foundation or not. Default - is True. - - Returns - ------- - zh : ndarray - Complementary solution matrix (6x6) at position x. - """ - if bed: - zh = np.concatenate( - [ - # Real - self.evR * np.exp(self.ewR * (x + l * self.sR)), - # Complex - np.exp(self.ewC.real * (x + l * self.sC)) - * ( - self.evC.real * np.cos(self.ewC.imag * x) - - self.evC.imag * np.sin(self.ewC.imag * x) - ), - # Complex - np.exp(self.ewC.real * (x + l * self.sC)) - * ( - self.evC.imag * np.cos(self.ewC.imag * x) - + self.evC.real * np.sin(self.ewC.imag * x) - ), - ], - axis=1, - ) - else: - # Abbreviations - H14 = 3 * self.B11 / self.A11 * x**2 - H24 = 6 * self.B11 / self.A11 * x - H54 = -3 * x**2 + 6 * self.K0 / (self.A11 * self.kA55) - # Complementary solution matrix of free segments - zh = np.array( - [ - [0, 0, 0, H14, 1, x], - [0, 0, 0, H24, 0, 1], - [1, x, x**2, x**3, 0, 0], - [0, 1, 2 * x, 3 * x**2, 0, 0], - [0, -1, -2 * x, H54, 0, 0], - [0, 0, -2, -6 * x, 0, 0], - ] - ) - - return zh - - def zp(self, x, phi, bed=True): - """ - Compute bedded or free particular integrals at position x. - - Arguments - --------- - x : float - Horizontal coordinate (mm). - phi : float - Inclination (degrees). - bed : bool - Indicates whether segment has foundation (True) or not - (False). Default is True. - - Returns - ------- - zp : ndarray - Particular integral vector (6x1) at position x. - """ - # Get weight and surface loads - qn, qt = self.get_weight_load(phi) - pn, pt = self.get_surface_load(phi) - - # Set foundation stiffnesses - kn = self.kn - kt = self.kt - - # Unpack laminate stiffnesses - A11 = self.A11 - B11 = self.B11 - kA55 = self.kA55 - K0 = self.K0 - - # Unpack geometric properties - h = self.h - t = self.t - zs = self.zs - - # Assemble particular integral vectors - if bed: - zp = np.array( - [ - [ - (qt + pt) / kt - + h * qt * (h + t - 2 * zs) / (4 * kA55) - + h * pt * (2 * h + t) / (4 * kA55) - ], - [0], - [(qn + pn) / kn], - [0], - [-(qt * (h + t - 2 * zs) + pt * (2 * h + t)) / (2 * kA55)], - [0], - ] - ) - else: - zp = np.array( - [ - [(-3 * (qt + pt) / A11 - B11 * (qn + pn) * x / K0) / 6 * x**2], - [(-2 * (qt + pt) / A11 - B11 * (qn + pn) * x / K0) / 2 * x], - [-A11 * (qn + pn) * x**4 / (24 * K0)], - [-A11 * (qn + pn) * x**3 / (6 * K0)], - [ - A11 * (qn + pn) * x**3 / (6 * K0) - + ((zs - B11 / A11) * qt - h * pt / 2 - (qn + pn) * x) / kA55 - ], - [(qn + pn) * (A11 * x**2 / (2 * K0) - 1 / kA55)], - ] - ) - - return zp - - def z(self, x, C, l, phi, bed=True): - """ - Assemble solution vector at positions x. - - Arguments - --------- - x : float or squence - Horizontal coordinate (mm). Can be sequence of length N. - C : ndarray - Vector of constants (6xN) at positions x. - l : float - Segment length (mm). - phi : float - Inclination (degrees). - bed : bool - Indicates whether segment has foundation (True) or not - (False). Default is True. - - Returns - ------- - z : ndarray - Solution vector (6xN) at position x. - """ - if isinstance(x, (list, tuple, np.ndarray)): - z = np.concatenate( - [np.dot(self.zh(xi, l, bed), C) + self.zp(xi, phi, bed) for xi in x], - axis=1, - ) - else: - z = np.dot(self.zh(x, l, bed), C) + self.zp(x, phi, bed) - - return z diff --git a/weac/inverse.py b/weac/inverse.py deleted file mode 100644 index 2a1994d..0000000 --- a/weac/inverse.py +++ /dev/null @@ -1,51 +0,0 @@ -"""Class for the elastic analysis of layered snow slabs.""" -# pylint: disable=invalid-name - -# Project imports -from weac.eigensystem import Eigensystem -from weac.mixins import AnalysisMixin, FieldQuantitiesMixin, OutputMixin, SolutionMixin - - -class Inverse( - FieldQuantitiesMixin, SolutionMixin, AnalysisMixin, OutputMixin, Eigensystem -): - """ - Fit the elastic properties of the layers of a snowpack. - - Allows for the inverse identification of the elastic properties - of the layers of a snowpack from full-field displacement - measurements. - - Inherits methods for the eigensystem calculation from the base - class Eigensystem(), methods for the calculation of field - quantities from FieldQuantitiesMixin(), methods for the solution - of the system from SolutionMixin() and methods for the output - analysis from AnalysisMixin(). - """ - - def __init__(self, system="pst-", layers=None, parameters=(6.0, 4.6, 0.25)): - """ - Initialize model with user input. - - Arguments - --------- - system : str, optional - Type of system to analyse. Default is 'pst-'. - layers : list, optional - List of layer densities and thicknesses. Default is None. - parameters : tuple, optional - Fitting parameters C0, C1, and Eweak. Multiplicative constant - of Young modulus parametrization, exponent constant of Young - modulus parametrization, and weak-layer Young modulus, - respectively. Default is (6.0, 4.6, 0.25). - """ - # Call parent __init__ - super().__init__(system=system) - - # Unpack fitting parameters - C0, C1, Eweak = parameters - - # Set material properties and set up model - self.set_beam_properties(layers=layers, C0=C0, C1=C1) - self.set_foundation_properties(E=Eweak) - self.calc_fundamental_system() diff --git a/weac/layered.py b/weac/layered.py deleted file mode 100755 index 3997667..0000000 --- a/weac/layered.py +++ /dev/null @@ -1,64 +0,0 @@ -"""Class for the elastic analysis of layered snow slabs.""" - -# Project imports - -from weac.eigensystem import Eigensystem -from weac.mixins import ( - AnalysisMixin, - FieldQuantitiesMixin, - OutputMixin, - SlabContactMixin, - SolutionMixin, -) - - -class Layered( - FieldQuantitiesMixin, - SlabContactMixin, - SolutionMixin, - AnalysisMixin, - OutputMixin, - Eigensystem, -): - """ - Layered beam on elastic foundation model application interface. - - Inherits methods for the eigensystem calculation from the base - class Eigensystem(), methods for the calculation of field - quantities from FieldQuantitiesMixin(), methods for the solution - of the system from SolutionMixin() and methods for the output - analysis from AnalysisMixin(). - """ - - def __init__(self, system="pst-", layers=None, touchdown=False): - """ - Initialize model with user input. - - Arguments - --------- - system : {'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'}, optional - Type of system to analyse: PST cut from the right (pst-), - PST cut form the left (-pst), PST with vertical faces cut - from the right (vpst-), PST with vertical faces cut from the - left (-vpst), one skier on infinite slab (skier) or multiple - skiers on infinite slab (skiers). Default is 'pst-'. - layers : list, optional - 2D list of layer densities and thicknesses. Columns are - density(kg/m ^ 3) and thickness(mm). One row corresponds - to one layer. Default is [[240, 200], ]. - touchdown : bool, optional - Set True if slab touchdown is to be considered. Default is False. - """ - # Call parent __init__ - super().__init__(system=system, touchdown=touchdown) - - # Set material properties and set up model - self.set_beam_properties( - layers - if layers - else [ - [240, 200], - ] - ) - self.set_foundation_properties() - self.calc_fundamental_system() diff --git a/weac/logging_config.py b/weac/logging_config.py new file mode 100644 index 0000000..7f8c581 --- /dev/null +++ b/weac/logging_config.py @@ -0,0 +1,39 @@ +""" +Logging configuration for weak layer anticrack nucleation model. +""" + +import os +from logging.config import dictConfig +from typing import Optional + + +def setup_logging(level: Optional[str] = None) -> None: + """ + Initialise the global logging configuration exactly once. + The level is taken from the env var WEAC_LOG_LEVEL (default WARNING). + """ + if level is None: + level = os.getenv("WEAC_LOG_LEVEL", "WARNING").upper() + + dictConfig( + { + "version": 1, + "disable_existing_loggers": False, # keep third-party loggers alive + "formatters": { + "console": { + "format": "%(asctime)s | %(levelname)-8s | %(name)s: %(message)s", + }, + }, + "handlers": { + "console": { + "class": "logging.StreamHandler", + "formatter": "console", + "level": level, + }, + }, + "root": { # applies to *all* loggers + "handlers": ["console"], + "level": level, + }, + } + ) diff --git a/weac/mixins.py b/weac/mixins.py deleted file mode 100644 index d0088a8..0000000 --- a/weac/mixins.py +++ /dev/null @@ -1,2083 +0,0 @@ -"""Mixins for the elastic analysis of layered snow slabs.""" -# pylint: disable=invalid-name,too-many-locals,too-many-arguments,too-many-lines - -# Standard library imports -from functools import partial - -# Third party imports -import numpy as np -from scipy.integrate import cumulative_trapezoid, quad -from scipy.optimize import brentq - -# Module imports -from weac.tools import calc_vertical_bc_center_of_gravity, tensile_strength_slab - - -class FieldQuantitiesMixin: - """ - Mixin for field quantities. - - Provides methods for the computation of displacements, stresses, - strains, and energy release rates from the solution vector. - """ - - # pylint: disable=no-self-use - def w(self, Z, unit="mm"): - """ - Get centerline deflection w. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - unit : {'m', 'cm', 'mm', 'um'}, optional - Desired output unit. Default is mm. - - Returns - ------- - float - Deflection w (in specified unit) of the slab. - """ - convert = { - "m": 1e-3, # meters - "cm": 1e-1, # centimeters - "mm": 1, # millimeters - "um": 1e3, # micrometers - } - return convert[unit] * Z[2, :] - - def dw_dx(self, Z): - """ - Get first derivative w' of the centerline deflection. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - First derivative w' of the deflection of the slab. - """ - return Z[3, :] - - def psi(self, Z, unit="rad"): - """ - Get midplane rotation psi. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - unit : {'deg', 'degrees', 'rad', 'radians'}, optional - Desired output unit. Default is radians. - - Returns - ------- - psi : float - Cross-section rotation psi (radians) of the slab. - """ - if unit in ["deg", "degree", "degrees"]: - psi = np.rad2deg(Z[4, :]) - elif unit in ["rad", "radian", "radians"]: - psi = Z[4, :] - return psi - - def dpsi_dx(self, Z): - """ - Get first derivative psi' of the midplane rotation. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - First derivative psi' of the midplane rotation (radians/mm) - of the slab. - """ - return Z[5, :] - - # pylint: enable=no-self-use - def u(self, Z, z0, unit="mm"): - """ - Get horizontal displacement u = u0 + z0 psi. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - z0 : float - Z-coordinate (mm) where u is to be evaluated. - unit : {'m', 'cm', 'mm', 'um'}, optional - Desired output unit. Default is mm. - - Returns - ------- - float - Horizontal displacement u (unit) of the slab. - """ - convert = { - "m": 1e-3, # meters - "cm": 1e-1, # centimeters - "mm": 1, # millimeters - "um": 1e3, # micrometers - } - return convert[unit] * (Z[0, :] + z0 * self.psi(Z)) - - def du_dx(self, Z, z0): - """ - Get first derivative of the horizontal displacement. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - z0 : float - Z-coordinate (mm) where u is to be evaluated. - - Returns - ------- - float - First derivative u' = u0' + z0 psi' of the horizontal - displacement of the slab. - """ - return Z[1, :] + z0 * self.dpsi_dx(Z) - - def N(self, Z): - """ - Get the axial normal force N = A11 u' + B11 psi' in the slab. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - Axial normal force N (N) in the slab. - """ - return self.A11 * Z[1, :] + self.B11 * Z[5, :] - - def M(self, Z): - """ - Get bending moment M = B11 u' + D11 psi' in the slab. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - Bending moment M (Nmm) in the slab. - """ - return self.B11 * Z[1, :] + self.D11 * Z[5, :] - - def V(self, Z): - """ - Get vertical shear force V = kA55(w' + psi). - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - Vertical shear force V (N) in the slab. - """ - return self.kA55 * (Z[3, :] + Z[4, :]) - - def sig(self, Z, unit="MPa"): - """ - Get weak-layer normal stress. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - unit : {'MPa', 'kPa'}, optional - Desired output unit. Default is MPa. - - Returns - ------- - float - Weak-layer normal stress sigma (in specified unit). - """ - convert = {"kPa": 1e3, "MPa": 1} - return -convert[unit] * self.kn * self.w(Z) - - def tau(self, Z, unit="MPa"): - """ - Get weak-layer shear stress. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - unit : {'MPa', 'kPa'}, optional - Desired output unit. Default is MPa. - - Returns - ------- - float - Weak-layer shear stress tau (in specified unit). - """ - convert = {"kPa": 1e3, "MPa": 1} - return ( - -convert[unit] - * self.kt - * (self.dw_dx(Z) * self.t / 2 - self.u(Z, z0=self.h / 2)) - ) - - def eps(self, Z): - """ - Get weak-layer normal strain. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - Weak-layer normal strain epsilon. - """ - return -self.w(Z) / self.t - - def gamma(self, Z): - """ - Get weak-layer shear strain. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - - Returns - ------- - float - Weak-layer shear strain gamma. - """ - return self.dw_dx(Z) / 2 - self.u(Z, z0=self.h / 2) / self.t - - def Gi(self, Ztip, unit="kJ/m^2"): - """ - Get mode I differential energy release rate at crack tip. - - Arguments - --------- - Ztip : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T - at the crack tip. - unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional - Desired output unit. Default is kJ/m^2. - - Returns - ------- - float - Mode I differential energy release rate (N/mm = kJ/m^2 - or J/m^2) at the crack tip. - """ - convert = { - "J/m^2": 1e3, # joule per square meter - "kJ/m^2": 1, # kilojoule per square meter - "N/mm": 1, # newton per millimeter - } - return convert[unit] * self.sig(Ztip) ** 2 / (2 * self.kn) - - def Gii(self, Ztip, unit="kJ/m^2"): - """ - Get mode II differential energy release rate at crack tip. - - Arguments - --------- - Ztip : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T - at the crack tip. - unit : {'N/mm', 'kJ/m^2', 'J/m^2'}, optional - Desired output unit. Default is kJ/m^2 = N/mm. - - Returns - ------- - float - Mode II differential energy release rate (N/mm = kJ/m^2 - or J/m^2) at the crack tip. - """ - convert = { - "J/m^2": 1e3, # joule per square meter - "kJ/m^2": 1, # kilojoule per square meter - "N/mm": 1, # newton per millimeter - } - return convert[unit] * self.tau(Ztip) ** 2 / (2 * self.kt) - - def int1(self, x, z0, z1): - """ - Get mode I crack opening integrand at integration points xi. - - Arguments - --------- - x : float, ndarray - X-coordinate where integrand is to be evaluated (mm). - z0 : callable - Function that returns the solution vector of the uncracked - configuration. - z1 : callable - Function that returns the solution vector of the cracked - configuration. - - Returns - ------- - float or ndarray - Integrant of the mode I crack opening integral. - """ - return self.sig(z0(x)) * self.eps(z1(x)) * self.t - - def int2(self, x, z0, z1): - """ - Get mode II crack opening integrand at integration points xi. - - Arguments - --------- - x : float, ndarray - X-coordinate where integrand is to be evaluated (mm). - z0 : callable - Function that returns the solution vector of the uncracked - configuration. - z1 : callable - Function that returns the solution vector of the cracked - configuration. - - Returns - ------- - float or ndarray - Integrant of the mode II crack opening integral. - """ - return self.tau(z0(x)) * self.gamma(z1(x)) * self.t - - def dz_dx(self, z, phi): - """ - Get first derivative z'(x) = K*z(x) + q of the solution vector. - - z'(x) = [u'(x) u''(x) w'(x) w''(x) psi'(x), psi''(x)]^T - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - First derivative z'(x) for the solution vector (6x1). - """ - K = self.calc_system_matrix() - q = self.get_load_vector(phi) - return np.dot(K, z) + q - - def dz_dxdx(self, z, phi): - """ - Get second derivative z''(x) = K*z'(x) of the solution vector. - - z''(x) = [u''(x) u'''(x) w''(x) w'''(x) psi''(x), psi'''(x)]^T - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - Second derivative z''(x) = (K*z(x) + q)' = K*z'(x) = K*(K*z(x) + q) - of the solution vector (6x1). - """ - K = self.calc_system_matrix() - q = self.get_load_vector(phi) - dz_dx = np.dot(K, z) + q - return np.dot(K, dz_dx) - - def du0_dxdx(self, z, phi): - """ - Get second derivative of the horiz. centerline displacement u0''(x). - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - Second derivative of the horizontal centerline displacement - u0''(x) (1/mm). - """ - return self.dz_dx(z, phi)[1, :] - - def dpsi_dxdx(self, z, phi): - """ - Get second derivative of the cross-section rotation psi''(x). - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - Second derivative of the cross-section rotation psi''(x) (1/mm^2). - """ - return self.dz_dx(z, phi)[5, :] - - def du0_dxdxdx(self, z, phi): - """ - Get third derivative of the horiz. centerline displacement u0'''(x). - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - Third derivative of the horizontal centerline displacement - u0'''(x) (1/mm^2). - """ - return self.dz_dxdx(z, phi)[1, :] - - def dpsi_dxdxdx(self, z, phi): - """ - Get third derivative of the cross-section rotation psi'''(x). - - Parameters - ---------- - z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x) psi'(x)]^T. - phi : float - Inclination (degrees). Counterclockwise positive. - - Returns - ------- - ndarray, float - Third derivative of the cross-section rotation psi'''(x) (1/mm^3). - """ - return self.dz_dxdx(z, phi)[5, :] - - -class SlabContactMixin: - """ - Mixin for handling the touchdown situation in a PST. - - Provides Methods for the calculation of substitute spring stiffnesses, - cracklength-tresholds and element lengths. - """ - - # pylint: disable=too-many-instance-attributes - - def set_columnlength(self, L): - """ - Set cracklength. - - Arguments - --------- - L : float - Column length of a PST (mm). - """ - self.L = L - - def set_cracklength(self, a): - """ - Set cracklength. - - Arguments - --------- - a : float - Cracklength in a PST (mm). - """ - self.a = a - - def set_tc(self, cf): - """ - Set height of the crack. - - Arguments - --------- - cf : float - Collapse-factor. Ratio of the crack height to the - uncollapsed weak-layer height. - """ - # mark argument as intentionally unused (API compatibility) - _ = cf - # subtract displacement under constact load from collapsed wl height - qn = self.calc_qn() - collapse_height = 4.70 * (1 - np.exp(-self.t / 7.78)) - self.tc = collapse_height - qn / self.kn - - def set_phi(self, phi): - """ - Set inclination of the slab. - - Arguments - --------- - phi : float - Inclination of the slab (Β°). - """ - self.phi = phi - - def set_stiffness_ratio(self, ratio=1000): - """ - Set ratio between collapsed and uncollapsed weak-layer stiffness. - - Parameters - ---------- - ratio : int, optional - Stiffness ratio between collapsed and uncollapsed weak layer. - Default is 1000. - """ - self.ratio = ratio - - def calc_qn(self): - """ - Calc total surface normal load. - - Returns - ------- - float - Total surface normal load (N/mm). - """ - return self.get_weight_load(self.phi)[0] + self.get_surface_load(self.phi)[0] - - def calc_qt(self): - """ - Calc total surface normal load. - - Returns - ------- - float - Total surface normal load (N/mm). - """ - return self.get_weight_load(self.phi)[1] + self.get_surface_load(self.phi)[1] - - def substitute_stiffness(self, L, support="rested", dof="rot"): - """ - Calc substitute stiffness for beam on elastic foundation. - - Arguments - --------- - L : float - Total length of the PST-column (mm). - support : string - Type of segment foundation. Defaults to 'rested'. - dof : string - Type of substitute spring, either 'rot' or 'trans'. Defaults to 'rot'. - - Returns - ------- - k : stiffness of substitute spring. - """ - # adjust system to substitute system - if dof in ["rot"]: - tempsys = self.system - self.system = "rot" - if dof in ["trans"]: - tempsys = self.system - self.system = "trans" - - # Change eigensystem for rested segment - if support in ["rested"]: - tempkn = self.kn - tempkt = self.kt - self.kn = self.ratio * self.kn - self.kt = self.ratio * self.kt - self.calc_system_matrix() - self.calc_eigensystem() - - # prepare list of segment characteristics - segments = { - "li": np.array([L, 0.0]), - "mi": np.array([0]), - "ki": np.array([True, True]), - } - # solve system of equations - constants = self.assemble_and_solve(phi=0, **segments) - # calculate stiffness - _, z_pst, _ = self.rasterize_solution(C=constants, phi=0, num=1, **segments) - if dof in ["rot"]: - k = abs(1 / self.psi(z_pst)[0]) - if dof in ["trans"]: - k = abs(1 / self.w(z_pst)[0]) - - # Reset to previous system and eigensystem - self.system = tempsys - if support in ["rested"]: - self.kn = tempkn - self.kt = tempkt - self.calc_system_matrix() - self.calc_eigensystem() - - return k - - def calc_a1(self): - """ - Calc transition lengths a1 (aAB). - - Returns - ------- - a1 : float - Length of the crack for transition of stage A to stage B (mm). - """ - # Unpack variables - bs = -(self.B11**2 / self.A11 - self.D11) - ss = self.kA55 - L = self.L - tc = self.tc - qn = self.calc_qn() - - # Create polynomial expression - def polynomial(x): - # Spring stiffness supported segment - kRl = self.substitute_stiffness(L - x, "supported", "rot") - kNl = self.substitute_stiffness(L - x, "supported", "trans") - c1 = 1 / (8 * bs) - c2 = 1 / (2 * kRl) - c3 = 1 / (2 * ss) - c4 = 1 / kNl - c5 = -tc / qn - return c1 * x**4 + c2 * x**3 + c3 * x**2 + c4 * x + c5 - - # Find root - a1 = brentq(polynomial, L / 1000, 999 / 1000 * L) - - return a1 - - def calc_a2(self): - """ - Calc transition lengths a2 (aBC). - - Returns - ------- - a2 : float - Length of the crack for transition of stage B to stage C (mm). - """ - # Unpack variables - bs = -(self.B11**2 / self.A11 - self.D11) - ss = self.kA55 - L = self.L - tc = self.tc - qn = self.calc_qn() - - # Create polynomial function - def polynomial(x): - # Spring stiffness supported segment - kRl = self.substitute_stiffness(L - x, "supported", "rot") - kNl = self.substitute_stiffness(L - x, "supported", "trans") - c1 = ss**2 * kRl * kNl * qn - c2 = 6 * ss**2 * bs * kNl * qn - c3 = 30 * bs * ss * kRl * kNl * qn - c4 = 24 * bs * qn * (2 * ss**2 * kRl + 3 * bs * ss * kNl) - c5 = 72 * bs * (bs * qn * (ss**2 + kRl * kNl) - ss**2 * kRl * kNl * tc) - c6 = 144 * bs * ss * (bs * kRl * qn - bs * ss * kNl * tc) - c7 = -144 * bs**2 * ss * kRl * kNl * tc - return ( - c1 * x**6 + c2 * x**5 + c3 * x**4 + c4 * x**3 + c5 * x**2 + c6 * x + c7 - ) - - # Find root - a2 = brentq(polynomial, L / 1000, 999 / 1000 * L) - - return a2 - - def calc_lA(self): - """ - Calculate the length of the touchdown element in mode A. - """ - lA = self.a - - return lA - - def calc_lB(self): - """ - Calculate the length of the touchdown element in mode B. - """ - lB = self.a - - return lB - - def calc_lC(self): - """ - Calculate the length of the touchdown element in mode C. - """ - # Unpack variables - bs = -(self.B11**2 / self.A11 - self.D11) - ss = self.kA55 - L = self.L - a = self.a - tc = self.tc - qn = self.calc_qn() - - def polynomial(x): - # Spring stiffness supported segment - kRl = self.substitute_stiffness(L - a, "supported", "rot") - kNl = self.substitute_stiffness(L - a, "supported", "trans") - # Spring stiffness rested segment - kRr = self.substitute_stiffness(a - x, "rested", "rot") - # define constants - c1 = ss**2 * kRl * kNl * qn - c2 = 6 * ss * kNl * qn * (bs * ss + kRl * kRr) - c3 = 30 * bs * ss * kNl * qn * (kRl + kRr) - c4 = ( - 24 - * bs - * qn - * (2 * ss**2 * kRl + 3 * bs * ss * kNl + 3 * kRl * kRr * kNl) - ) - c5 = ( - 72 - * bs - * ( - bs * qn * (ss**2 + kNl * (kRl + kRr)) - + ss * kRl * (2 * kRr * qn - ss * kNl * tc) - ) - ) - c6 = ( - 144 - * bs - * ss - * (bs * qn * (kRl + kRr) - kNl * tc * (bs * ss + kRl * kRr)) - ) - c7 = -144 * bs**2 * ss * kNl * tc * (kRl + kRr) - return ( - c1 * x**6 + c2 * x**5 + c3 * x**4 + c4 * x**3 + c5 * x**2 + c6 * x + c7 - ) - - # Find root - lC = brentq(polynomial, a / 1000, 999 / 1000 * a) - - return lC - - def set_touchdown_attributes(self, L, a, cf, phi, ratio): - """Set class attributes for touchdown consideration""" - self.set_columnlength(L) - self.set_cracklength(a) - self.set_phi(phi) - self.set_tc(cf) - self.set_stiffness_ratio(ratio) - - def calc_touchdown_mode(self): - """Calculate touchdown-mode from thresholds""" - if self.touchdown: - # Calculate stage transitions - self.a1 = self.calc_a1() - self.a2 = self.calc_a2() - # Assign stage - if self.a <= self.a1: - mode = "A" - elif self.a1 < self.a <= self.a2: - mode = "B" - elif self.a2 < self.a: - mode = "C" - self.mode = mode - else: - self.mode = "A" - - def calc_touchdown_length(self): - """Calculate touchdown length""" - if self.mode in ["A"]: - self.td = self.calc_lA() - elif self.mode in ["B"]: - self.td = self.calc_lB() - elif self.mode in ["C"]: - self.td = self.calc_lC() - - def calc_touchdown_system(self, L, a, cf, phi, ratio=1000): - """Calculate touchdown""" - self.set_touchdown_attributes(L, a, cf, phi, ratio) - self.calc_touchdown_mode() - self.calc_touchdown_length() - - -class SolutionMixin: - """ - Mixin for the solution of boundary value problems. - - Provides methods for the assembly of the system of equations - and for the computation of the free constants. - """ - - def bc(self, z, k=False, pos="mid"): - """ - Provide equations for free (pst) or infinite (skiers) ends. - - Arguments - --------- - z : ndarray - Solution vector (6x1) at a certain position x. - l : float, optional - Length of the segment in consideration. Default is zero. - k : boolean - Indicates whether segment has foundation(True) or not (False). - Default is False. - pos : {'left', 'mid', 'right', 'l', 'm', 'r'}, optional - Determines whether the segement under consideration - is a left boundary segement (left, l), one of the - center segement (mid, m), or a right boundary - segement (right, r). Default is 'mid'. - - Returns - ------- - bc : ndarray - Boundary condition vector (lenght 3) at position x. - """ - - # Set boundary conditions for PST-systems - if self.system in ["pst-", "-pst"]: - if not k: - if self.mode in ["A"]: - # Free end - bc = np.array([self.N(z), self.M(z), self.V(z)]) - elif self.mode in ["B"] and pos in ["r", "right"]: - # Touchdown right - bc = np.array([self.N(z), self.M(z), self.w(z)]) - elif self.mode in ["B"] and pos in ["l", "left"]: # Kann dieser Block - # Touchdown left # verschwinden? Analog zu 'A' - bc = np.array([self.N(z), self.M(z), self.w(z)]) - elif self.mode in ["C"] and pos in ["r", "right"]: - # Spring stiffness - kR = self.substitute_stiffness(self.a - self.td, "rested", "rot") - # Touchdown right - bc = np.array([self.N(z), self.M(z) + kR * self.psi(z), self.w(z)]) - elif self.mode in ["C"] and pos in ["l", "left"]: - # Spring stiffness - kR = self.substitute_stiffness(self.a - self.td, "rested", "rot") - # Touchdown left - bc = np.array([self.N(z), self.M(z) - kR * self.psi(z), self.w(z)]) - else: - # Free end - bc = np.array([self.N(z), self.M(z), self.V(z)]) - # Set boundary conditions for PST-systems with vertical faces - elif self.system in ["-vpst", "vpst-"]: - bc = np.array([self.N(z), self.M(z), self.V(z)]) - # Set boundary conditions for SKIER-systems - elif self.system in ["skier", "skiers"]: - # Infinite end (vanishing complementary solution) - bc = np.array([self.u(z, z0=0), self.w(z), self.psi(z)]) - # Set boundary conditions for substitute spring calculus - elif self.system in ["rot", "trans"]: - bc = np.array([self.N(z), self.M(z), self.V(z)]) - else: - raise ValueError( - f"Boundary conditions not defined for system of type {self.system}." - ) - - return bc - - def eqs(self, zl, zr, k=False, pos="mid"): - """ - Provide boundary or transmission conditions for beam segments. - - Arguments - --------- - zl : ndarray - Solution vector (6x1) at left end of beam segement. - zr : ndarray - Solution vector (6x1) at right end of beam segement. - k : boolean - Indicates whether segment has foundation(True) or not (False). - Default is False. - pos: {'left', 'mid', 'right', 'l', 'm', 'r'}, optional - Determines whether the segement under consideration - is a left boundary segement (left, l), one of the - center segement (mid, m), or a right boundary - segement (right, r). Default is 'mid'. - - Returns - ------- - eqs : ndarray - Vector (of length 9) of boundary conditions (3) and - transmission conditions (6) for boundary segements - or vector of transmission conditions (of length 6+6) - for center segments. - """ - if pos in ("l", "left"): - eqs = np.array( - [ - self.bc(zl, k, pos)[0], # Left boundary condition - self.bc(zl, k, pos)[1], # Left boundary condition - self.bc(zl, k, pos)[2], # Left boundary condition - self.u(zr, z0=0), # ui(xi = li) - self.w(zr), # wi(xi = li) - self.psi(zr), # psii(xi = li) - self.N(zr), # Ni(xi = li) - self.M(zr), # Mi(xi = li) - self.V(zr), - ] - ) # Vi(xi = li) - elif pos in ("m", "mid"): - eqs = np.array( - [ - -self.u(zl, z0=0), # -ui(xi = 0) - -self.w(zl), # -wi(xi = 0) - -self.psi(zl), # -psii(xi = 0) - -self.N(zl), # -Ni(xi = 0) - -self.M(zl), # -Mi(xi = 0) - -self.V(zl), # -Vi(xi = 0) - self.u(zr, z0=0), # ui(xi = li) - self.w(zr), # wi(xi = li) - self.psi(zr), # psii(xi = li) - self.N(zr), # Ni(xi = li) - self.M(zr), # Mi(xi = li) - self.V(zr), - ] - ) # Vi(xi = li) - elif pos in ("r", "right"): - eqs = np.array( - [ - -self.u(zl, z0=0), # -ui(xi = 0) - -self.w(zl), # -wi(xi = 0) - -self.psi(zl), # -psii(xi = 0) - -self.N(zl), # -Ni(xi = 0) - -self.M(zl), # -Mi(xi = 0) - -self.V(zl), # -Vi(xi = 0) - self.bc(zr, k, pos)[0], # Right boundary condition - self.bc(zr, k, pos)[1], # Right boundary condition - self.bc(zr, k, pos)[2], - ] - ) # Right boundary condition - else: - raise ValueError( - ( - f"Invalid position argument {pos} given. " - "Valid segment positions are l, m, and r, " - "or left, mid and right." - ) - ) - return eqs - - def calc_segments( - self, - li: list[float] | list[int] | bool = False, - mi: list[float] | list[int] | bool = False, - ki: list[bool] | bool = False, - k0: list[bool] | bool = False, - L: float = 1e4, - a: float = 0, - m: float = 0, - phi: float = 0, - cf: float = 0.5, - ratio: float = 1000, - **kwargs, - ): - """ - Assemble lists defining the segments. - - This includes length (li), foundation (ki, k0), and skier - weight (mi). - - Arguments - --------- - li : squence, optional - List of lengths of segements(mm). Used for system 'skiers'. - mi : squence, optional - List of skier weigths (kg) at segement boundaries. Used for - system 'skiers'. - ki : squence, optional - List of one bool per segement indicating whether segement - has foundation (True) or not (False) in the cracked state. - Used for system 'skiers'. - k0 : squence, optional - List of one bool per segement indicating whether segement - has foundation(True) or not (False) in the uncracked state. - Used for system 'skiers'. - L : float, optional - Total length of model (mm). Used for systems 'pst-', '-pst', - 'vpst-', '-vpst', and 'skier'. - a : float, optional - Crack length (mm). Used for systems 'pst-', '-pst', 'pst-', - '-pst', and 'skier'. - phi : float, optional - Inclination (degree). - m : float, optional - Weight of skier (kg) in the axial center of the model. - Used for system 'skier'. - cf : float, optional - Collapse factor. Ratio of the crack height to the uncollapsed - weak-layer height. Used for systems 'pst-', '-pst'. Default is 0.5. - ratio : float, optional - Stiffness ratio between collapsed and uncollapsed weak layer. - Default is 1000. - - Returns - ------- - segments : dict - Dictionary with lists of touchdown booleans (tdi), segement - lengths (li), skier weights (mi), and foundation booleans - in the cracked (ki) and uncracked (k0) configurations. - """ - - _ = kwargs # Unused arguments - - # Precompute touchdown properties - self.calc_touchdown_system(L=L, a=a, cf=cf, phi=phi, ratio=ratio) - - # Assemble list defining the segments - if self.system == "skiers": - li = np.array(li) # Segment lengths - mi = np.array(mi) # Skier weights - ki = np.array(ki) # Crack - k0 = np.array(k0) # No crack - elif self.system == "pst-": - li = np.array([L - self.a, self.td]) # Segment lengths - mi = np.array([0]) # Skier weights - ki = np.array([True, False]) # Crack - k0 = np.array([True, True]) # No crack - elif self.system == "-pst": - li = np.array([self.td, L - self.a]) # Segment lengths - mi = np.array([0]) # Skier weights - ki = np.array([False, True]) # Crack - k0 = np.array([True, True]) # No crack - elif self.system == "vpst-": - li = np.array([L - a, a]) # Segment lengths - mi = np.array([0]) # Skier weights - ki = np.array([True, False]) # Crack - k0 = np.array([True, True]) # No crack - elif self.system == "-vpst": - li = np.array([a, L - a]) # Segment lengths - mi = np.array([0]) # Skier weights - ki = np.array([False, True]) # Crack - k0 = np.array([True, True]) # No crack - elif self.system == "skier": - lb = (L - self.a) / 2 # Half bedded length - lf = self.a / 2 # Half free length - li = np.array([lb, lf, lf, lb]) # Segment lengths - mi = np.array([0, m, 0]) # Skier weights - ki = np.array([True, False, False, True]) # Crack - k0 = np.array([True, True, True, True]) # No crack - else: - raise ValueError(f"System {self.system} is not implemented.") - - # Fill dictionary - segments = { - "nocrack": {"li": li, "mi": mi, "ki": k0}, - "crack": {"li": li, "mi": mi, "ki": ki}, - "both": {"li": li, "mi": mi, "ki": ki, "k0": k0}, - } - return segments - - def assemble_and_solve(self, phi, li, mi, ki): - """ - Compute free constants for arbitrary beam assembly. - - Assemble LHS from supported and unsupported segments in the form - [ ] [ zh1 0 0 ... 0 0 0 ][ ] [ ] [ ] left - [ ] [ zh1 zh2 0 ... 0 0 0 ][ ] [ ] [ ] mid - [ ] [ 0 zh2 zh3 ... 0 0 0 ][ ] [ ] [ ] mid - [z0] = [ ... ... ... ... ... ... ... ][ C ] + [ zp ] = [ rhs ] mid - [ ] [ 0 0 0 ... zhL zhM 0 ][ ] [ ] [ ] mid - [ ] [ 0 0 0 ... 0 zhM zhN ][ ] [ ] [ ] mid - [ ] [ 0 0 0 ... 0 0 zhN ][ ] [ ] [ ] right - and solve for constants C. - - Arguments - --------- - phi : float - Inclination (degrees). - li : ndarray - List of lengths of segements (mm). - mi : ndarray - List of skier weigths (kg) at segement boundaries. - ki : ndarray - List of one bool per segement indicating whether segement - has foundation (True) or not (False). - - Returns - ------- - C : ndarray - Matrix(6xN) of solution constants for a system of N - segements. Columns contain the 6 constants of each segement. - """ - # --- CATCH ERRORS ---------------------------------------------------- - - # No foundation - if not any(ki): - raise ValueError("Provide at least one supported segment.") - # Mismatch of number of segements and transisions - if len(li) != len(ki) or len(li) - 1 != len(mi): - raise ValueError( - "Make sure len(li)=N, len(ki)=N, and " - "len(mi)=N-1 for a system of N segments." - ) - - if self.system not in ["pst-", "-pst", "vpst-", "-vpst", "rot", "trans"]: - # Boundary segments must be on foundation for infinite BCs - if not all([ki[0], ki[-1]]): - raise ValueError( - "Provide supported boundary segments in " - "order to account for infinite extensions." - ) - # Make sure infinity boundary conditions are far enough from skiers - if li[0] < 5e3 or li[-1] < 5e3: - print( - ( - "WARNING: Boundary segments are short. Make sure " - "the complementary solution has decayed to the " - "boundaries." - ) - ) - - # --- PREPROCESSING --------------------------------------------------- - - # Determine size of linear system of equations - nS = len(li) # Number of beam segments - - nDOF = 6 # Number of free constants per segment - - # Add dummy segment if only one segment provided - if nS == 1: - li.append(0) - ki.append(True) - mi.append(0) - nS = 2 - - # Assemble position vector - pi = np.full(nS, "m") - pi[0], pi[-1] = "l", "r" - - # Initialize matrices - zh0 = np.zeros([nS * 6, nS * nDOF]) - zp0 = np.zeros([nS * 6, 1]) - rhs = np.zeros([nS * 6, 1]) - - # --- ASSEMBLE LINEAR SYSTEM OF EQUATIONS ----------------------------- - - # Loop through segments to assemble left-hand side - for i in range(nS): - # Length, foundation and position of segment i - l, k, pos = li[i], ki[i], pi[i] - # Transmission conditions at left and right segment ends - zhi = self.eqs( - zl=self.zh(x=0, l=l, bed=k), zr=self.zh(x=l, l=l, bed=k), k=k, pos=pos - ) - zpi = self.eqs( - zl=self.zp(x=0, phi=phi, bed=k), - zr=self.zp(x=l, phi=phi, bed=k), - k=k, - pos=pos, - ) - # Rows for left-hand side assembly - start = 0 if i == 0 else 3 - stop = 6 if i == nS - 1 else 9 - # Assemble left-hand side - zh0[(6 * i - start) : (6 * i + stop), i * nDOF : (i + 1) * nDOF] = zhi - zp0[(6 * i - start) : (6 * i + stop)] += zpi - - # Loop through loads to assemble right-hand side - for i, m in enumerate(mi, start=1): - # Get skier loads - Fn, Ft = self.get_skier_load(m, phi) - # Right-hand side for transmission from segment i-1 to segment i - rhs[6 * i : 6 * i + 3] = np.vstack([Ft, -Ft * self.h / 2, Fn]) - # Set rhs so that complementary integral vanishes at boundaries - if self.system not in ["pst-", "-pst", "rested"]: - rhs[:3] = self.bc(self.zp(x=0, phi=phi, bed=ki[0])) - rhs[-3:] = self.bc(self.zp(x=li[-1], phi=phi, bed=ki[-1])) - - # Set rhs for vertical faces - if self.system in ["vpst-", "-vpst"]: - # Calculate center of gravity and mass of - # added or cut off slab segement - xs, zs, m = calc_vertical_bc_center_of_gravity(self.slab, phi) - # Convert slope angle to radians - phi = np.deg2rad(phi) - # Translate inbto section forces and moments - N = -self.g * m * np.sin(phi) - M = -self.g * m * (xs * np.cos(phi) + zs * np.sin(phi)) - V = self.g * m * np.cos(phi) - # Add to right-hand side - rhs[:3] = np.vstack([N, M, V]) # left end - rhs[-3:] = np.vstack([N, M, V]) # right end - - # Loop through segments to set touchdown conditions at rhs - for i in range(nS): - # Length, foundation and position of segment i - l, k, pos = li[i], ki[i], pi[i] - # Set displacement BC in stage B - if not k and bool(self.mode in ["B"]): - if i == 0: - rhs[:3] = np.vstack([0, 0, self.tc]) - if i == (nS - 1): - rhs[-3:] = np.vstack([0, 0, self.tc]) - # Set normal force and displacement BC for stage C - if not k and bool(self.mode in ["C"]): - N = self.calc_qt() * (self.a - self.td) - if i == 0: - rhs[:3] = np.vstack([-N, 0, self.tc]) - if i == (nS - 1): - rhs[-3:] = np.vstack([N, 0, self.tc]) - - # Rhs for substitute spring stiffness - if self.system in ["rot"]: - # apply arbitrary moment of 1 at left boundary - rhs = rhs * 0 - rhs[1] = 1 - if self.system in ["trans"]: - # apply arbitrary force of 1 at left boundary - rhs = rhs * 0 - rhs[2] = 1 - - # --- SOLVE ----------------------------------------------------------- - - # Solve z0 = zh0*C + zp0 = rhs for constants, i.e. zh0*C = rhs - zp0 - C = np.linalg.solve(zh0, rhs - zp0) - # Sort (nDOF = 6) constants for each segment into columns of a matrix - return C.reshape([-1, nDOF]).T - - -class AnalysisMixin: - """ - Mixin for the analysis of model outputs. - - Provides methods for the analysis of layered slabs on compliant - elastic foundations. - """ - - def rasterize_solution( - self, - C: np.ndarray, - phi: float, - li: list[float] | bool, - ki: list[bool] | bool, - num: int = 250, - **kwargs, - ): - """ - Compute rasterized solution vector. - - Arguments - --------- - C : ndarray - Vector of free constants. - phi : float - Inclination (degrees). - li : ndarray - List of segment lengths (mm). - ki : ndarray - List of booleans indicating whether segment lies on - a foundation or not. - num : int - Number of grid points. - - Returns - ------- - xq : ndarray - Grid point x-coordinates at which solution vector - is discretized. - zq : ndarray - Matrix with solution vectors as colums at grid - points xq. - xb : ndarray - Grid point x-coordinates that lie on a foundation. - """ - # Unused arguments - _ = kwargs - - # Drop zero-length segments - li = abs(li) - isnonzero = li > 0 - C, ki, li = C[:, isnonzero], ki[isnonzero], li[isnonzero] - - # Compute number of plot points per segment (+1 for last segment) - nq = np.ceil(li / li.sum() * num).astype("int") - nq[-1] += 1 - - # Provide cumulated length and plot point lists - lic = np.insert(np.cumsum(li), 0, 0) - nqc = np.insert(np.cumsum(nq), 0, 0) - - # Initialize arrays - issupported = np.full(nq.sum(), True) - xq = np.full(nq.sum(), np.nan) - zq = np.full([6, xq.size], np.nan) - - # Loop through segments - for i, l in enumerate(li): - # Get local x-coordinates of segment i - xi = np.linspace(0, l, num=nq[i], endpoint=(i == li.size - 1)) # pylint: disable=superfluous-parens - # Compute start and end coordinates of segment i - x0 = lic[i] - # Assemble global coordinate vector - xq[nqc[i] : nqc[i + 1]] = x0 + xi - # Mask coordinates not on foundation (including endpoints) - if not ki[i]: - issupported[nqc[i] : nqc[i + 1]] = False - # Compute segment solution - zi = self.z(xi, C[:, [i]], l, phi, ki[i]) - # Assemble global solution matrix - zq[:, nqc[i] : nqc[i + 1]] = zi - - # Make sure cracktips are included - transmissionbool = [ki[j] or ki[j + 1] for j, _ in enumerate(ki[:-1])] - for i, truefalse in enumerate(transmissionbool, start=1): - issupported[nqc[i]] = truefalse - - # Assemble vector of coordinates on foundation - xb = np.full(nq.sum(), np.nan) - xb[issupported] = xq[issupported] - - return xq, zq, xb - - def ginc(self, C0, C1, phi, li, ki, k0, **kwargs): - """ - Compute incremental energy relase rate of of all cracks. - - Arguments - --------- - C0 : ndarray - Free constants of uncracked solution. - C1 : ndarray - Free constants of cracked solution. - phi : float - Inclination (degress). - li : ndarray - List of segment lengths. - ki : ndarray - List of booleans indicating whether segment lies on - a foundation or not in the cracked configuration. - k0 : ndarray - List of booleans indicating whether segment lies on - a foundation or not in the uncracked configuration. - - Returns - ------- - ndarray - List of total, mode I, and mode II energy release rates. - """ - # Unused arguments - _ = kwargs - - # Make sure inputs are np.arrays - li, ki, k0 = np.array(li), np.array(ki), np.array(k0) - - # Reduce inputs to segments with crack advance - iscrack = k0 & ~ki - C0, C1, li = C0[:, iscrack], C1[:, iscrack], li[iscrack] - - # Compute total crack lenght and initialize outputs - da = li.sum() if li.sum() > 0 else np.nan - Ginc1, Ginc2 = 0, 0 - - # Loop through segments with crack advance - for j, l in enumerate(li): - # Uncracked (0) and cracked (1) solutions at integration points - z0 = partial(self.z, C=C0[:, [j]], l=l, phi=phi, bed=True) - z1 = partial(self.z, C=C1[:, [j]], l=l, phi=phi, bed=False) - - # Mode I (1) and II (2) integrands at integration points - int1 = partial(self.int1, z0=z0, z1=z1) - int2 = partial(self.int2, z0=z0, z1=z1) - - # Segement contributions to total crack opening integral - Ginc1 += quad(int1, 0, l, epsabs=self.tol, epsrel=self.tol)[0] / (2 * da) - Ginc2 += quad(int2, 0, l, epsabs=self.tol, epsrel=self.tol)[0] / (2 * da) - - return np.array([Ginc1 + Ginc2, Ginc1, Ginc2]).flatten() - - def gdif(self, C, phi, li, ki, unit="kJ/m^2", **kwargs): - """ - Compute differential energy release rate of all crack tips. - - Arguments - --------- - C : ndarray - Free constants of the solution. - phi : float - Inclination (degress). - li : ndarray - List of segment lengths. - ki : ndarray - List of booleans indicating whether segment lies on - a foundation or not in the cracked configuration. - - Returns - ------- - ndarray - List of total, mode I, and mode II energy release rates. - """ - # Unused arguments - _ = kwargs - - # Get number and indices of segment transitions - ntr = len(li) - 1 - itr = np.arange(ntr) - - # Identify supported-free and free-supported transitions as crack tips - iscracktip = [ki[j] != ki[j + 1] for j in range(ntr)] - - # Transition indices of crack tips and total number of crack tips - ict = itr[iscracktip] - nct = len(ict) - - # Initialize energy release rate array - Gdif = np.zeros([3, nct]) - - # Compute energy relase rate of all crack tips - for j, idx in enumerate(ict): - # Solution at crack tip - z = self.z(li[idx], C[:, [idx]], li[idx], phi, bed=ki[idx]) - # Mode I and II differential energy release rates - Gdif[1:, j] = np.concatenate((self.Gi(z, unit=unit), self.Gii(z, unit=unit))) - - # Sum mode I and II contributions - Gdif[0, :] = Gdif[1, :] + Gdif[2, :] - - # Adjust contributions for center cracks - if nct > 1: - avgmask = np.full(nct, True) # Initialize mask - avgmask[[0, -1]] = ki[[0, -1]] # Do not weight edge cracks - Gdif[:, avgmask] *= 0.5 # Weigth with half crack length - - # Return total differential energy release rate of all crack tips - return Gdif.sum(axis=1) - - def get_zmesh(self, dz=2): - """ - Get z-coordinates of grid points and corresponding elastic properties. - - Arguments - --------- - dz : float, optional - Element size along z-axis (mm). Default is 2 mm. - - Returns - ------- - mesh : ndarray - Mesh along z-axis. Columns are a list of z-coordinates (mm) of - grid points along z-axis with at least two grid points (top, - bottom) per layer, Young's modulus of each grid point, shear - modulus of each grid point, and Poisson's ratio of each grid - point. - """ - # Get ply (layer) coordinates - z = self.get_ply_coordinates() - # Compute number of grid points per layer - nlayer = np.ceil((z[1:] - z[:-1]) / dz).astype(np.int32) + 1 - # Calculate grid points as list of z-coordinates (mm) - zi = np.hstack( - [np.linspace(z[i], z[i + 1], n, endpoint=True) for i, n in enumerate(nlayer)] - ) - # Get lists of corresponding elastic properties (E, nu, rho) - si = np.repeat(self.slab[:, [2, 4, 0]], nlayer, axis=0) - # Assemble mesh with columns (z, E, G, nu) - return np.column_stack([zi, si]) - - def Sxx(self, Z, phi, dz=2, unit="kPa"): - """ - Compute axial normal stress in slab layers. - - Arguments - ---------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - dz : float, optional - Element size along z-axis (mm). Default is 2 mm. - unit : {'kPa', 'MPa'}, optional - Desired output unit. Default is 'kPa'. - - Returns - ------- - ndarray, float - Axial slab normal stress in specified unit. - """ - # Unit conversion dict - convert = {"kPa": 1e3, "MPa": 1} - - # Get mesh along z-axis - zmesh = self.get_zmesh(dz=dz) - zi = zmesh[:, 0] - rho = 1e-12 * zmesh[:, 3] - - # Get dimensions of stress field (n rows, m columns) - n = zmesh.shape[0] - m = Z.shape[1] - - # Initialize axial normal stress Sxx - Sxx = np.zeros(shape=[n, m]) - - # Compute axial normal stress Sxx at grid points in MPa - for i, (z, E, nu, _) in enumerate(zmesh): - Sxx[i, :] = E / (1 - nu**2) * self.du_dx(Z, z) - - # Calculate weight load at grid points and superimpose on stress field - qt = -rho * self.g * np.sin(np.deg2rad(phi)) - for i, qi in enumerate(qt[:-1]): - Sxx[i, :] += qi * (zi[i + 1] - zi[i]) - Sxx[-1, :] += qt[-1] * (zi[-1] - zi[-2]) - - # Return axial normal stress in specified unit - return convert[unit] * Sxx - - def Txz(self, Z, phi, dz=2, unit="kPa"): - """ - Compute shear stress in slab layers. - - Arguments - ---------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - dz : float, optional - Element size along z-axis (mm). Default is 2 mm. - unit : {'kPa', 'MPa'}, optional - Desired output unit. Default is 'kPa'. - - Returns - ------- - ndarray - Shear stress at grid points in the slab in specified unit. - """ - # Unit conversion dict - convert = {"kPa": 1e3, "MPa": 1} - # Get mesh along z-axis - zmesh = self.get_zmesh(dz=dz) - zi = zmesh[:, 0] - rho = 1e-12 * zmesh[:, 3] - - # Get dimensions of stress field (n rows, m columns) - n = zmesh.shape[0] - m = Z.shape[1] - - # Get second derivatives of centerline displacement u0 and - # cross-section rotaiton psi of all grid points along the x-axis - du0_dxdx = self.du0_dxdx(Z, phi) - dpsi_dxdx = self.dpsi_dxdx(Z, phi) - - # Initialize first derivative of axial normal stress sxx w.r.t. x - dsxx_dx = np.zeros(shape=[n, m]) - - # Calculate first derivative of sxx at z-grid points - for i, (z, E, nu, _) in enumerate(zmesh): - dsxx_dx[i, :] = E / (1 - nu**2) * (du0_dxdx + z * dpsi_dxdx) - - # Calculate weight load at grid points - qt = -rho * self.g * np.sin(np.deg2rad(phi)) - - # Integrate -dsxx_dx along z and add cumulative weight load - # to obtain shear stress Txz in MPa - Txz = cumulative_trapezoid(dsxx_dx, zi, axis=0, initial=0) - Txz += cumulative_trapezoid(qt, zi, initial=0)[:, None] - - # Return shear stress Txz in specified unit - return convert[unit] * Txz - - def Szz(self, Z, phi, dz=2, unit="kPa"): - """ - Compute transverse normal stress in slab layers. - - Arguments - ---------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - dz : float, optional - Element size along z-axis (mm). Default is 2 mm. - unit : {'kPa', 'MPa'}, optional - Desired output unit. Default is 'kPa'. - - Returns - ------- - ndarray, float - Transverse normal stress at grid points in the slab in - specified unit. - """ - # Unit conversion dict - convert = {"kPa": 1e3, "MPa": 1} - - # Get mesh along z-axis - zmesh = self.get_zmesh(dz=dz) - zi = zmesh[:, 0] - rho = 1e-12 * zmesh[:, 3] - - # Get dimensions of stress field (n rows, m columns) - n = zmesh.shape[0] - m = Z.shape[1] - - # Get third derivatives of centerline displacement u0 and - # cross-section rotaiton psi of all grid points along the x-axis - du0_dxdxdx = self.du0_dxdxdx(Z, phi) - dpsi_dxdxdx = self.dpsi_dxdxdx(Z, phi) - - # Initialize second derivative of axial normal stress sxx w.r.t. x - dsxx_dxdx = np.zeros(shape=[n, m]) - - # Calculate second derivative of sxx at z-grid points - for i, (z, E, nu, _) in enumerate(zmesh): - dsxx_dxdx[i, :] = E / (1 - nu**2) * (du0_dxdxdx + z * dpsi_dxdxdx) - - # Calculate weight load at grid points - qn = rho * self.g * np.cos(np.deg2rad(phi)) - - # Integrate dsxx_dxdx twice along z to obtain transverse - # normal stress Szz in MPa - integrand = cumulative_trapezoid(dsxx_dxdx, zi, axis=0, initial=0) - Szz = cumulative_trapezoid(integrand, zi, axis=0, initial=0) - Szz += cumulative_trapezoid(-qn, zi, initial=0)[:, None] - - # Return shear stress txz in specified unit - return convert[unit] * Szz - - def principal_stress_slab( - self, Z, phi, dz=2, unit="kPa", val="max", normalize=False - ): - """ - Compute maxium or minimum principal stress in slab layers. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - phi : float - Inclination (degrees). Counterclockwise positive. - dz : float, optional - Element size along z-axis (mm). Default is 2 mm. - unit : {'kPa', 'MPa'}, optional - Desired output unit. Default is 'kPa'. - val : str, optional - Maximum 'max' or minimum 'min' principal stress. Default is 'max'. - normalize : bool - Toggle layerwise normalization to strength. - - Returns - ------- - ndarray - Maximum or minimum principal stress in specified unit. - - Raises - ------ - ValueError - If specified principal stress component is neither 'max' nor - 'min', or if normalization of compressive principal stress - is requested. - """ - # Raise error if specified component is not available - if val not in ["min", "max"]: - raise ValueError(f"Component {val} not defined.") - - # Multiplier selection dict - m = {"max": 1, "min": -1} - - # Get axial normal stresses, shear stresses, transverse normal stresses - Sxx = self.Sxx(Z=Z, phi=phi, dz=dz, unit=unit) - Txz = self.Txz(Z=Z, phi=phi, dz=dz, unit=unit) - Szz = self.Szz(Z=Z, phi=phi, dz=dz, unit=unit) - - # Calculate principal stress - Ps = (Sxx + Szz) / 2 + m[val] * np.sqrt((Sxx - Szz) ** 2 + 4 * Txz**2) / 2 - - # Raise error if normalization of compressive stresses is attempted - if normalize and val == "min": - raise ValueError("Can only normlize tensile stresses.") - - # Normalize tensile stresses to tensile strength - if normalize and val == "max": - # Get layer densities - rho = self.get_zmesh(dz=dz)[:, 3] - # Normlize maximum principal stress to layers' tensile strength - return Ps / tensile_strength_slab(rho, unit=unit)[:, None] - - # Return absolute principal stresses - return Ps - - def principal_stress_weaklayer( - self, Z, sc=2.6, unit="kPa", val="min", normalize=False - ): - """ - Compute maxium or minimum principal stress in the weak layer. - - Arguments - --------- - Z : ndarray - Solution vector [u(x) u'(x) w(x) w'(x) psi(x), psi'(x)]^T - sc : float - Weak-layer compressive strength. Default is 2.6 kPa. - unit : {'kPa', 'MPa'}, optional - Desired output unit. Default is 'kPa'. - val : str, optional - Maximum 'max' or minimum 'min' principal stress. Default is 'min'. - normalize : bool - Toggle layerwise normalization to strength. - - Returns - ------- - ndarray - Maximum or minimum principal stress in specified unit. - - Raises - ------ - ValueError - If specified principal stress component is neither 'max' nor - 'min', or if normalization of tensile principal stress - is requested. - """ - # Raise error if specified component is not available - if val not in ["min", "max"]: - raise ValueError(f"Component {val} not defined.") - - # Multiplier selection dict - m = {"max": 1, "min": -1} - - # Get weak-layer normal and shear stresses - sig = self.sig(Z, unit=unit) - tau = self.tau(Z, unit=unit) - - # Calculate principal stress - ps = sig / 2 + m[val] * np.sqrt(sig**2 + 4 * tau**2) / 2 - - # Raise error if normalization of tensile stresses is attempted - if normalize and val == "max": - raise ValueError("Can only normlize compressive stresses.") - - # Normalize compressive stresses to compressive strength - if normalize and val == "min": - return ps / sc - - # Return absolute principal stresses - return ps - - -class OutputMixin: - """ - Mixin for outputs. - - Provides convenience methods for the assembly of output lists - such as rasterized displacements or rasterized stresses. - """ - - def external_potential(self, C, phi, L, **segments): - """ - Compute total external potential (pst only). - - Arguments - --------- - C : ndarray - Matrix(6xN) of solution constants for a system of N - segements. Columns contain the 6 constants of each segement. - phi : float - Inclination of the slab (Β°). - L : float, optional - Total length of model (mm). - segments : dict - Dictionary with lists of touchdown booleans (tdi), segement - lengths (li), skier weights (mi), and foundation booleans - in the cracked (ki) and uncracked (k0) configurations. - - Returns - ------- - Pi_ext : float - Total external potential (Nmm). - """ - # Rasterize solution - xq, zq, xb = self.rasterize_solution(C=C, phi=phi, **segments) - _ = xq, xb - # Compute displacements where weight loads are applied - w0 = self.w(zq) - us = self.u(zq, z0=self.zs) - # Get weight loads - qn = self.calc_qn() - qt = self.calc_qt() - # use +/- and us[0]/us[-1] according to system and phi - # compute total external potential - Pi_ext = ( - -qn * (segments["li"][0] + segments["li"][1]) * np.average(w0) - - qn * (L - (segments["li"][0] + segments["li"][1])) * self.tc - ) - # Ensure - if self.system in ["pst-"]: - ub = us[-1] - elif self.system in ["-pst"]: - ub = us[0] - Pi_ext += ( - -qt * (segments["li"][0] + segments["li"][1]) * np.average(us) - - qt * (L - (segments["li"][0] + segments["li"][1])) * ub - ) - if self.system not in ["pst-", "-pst"]: - print("Input error: Only pst-setup implemented at the moment.") - - return Pi_ext - - def internal_potential(self, C, phi, L, **segments): - """ - Compute total internal potential (pst only). - - Arguments - --------- - C : ndarray - Matrix(6xN) of solution constants for a system of N - segements. Columns contain the 6 constants of each segement. - phi : float - Inclination of the slab (Β°). - L : float, optional - Total length of model (mm). - segments : dict - Dictionary with lists of touchdown booleans (tdi), segement - lengths (li), skier weights (mi), and foundation booleans - in the cracked (ki) and uncracked (k0) configurations. - - Returns - ------- - Pi_int : float - Total internal potential (Nmm). - """ - # Rasterize solution - xq, zq, xb = self.rasterize_solution(C=C, phi=phi, **segments) - - # Compute section forces - N, M, V = self.N(zq), self.M(zq), self.V(zq) - - # Drop parts of the solution that are not a foundation - zweak = zq[:, ~np.isnan(xb)] - xweak = xb[~np.isnan(xb)] - - # Compute weak layer displacements - wweak = self.w(zweak) - uweak = self.u(zweak, z0=self.h / 2) - - # Compute stored energy of the slab (monte-carlo integration) - n = len(xq) - nweak = len(xweak) - # energy share from moment, shear force, wl normal and tangential springs - Pi_int = ( - L / 2 / n / self.A11 * np.sum([Ni**2 for Ni in N]) - + L - / 2 - / n - / (self.D11 - self.B11**2 / self.A11) - * np.sum([Mi**2 for Mi in M]) - + L / 2 / n / self.kA55 * np.sum([Vi**2 for Vi in V]) - + L * self.kn / 2 / nweak * np.sum([wi**2 for wi in wweak]) - + L * self.kt / 2 / nweak * np.sum([ui**2 for ui in uweak]) - ) - # energy share from substitute rotation spring - if self.system in ["pst-"]: - Pi_int += 1 / 2 * M[-1] * (self.psi(zq)[-1]) ** 2 - elif self.system in ["-pst"]: - Pi_int += 1 / 2 * M[0] * (self.psi(zq)[0]) ** 2 - else: - print("Input error: Only pst-setup implemented at the moment.") - - return Pi_int - - def total_potential(self, C, phi, L, **segments): - """ - Returns total differential potential - - Arguments - --------- - C : ndarray - Matrix(6xN) of solution constants for a system of N - segements. Columns contain the 6 constants of each segement. - phi : float - Inclination of the slab (Β°). - L : float, optional - Total length of model (mm). - segments : dict - Dictionary with lists of touchdown booleans (tdi), segement - lengths (li), skier weights (mi), and foundation booleans - in the cracked (ki) and uncracked (k0) configurations. - - Returns - ------- - Pi : float - Total differential potential (Nmm). - """ - Pi_int = self.internal_potential(C, phi, L, **segments) - Pi_ext = self.external_potential(C, phi, L, **segments) - - return Pi_int + Pi_ext - - def get_weaklayer_shearstress(self, x, z, unit="MPa", removeNaNs=False): - """ - Compute weak-layer shear stress. - - Arguments - --------- - x : ndarray - Discretized x-coordinates (mm) where coordinates of unsupported - (no foundation) segments are NaNs. - z : ndarray - Solution vectors at positions x as columns of matrix z. - unit : {'MPa', 'kPa'}, optional - Stress output unit. Default is MPa. - keepNaNs : bool - If set, do not remove - - Returns - ------- - x : ndarray - Horizontal coordinates (cm). - sig : ndarray - Normal stress (stress unit input). - """ - # Convert coordinates from mm to cm and stresses from MPa to unit - x = x / 10 - tau = self.tau(z, unit=unit) - # Filter stresses in unspupported segments - if removeNaNs: - # Remove coordinate-stress pairs where no weak layer is present - tau = tau[~np.isnan(x)] - x = x[~np.isnan(x)] - else: - # Set stress NaN where no weak layer is present - tau[np.isnan(x)] = np.nan - - return x, tau - - def get_weaklayer_normalstress(self, x, z, unit="MPa", removeNaNs=False): - """ - Compute weak-layer normal stress. - - Arguments - --------- - x : ndarray - Discretized x-coordinates (mm) where coordinates of unsupported - (no foundation) segments are NaNs. - z : ndarray - Solution vectors at positions x as columns of matrix z. - unit : {'MPa', 'kPa'}, optional - Stress output unit. Default is MPa. - keepNaNs : bool - If set, do not remove - - Returns - ------- - x : ndarray - Horizontal coordinates (cm). - sig : ndarray - Normal stress (stress unit input). - """ - # Convert coordinates from mm to cm and stresses from MPa to unit - x = x / 10 - sig = self.sig(z, unit=unit) - # Filter stresses in unspupported segments - if removeNaNs: - # Remove coordinate-stress pairs where no weak layer is present - sig = sig[~np.isnan(x)] - x = x[~np.isnan(x)] - else: - # Set stress NaN where no weak layer is present - sig[np.isnan(x)] = np.nan - - return x, sig - - def get_slab_displacement(self, x, z, loc="mid", unit="mm"): - """ - Compute horizontal slab displacement. - - Arguments - --------- - x : ndarray - Discretized x-coordinates (mm) where coordinates of - unsupported (no foundation) segments are NaNs. - z : ndarray - Solution vectors at positions x as columns of matrix z. - loc : {'top', 'mid', 'bot'} - Get displacements of top, midplane or bottom of slab. - Default is mid. - unit : {'m', 'cm', 'mm', 'um'}, optional - Displacement output unit. Default is mm. - - Returns - ------- - x : ndarray - Horizontal coordinates (cm). - ndarray - Horizontal displacements (unit input). - """ - # Coordinates (cm) - x = x / 10 - # Locator - z0 = {"top": -self.h / 2, "mid": 0, "bot": self.h / 2} - # Displacement (unit) - u = self.u(z, z0=z0[loc], unit=unit) - # Output array - return x, u - - def get_slab_deflection(self, x, z, unit="mm"): - """ - Compute vertical slab displacement. - - Arguments - --------- - x : ndarray - Discretized x-coordinates (mm) where coordinates of - unsupported (no foundation) segments are NaNs. - z : ndarray - Solution vectors at positions x as columns of matrix z. - Default is mid. - unit : {'m', 'cm', 'mm', 'um'}, optional - Displacement output unit. Default is mm. - - Returns - ------- - x : ndarray - Horizontal coordinates (cm). - ndarray - Vertical deflections (unit input). - """ - # Coordinates (cm) - x = x / 10 - # Deflection (unit) - w = self.w(z, unit=unit) - # Output array - return x, w - - def get_slab_rotation(self, x, z, unit="degrees"): - """ - Compute slab cross-section rotation angle. - - Arguments - --------- - x : ndarray - Discretized x-coordinates (mm) where coordinates of - unsupported (no foundation) segments are NaNs. - z : ndarray - Solution vectors at positions x as columns of matrix z. - Default is mid. - unit : {'deg', degrees', 'rad', 'radians'}, optional - Rotation angle output unit. Default is degrees. - - Returns - ------- - x : ndarray - Horizontal coordinates (cm). - ndarray - Cross section rotations (unit input). - """ - # Coordinates (cm) - x = x / 10 - # Cross-section rotation angle (unit) - psi = self.psi(z, unit=unit) - # Output array - return x, psi diff --git a/weac/plot.py b/weac/plot.py deleted file mode 100644 index 9f5b75c..0000000 --- a/weac/plot.py +++ /dev/null @@ -1,675 +0,0 @@ -"""Plotting resources for the WEak Layer AntiCrack nucleation model.""" -# pylint: disable=invalid-name,too-many-locals,too-many-branches -# pylint: disable=too-many-arguments,too-many-statements - -# Standard library imports -import colorsys -import os - -# Third party imports -import matplotlib.colors as mc -import matplotlib.pyplot as plt -import numpy as np - -# Local application imports -from weac.tools import isnotebook - -# === SET PLOT STYLES ========================================================= - - -def set_plotstyles(): - """Define styles plot markers, labels and colors.""" - labelstyle = { # Text style of plot labels - "backgroundcolor": "w", - "horizontalalignment": "center", - "verticalalignment": "center", - } - # markerstyle = { # Style of plot markers - # 'marker': 'o', - # 'markersize': 5, - # 'markerfacecolor': 'w', - # 'zorder': 3} - colors = np.array( - [ # TUD color palette - ["#DCDCDC", "#B5B5B5", "#898989", "#535353"], # gray - ["#5D85C3", "#005AA9", "#004E8A", "#243572"], # blue - ["#009CDA", "#0083CC", "#00689D", "#004E73"], # ocean - ["#50B695", "#009D81", "#008877", "#00715E"], # teal - ["#AFCC50", "#99C000", "#7FAB16", "#6A8B22"], # green - ["#DDDF48", "#C9D400", "#B1BD00", "#99A604"], # lime - ["#FFE05C", "#FDCA00", "#D7AC00", "#AE8E00"], # yellow - ["#F8BA3C", "#F5A300", "#D28700", "#BE6F00"], # sand - ["#EE7A34", "#EC6500", "#CC4C03", "#A94913"], # orange - ["#E9503E", "#E6001A", "#B90F22", "#961C26"], # red - ["#C9308E", "#A60084", "#951169", "#732054"], # magenta - ["#804597", "#721085", "#611C73", "#4C226A"], # purple - ] - ) - return labelstyle, colors - - -# === CONVENIENCE FUNCTIONS =================================================== - - -class MidpointNormalize(mc.Normalize): - """Colormap normalization to a specified midpoint. Default is 0.""" - - def __init__(self, vmin, vmax, midpoint=0, clip=False): - """Inizialize normalization.""" - self.midpoint = midpoint - mc.Normalize.__init__(self, vmin, vmax, clip) - - def __call__(self, value, clip=None): - """Make instances callable as functions.""" - normalized_min = max( - 0, - 0.5 * (1 - abs((self.midpoint - self.vmin) / (self.midpoint - self.vmax))), - ) - normalized_max = min( - 1, - 0.5 * (1 + abs((self.vmax - self.midpoint) / (self.midpoint - self.vmin))), - ) - normalized_mid = 0.5 - x, y = ( - [self.vmin, self.midpoint, self.vmax], - [normalized_min, normalized_mid, normalized_max], - ) - return np.ma.masked_array(np.interp(value, x, y)) - - -def outline(grid): - """Extract outline values of a 2D array (matrix, grid).""" - top = grid[0, :-1] - right = grid[:-1, -1] - bot = grid[-1, :0:-1] - left = grid[::-1, 0] - - return np.hstack([top, right, bot, left]) - - -def significant_digits(decimal): - """ - Get the number of significant digits. - - Arguments - --------- - decimal : float - Decimal number. - - Returns - ------- - int - Number of significant digits. - """ - return -int(np.floor(np.log10(decimal))) - - -def tight_central_distribution(limit, samples=100, tightness=1.5): - """ - Provide values within a given interval distributed tightly around 0. - - Parameters - ---------- - limit : float - Maximum and minimum of value range. - samples : int, optional - Number of values. Default is 100. - tightness : int, optional - Degree of value densification at center. 1.0 corresponds - to equal spacing. Default is 1.5. - - Returns - ------- - ndarray - Array of values more tightly spaced around 0. - """ - stop = limit ** (1 / tightness) - levels = np.linspace(0, stop, num=int(samples / 2), endpoint=True) ** tightness - return np.unique(np.hstack([-levels[::-1], levels])) - - -def adjust_lightness(color, amount=0.5): - """ - Adjust color lightness. - - Arguments - ---------- - color : str or tuple - Matplotlib colorname, hex string, or RGB value tuple. - amount : float, optional - Amount of lightening: >1 lightens, <1 darkens. Default is 0.5. - - Returns - ------- - tuple - RGB color tuple. - """ - try: - c = mc.cnames[color] - except KeyError: - c = color - c = colorsys.rgb_to_hls(*mc.to_rgb(c)) - return colorsys.hls_to_rgb(c[0], max(0, min(1, amount * c[1])), c[2]) - - -# === PLOT SLAB PROFILE ======================================================= - - -def slab_profile(instance): - """Create bar chart of slab profile.""" - # Plot Setup - plt.rcdefaults() - plt.rc("font", family="serif", size=10) - plt.rc("mathtext", fontset="cm") - - # Create figure - fig = plt.figure(figsize=(8 / 3, 4)) - ax1 = fig.gca() - - # Initialize coordinates - x = [] - y = [] - total_heigth = 0 - - for line in np.flipud(instance.slab): - x.append(line[0]) - x.append(line[0]) - - y.append(total_heigth) - total_heigth = total_heigth + line[1] - y.append(total_heigth) - - # Set axis labels - ax1.set_xlabel(r"$\longleftarrow$ Density $\rho$ (kg/m$^3$)") - ax1.set_ylabel(r"Height above weak layer (mm) $\longrightarrow$") - - ax1.set_xlim(500, 0) - - ax1.fill_betweenx(y, 0, x) - - # Save figure - save_plot(name="profile") - - # Reset plot styles - plt.rcdefaults() - - # Clear Canvas - plt.close() - - -# === DEFORMATION CONTOUR PLOT ================================================ - - -def deformed( - instance, - xsl, - xwl, - z, - phi, - dz=2, - scale=100, - window=np.inf, - pad=2, - levels=300, - aspect=2, - field="principal", - normalize=True, - dark=False, - filename="cont", -): - """ - Plot 2D deformed solution with displacement or stress fields. - - Arguments - --------- - instance : object - Instance of layered class. - xsl : ndarray - Discretized slab x-coordinates (mm). - xwl : ndarray - Discretized weak-layer x-coordinates (mm). - z : ndarray - Solution vectors at positions x as columns of matrix z. - phi : float - Inclination (degrees). Counterclockwise positive. - dz : float, optional - Element size along z-axis (mm) for stress plot. Default is 2 mm. - scale : int, optional - Scaling factor for the visualization of displacements. Default - is 100. - window : int, optional - Plot window (cm) around maximum vertical deflection. Default - is inf (full view). - pad : float, optional - Padding around shown geometry. Default is 2. - levels : int, optional - Number of isolevels. Default is 300. - aspect : int, optional - Aspect ratio of the displayed geometry. 1 is true to scale. - Default is 2. - field : {'u', 'w', 'Sxx', 'Txz', 'Szz', 'principal'}, optional - Field quantity for contour plot. Axial deformation 'u', vertical - deflection 'w', axial normal stress 'Sxx', shear stress 'Txz', - transverse normal stress 'Szz', or principal stresses 'principal'. - normalize : bool, optional - Toggle layerwise normalization of principal stresses to respective - strength. Only available with field='principal'. Default is True. - dark : bool, optional - Toggle display on dark figure background. Default is False. - - Raises - ------ - ValueError - If invalid stress or displacement field is requested. - """ - # Plot Setup - plt.rcdefaults() - plt.rc("font", family="serif", size=10) - plt.rc("mathtext", fontset="cm") - - # Set dark figure background if requested - if dark: - plt.style.use("dark_background") - fig = plt.figure() - ax = plt.gca() - fig.set_facecolor("#282c34") - ax.set_facecolor("white") - - # Calculate top-to-bottom vertical positions (mm) in beam coordinate system - zi = instance.get_zmesh(dz=dz)[:, 0] - h = instance.h - - # Compute slab displacements on grid (cm) - Usl = np.vstack([instance.u(z, z0=z0, unit="cm") for z0 in zi]) - Wsl = np.vstack([instance.w(z, unit="cm") for _ in zi]) - - # Put coordinate origin at horizontal center - if instance.system in ["skier", "skiers"]: - xsl = xsl - max(xsl) / 2 - xwl = xwl - max(xwl) / 2 - - # Compute slab grid coordinates with vertical origin at top surface (cm) - Xsl, Zsl = np.meshgrid(1e-1 * (xsl), 1e-1 * (zi + h / 2)) - - # Get x-coordinate of maximum deflection w (cm) and derive plot limits - xfocus = xsl[np.max(np.argmax(Wsl, axis=1))] / 10 - xmax = np.min([np.max([Xsl, Xsl + scale * Usl]) + pad, xfocus + window / 2]) - xmin = np.max([np.min([Xsl, Xsl + scale * Usl]) - pad, xfocus - window / 2]) - - # Scale shown weak-layer thickness with to max deflection and add padding - zmax = np.max(Zsl + scale * Wsl) + pad - zmin = np.min(Zsl) - pad - - # Compute weak-layer grid coordinates (cm) - Xwl, Zwl = np.meshgrid(1e-1 * xwl, [1e-1 * (zi[-1] + h / 2), zmax]) - - # Assemble weak-layer displacement field (top and bottom) - Uwl = np.row_stack([Usl[-1, :], np.zeros(xwl.shape[0])]) - Wwl = np.row_stack([Wsl[-1, :], np.zeros(xwl.shape[0])]) - - # Compute stress or displacement fields - match field: - # Horizontal displacements (um) - case "u": - slab = 1e4 * Usl - weak = 1e4 * Usl[-1, :] - label = r"$u$ ($\mu$m)" - # Vertical deflection (um) - case "w": - slab = 1e4 * Wsl - weak = 1e4 * Wsl[-1, :] - label = r"$w$ ($\mu$m)" - # Axial normal stresses (kPa) - case "Sxx": - slab = instance.Sxx(z, phi, dz=dz, unit="kPa") - weak = np.zeros(xwl.shape[0]) - label = r"$\sigma_{xx}$ (kPa)" - # Shear stresses (kPa) - case "Txz": - slab = instance.Txz(z, phi, dz=dz, unit="kPa") - weak = instance.get_weaklayer_shearstress(x=xwl, z=z, unit="kPa")[1] - label = r"$\tau_{xz}$ (kPa)" - # Transverse normal stresses (kPa) - case "Szz": - slab = instance.Szz(z, phi, dz=dz, unit="kPa") - weak = instance.get_weaklayer_normalstress(x=xwl, z=z, unit="kPa")[1] - label = r"$\sigma_{zz}$ (kPa)" - # Principal stresses - case "principal": - slab = instance.principal_stress_slab( - z, phi, dz=dz, val="max", unit="kPa", normalize=normalize - ) - weak = instance.principal_stress_weaklayer( - z, val="min", unit="kPa", normalize=normalize - ) - if normalize: - label = ( - r"$\sigma_\mathrm{I}/\sigma_+$ (slab), " - r"$\sigma_\mathrm{I\!I\!I}/\sigma_-$ (weak layer)" - ) - else: - label = ( - r"$\sigma_\mathrm{I}$ (kPa, slab), " - r"$\sigma_\mathrm{I\!I\!I}$ (kPa, weak layer)" - ) - case _: - raise ValueError( - f"Invalid input '{field}' for field. Valid options are " - "'u', 'w', 'Sxx', 'Txz', 'Szz', or 'principal'" - ) - - # Complement label - label += r" $\longrightarrow$" - - # Assemble weak-layer output on grid - weak = np.row_stack([weak, weak]) - - # Normalize colormap - absmax = np.nanmax(np.abs([slab.min(), slab.max(), weak.min(), weak.max()])) - clim = np.round(absmax, significant_digits(absmax)) - levels = np.linspace(-clim, clim, num=levels + 1, endpoint=True) - # nanmax = np.nanmax([slab.max(), weak.max()]) - # nanmin = np.nanmin([slab.min(), weak.min()]) - # norm = MidpointNormalize(vmin=nanmin, vmax=nanmax) - - # Plot baseline - plt.axhline(zmax, color="k", linewidth=1) - - # Plot outlines of the undeformed and deformed slab - plt.plot(outline(Xsl), outline(Zsl), "k--", alpha=0.3, linewidth=1) - plt.plot(outline(Xsl + scale * Usl), outline(Zsl + scale * Wsl), "k", linewidth=1) - - # Plot deformed weak-layer outline - if instance.system in ["-pst", "pst-", "-vpst", "vpst-"]: - nanmask = np.isfinite(xwl) - plt.plot( - outline(Xwl[:, nanmask] + scale * Uwl[:, nanmask]), - outline(Zwl[:, nanmask] + scale * Wwl[:, nanmask]), - "k", - linewidth=1, - ) - - # Colormap - cmap = plt.cm.RdBu_r - cmap.set_over(adjust_lightness(cmap(1.0), 0.9)) - cmap.set_under(adjust_lightness(cmap(0.0), 0.9)) - - # Plot fields - plt.contourf( - Xsl + scale * Usl, - Zsl + scale * Wsl, - slab, - levels=levels, # norm=norm, - cmap=cmap, - extend="both", - ) - plt.contourf( - Xwl + scale * Uwl, - Zwl + scale * Wwl, - weak, - levels=levels, # norm=norm, - cmap=cmap, - extend="both", - ) - - # Plot setup - plt.axis("scaled") - plt.xlim([xmin, xmax]) - plt.ylim([zmin, zmax]) - plt.gca().set_aspect(aspect) - plt.gca().invert_yaxis() - plt.gca().use_sticky_edges = False - - # Plot labels - plt.gca().set_xlabel(r"lateral position $x$ (cm) $\longrightarrow$") - plt.gca().set_ylabel("depth below surface\n" + r"$\longleftarrow $ $d$ (cm)") - plt.title(rf"${scale}\!\times\!$ scaled deformations (cm)", size=10) - - # Show colorbar - ticks = np.linspace(levels[0], levels[-1], num=11, endpoint=True) - plt.colorbar(orientation="horizontal", ticks=ticks, label=label, aspect=35) - - # Save figure - save_plot(name=filename) - - # Clear Canvas - plt.close() - - # Reset plot styles - plt.rcdefaults() - - -# === BASE PLOT FUNCTION ====================================================== - - -def plot_data( - name, - ax1data, - ax1label, - ax2data=None, - ax2label=None, - labelpos=None, - vlines=True, - li=False, - mi=False, - ki=False, - xlabel=r"Horizontal position $x$ (cm)", -): - """Plot data. Base function.""" - # Figure setup - plt.rcdefaults() - plt.rc("font", family="serif", size=10) - plt.rc("mathtext", fontset="cm") - - # Plot styles - labelstyle, colors = set_plotstyles() - - # Create figure - fig = plt.figure(figsize=(4, 8 / 3)) - ax1 = fig.gca() - - # Axis limits - ax1.autoscale(axis="x", tight=True) - - # Set axis labels - ax1.set_xlabel(xlabel + r" $\longrightarrow$") - ax1.set_ylabel(ax1label + r" $\longrightarrow$") - - # Plot x-axis - ax1.axhline(0, linewidth=0.5, color="gray") - - # Plot vertical separators - if vlines: - ax1.axvline(0, linewidth=0.5, color="gray") - for i, f in enumerate(ki): - if not f: - ax1.axvspan( - sum(li[:i]) / 10, - sum(li[: i + 1]) / 10, - facecolor="gray", - alpha=0.05, - zorder=100, - ) - for i, m in enumerate(mi, start=1): - if m > 0: - ax1.axvline(sum(li[:i]) / 10, linewidth=0.5, color="gray") - else: - ax1.autoscale(axis="y", tight=True) - - # Calculate labelposition - if not labelpos: - x = ax1data[0][0] - labelpos = int(0.95 * len(x[~np.isnan(x)])) - - # Fill left y-axis - i = 0 - for x, y, label in ax1data: - i += 1 - if label == "" or "FEA" in label: - # line, = ax1.plot(x, y, 'k:', linewidth=1) - ax1.plot(x, y, linewidth=3, color="white") - (line,) = ax1.plot(x, y, ":", linewidth=1) # , color='black' - thislabelpos = -2 - x, y = x[~np.isnan(x)], y[~np.isnan(x)] - xtx = (x[thislabelpos - 1] + x[thislabelpos]) / 2 - ytx = (y[thislabelpos - 1] + y[thislabelpos]) / 2 - ax1.text(xtx, ytx, label, color=line.get_color(), **labelstyle) - else: - # Plot line - ax1.plot(x, y, linewidth=3, color="white") - (line,) = ax1.plot(x, y, linewidth=1) - # Line label - x, y = x[~np.isnan(x)], y[~np.isnan(x)] - if len(x) > 0: - xtx = (x[labelpos - 10 * i - 1] + x[labelpos - 10 * i]) / 2 - ytx = (y[labelpos - 10 * i - 1] + y[labelpos - 10 * i]) / 2 - ax1.text(xtx, ytx, label, color=line.get_color(), **labelstyle) - - # Fill right y-axis - if ax2data: - # Create right y-axis - ax2 = ax1.twinx() - # Set axis label - ax2.set_ylabel(ax2label + r" $\longrightarrow$") - # Fill - for x, y, label in ax2data: - # Plot line - ax2.plot(x, y, linewidth=3, color="white") - (line,) = ax2.plot(x, y, linewidth=1, color=colors[8, 0]) - # Line label - x, y = x[~np.isnan(x)], y[~np.isnan(x)] - xtx = (x[labelpos - 1] + x[labelpos]) / 2 - ytx = (y[labelpos - 1] + y[labelpos]) / 2 - ax2.text(xtx, ytx, label, color=line.get_color(), **labelstyle) - - # Save figure - save_plot(name) - - # Clear canvas - plt.close() - - # Reset plot styles - plt.rcdefaults() - - -# === PLOT WRAPPERS =========================================================== - - -def displacements(instance, x, z, i="", **segments): - """Wrap for dispalcements plot.""" - data = [ - [x / 10, instance.u(z, z0=0, unit="mm"), r"$u_0\ (\mathrm{mm})$"], - [x / 10, -instance.w(z, unit="mm"), r"$-w\ (\mathrm{mm})$"], - [x / 10, instance.psi(z, unit="degrees"), r"$\psi\ (^\circ)$ "], - ] - plot_data(ax1label=r"Displacements", ax1data=data, name="disp" + str(i), **segments) - - -def section_forces(instance, x, z, i="", **segments): - """Wrap section forces plot.""" - data = [ - [x / 10, instance.N(z), r"$N$"], - [x / 10, instance.M(z), r"$M$"], - [x / 10, instance.V(z), r"$V$"], - ] - plot_data(ax1label=r"Section forces", ax1data=data, name="forc" + str(i), **segments) - - -def stresses(instance, x, z, i="", **segments): - """Wrap stress plot.""" - data = [ - [x / 10, instance.tau(z, unit="kPa"), r"$\tau$"], - [x / 10, instance.sig(z, unit="kPa"), r"$\sigma$"], - ] - plot_data(ax1label=r"Stress (kPa)", ax1data=data, name="stress" + str(i), **segments) - - -def stress_criteria(x, stress, **segments): - """Wrap plot of stress and energy criteria.""" - data = [[x / 10, stress, r"$\sigma/\sigma_\mathrm{c}$"]] - plot_data(ax1label=r"Criteria", ax1data=data, name="crit", **segments) - - -def err_comp(da, Gdif, Ginc, mode=0): - """Wrap energy release rate plot.""" - data = [ - [da / 10, 1e3 * Gdif[mode, :], r"$\mathcal{G}$"], - [da / 10, 1e3 * Ginc[mode, :], r"$\bar{\mathcal{G}}$"], - ] - plot_data( - xlabel=r"Crack length $\Delta a$ (cm)", - ax1label=r"Energy release rate (J/m$^2$)", - ax1data=data, - name="err", - vlines=False, - ) - - -def err_modes(da, G, kind="inc"): - """Wrap energy release rate plot.""" - label = r"$\bar{\mathcal{G}}$" if kind == "inc" else r"$\mathcal{G}$" - data = [ - [da / 10, 1e3 * G[2, :], label + r"$_\mathrm{I\!I}$"], - [da / 10, 1e3 * G[1, :], label + r"$_\mathrm{I}$"], - [da / 10, 1e3 * G[0, :], label + r"$_\mathrm{I+I\!I}$"], - ] - plot_data( - xlabel=r"Crack length $a$ (cm)", - ax1label=r"Energy release rate (J/m$^2$)", - ax1data=data, - name="modes", - vlines=False, - ) - - -def fea_disp(instance, x, z, fea): - """Wrap dispalcements plot.""" - data = [ - [fea[:, 0] / 10, -np.flipud(fea[:, 1]), r"FEA $u_0$"], - [fea[:, 0] / 10, np.flipud(fea[:, 2]), r"FEA $w_0$"], - # [fea[:, 0]/10, -np.flipud(fea[:, 3]), r'FEA $u(z=-h/2)$'], - # [fea[:, 0]/10, np.flipud(fea[:, 4]), r'FEA $w(z=-h/2)$'], - [fea[:, 0] / 10, np.flipud(np.rad2deg(fea[:, 5])), r"FEA $\psi$"], - [x / 10, instance.u(z, z0=0), r"$u_0$"], - [x / 10, -instance.w(z), r"$-w$"], - [x / 10, np.rad2deg(instance.psi(z)), r"$\psi$"], - ] - plot_data( - ax1label=r"Displacements (mm)", ax1data=data, name="fea_disp", labelpos=-50 - ) - - -def fea_stress(instance, xb, zb, fea): - """Wrap stress plot.""" - data = [ - [fea[:, 0] / 10, 1e3 * np.flipud(fea[:, 2]), r"FEA $\sigma_2$"], - [fea[:, 0] / 10, 1e3 * np.flipud(fea[:, 3]), r"FEA $\tau_{12}$"], - [xb / 10, instance.tau(zb, unit="kPa"), r"$\tau$"], - [xb / 10, instance.sig(zb, unit="kPa"), r"$\sigma$"], - ] - plot_data(ax1label=r"Stress (kPa)", ax1data=data, name="fea_stress", labelpos=-50) - - -# === SAVE FUNCTION =========================================================== - - -def save_plot(name): - """ - Show or save plot depending on interpreter - - Arguments - --------- - name : string - Name for the figure. - """ - filename = name + ".png" - # Show figure if on jupyter notebook - if isnotebook(): - plt.show() - # Save figure if on terminal - else: - # Make directory if not yet existing - if not os.path.isdir(os.path.join(os.getcwd(), "plots")): - os.mkdir("plots") - plt.savefig("plots/" + filename, bbox_inches="tight") - return diff --git a/weac/tools.py b/weac/tools.py deleted file mode 100644 index 448dce8..0000000 --- a/weac/tools.py +++ /dev/null @@ -1,334 +0,0 @@ -# pylint: disable=C0103 -"""Helper functions for the WEak Layer AntiCrack nucleation model.""" - -# Standard library imports -from timeit import default_timer as timer - -# Third party imports -import numpy as np - -import weac - -try: - from IPython import get_ipython -except ImportError: - get_ipython = None - - -def time(): - """Return current time in milliseconds.""" - return 1e3 * timer() - - -def isnotebook(): - """Identify shell environment.""" - try: - if get_ipython is None: - return False - shell = get_ipython().__class__.__name__ - if shell == "ZMQInteractiveShell": - return True # Jupyter notebook or qtconsole - elif shell == "TerminalInteractiveShell": - return False # Terminal running IPython - else: - return False # Other type - except (NameError, AttributeError): - return False # Probably standard Python interpreter - - -def load_dummy_profile(profile_id): - """Define standard layering types for comparison.""" - # Layers [density (kg/m^3), thickness (mm), Young's modulus (N/mm^2)] - soft = [180.0, 120.0, 5] - medium = [270.0, 120.0, 30] - hard = [350.0, 120.0, 93.8] - # soft = [120., 120., 0.3] - # medium = [180., 120., 1.5] - # hard = [270., 120., 7.5] - - # Database (top to bottom) - database = { - # Layered - "a": [hard, medium, soft], - "b": [soft, medium, hard], - "c": [hard, soft, hard], - "d": [soft, hard, soft], - "e": [hard, soft, soft], - "f": [soft, soft, hard], - # Homogeneous - "h": [medium, medium, medium], - "soft": [soft, soft, soft], - "medium": [medium, medium, medium], - "hard": [hard, hard, hard], - # Comparison - "comp": [ - [240.0, 200.0, 5.23], - ], - } - - # Load profile - try: - profile = np.array(database[profile_id.lower()]) - except KeyError: - raise ValueError(f"Profile {profile_id} is not defined.") from None - - # Prepare output - layers = profile[:, 0:2] - E = profile[:, 2] - - return layers, E - - -def calc_center_of_gravity(layers): - """ - Calculate z-coordinate of the center of gravity. - - Arguments - --------- - layers : ndarray - 2D list of layer densities and thicknesses. Columns are - density (kg/m^3) and thickness (mm). One row corresponds - to one layer. - - Returns - ------- - H : float - Total slab thickness (mm). - zs : float - Z-coordinate of center of gravity (mm). - """ - # Layering info for center of gravity calculation (bottom to top) - n = layers.shape[0] # Number of layers - rho = 1e-12 * np.flipud(layers[:, 0]) # Layer densities (kg/m^3 -> t/mm^3) - h = np.flipud(layers[:, 1]) # Layer thicknesses - H = sum(h) # Total slab thickness - # Layer center coordinates (bottom to top) - zi = [H / 2 - sum(h[0:j]) - h[j] / 2 for j in range(n)] - # Z-coordinate of the center of gravity - zs = sum(zi * h * rho) / sum(h * rho) - # Return slab thickness and center of gravity - return H, zs - - -def calc_vertical_bc_center_of_gravity(slab, phi): - """ - Calculate center of gravity of triangular slab segements for vertical PSTs. - - Parameters - ---------- - slab : ndarray - List of layer densities, thicknesses, and elastic properties. - Columns are density (kg/m^3), thickness (mm), Young's modulus - (MPa), shear modulus (MPa), and Poisson's ratio. One row corresponds - to one layer. - phi : fload - Slope angle (deg). - - Returns - ------- - xs : float - Horizontal coordinate of center of gravity (mm). - zs : float - Vertical coordinate of center of gravity (mm). - w : ndarray - Weight of the slab segment that is cut off or added (t). - """ - # Convert slope angle to radians - phi = np.deg2rad(phi) - - # Catch flat-field case - if phi == 0: - xs = 0 - zs = 0 - w = 0 - else: - # Layering info for center of gravity calculation (top to bottom) - n = slab.shape[0] # Number of slab - rho = 1e-12 * slab[:, 0] # Layer densities (kg/m^3 -> t/mm^3) - hi = slab[:, 1] # Layer thicknesses - H = sum(hi) # Total slab thickness - # Layer coordinates z_i (top to bottom) - z = np.array([-H / 2 + sum(hi[0:j]) for j in range(n + 1)]) - zi = z[:-1] # z_i - zii = z[1:] # z_{i+1} - # Center of gravity of all layers (top to bottom) - zsi = zi + hi / 3 * (3 / 2 * H - zi - 2 * zii) / (H - zi - zii) - # Surface area of all layers (top to bottom) - Ai = hi / 2 * (H - zi - zii) * np.tan(phi) - # Center of gravity in vertical direction - zs = sum(zsi * rho * Ai) / sum(rho * Ai) - # Center of gravity in horizontal direction - xs = (H / 2 - zs) * np.tan(phi / 2) - # Weight of added or cut off slab segments (t) - w = sum(Ai * rho) - - # Return center of gravity and weight of slab segment - return xs, zs, w - - -def scapozza(rho): - """ - Compute Young's modulus (MPa) from density (kg/m^3). - - Arguments - --------- - rho : float or ndarray - Density (kg/m^3). - - Returns - ------- - E : float or ndarray - Young's modulus (MPa). - """ - rho = rho * 1e-12 # Convert to t/mm^3 - rho0 = 917e-12 # Desity of ice in t/mm^3 - E = 5.07e3 * (rho / rho0) ** 5.13 # Young's modulus in MPa - return E - - -def gerling(rho, C0=6.0, C1=4.6): - """ - Compute Young's modulus from density according to Gerling et al. 2017. - - Arguments - --------- - rho : float or ndarray - Density (kg/m^3). - C0 : float, optional - Multiplicative constant of Young modulus parametrization - according to Gerling et al. (2017). Default is 6.0. - C1 : float, optional - Exponent of Young modulus parameterization according to - Gerling et al. (2017). Default is 4.6. - - Returns - ------- - E : float or ndarray - Young's modulus (MPa). - """ - return C0 * 1e-10 * rho**C1 - - -def bergfeld(rho, rho0=916.7, C0=6.5, C1=4.4): - """ - Compute Young's modulus from density according to Bergfeld et al. (2023). - - Arguments - --------- - rho : float or ndarray - Density (kg/m^3). - rho0 : float, optional - Density of ice (kg/m^3). Default is 917. - C0 : float, optional - Multiplicative constant of Young modulus parametrization - according to Bergfeld et al. (2023). Default is 6.5. - C1 : float, optional - Exponent of Young modulus parameterization according to - Bergfeld et al. (2023). Default is 4.4. - - Returns - ------- - E : float or ndarray - Young's modulus (MPa). - """ - return C0 * 1e3 * (rho / rho0) ** C1 - - -def tensile_strength_slab(rho, unit="kPa"): - """ - Estimate the tensile strength of a slab layer from its density. - - Uses the density parametrization of Sigrist (2006). - - Arguments - --------- - rho : ndarray, float - Layer density (kg/m^3). - unit : str, optional - Desired output unit of the layer strength. Default is 'kPa'. - - Returns - ------- - ndarray - Tensile strength in specified unit. - """ - convert = {"kPa": 1, "MPa": 1e-3, "m": 1, "mm": 1e3, "cm": 1e2} - rho_ice = 917 - # Sigrist's equation is given in kPa - value = convert[unit] * 240 * (rho / rho_ice) ** 2.44 - return value - - -def touchdown_distance( - layers: np.ndarray | str | None = None, - C0: float = 6.5, - C1: float = 4.4, - Ewl: float = 0.25, - t: float = 10, - phi: float = 0, -): - """ - Calculate cut length at first contanct and steady-state touchdown distance. - - Arguments - --------- - layers : list, optional - 2D list of layer densities and thicknesses. Columns are - density(kg/m ^ 3) and thickness(mm). One row corresponds - to one layer. Default is [[240, 200], ]. - C0 : float, optional - Multiplicative constant of Young modulus parametrization - according to Bergfeld et al. (2023). Default is 6.5. - C1 : float, optional - Exponent of Young modulus parameterization according to - Bergfeld et al. (2023). Default is 4.4. - Ewl : float, optional - Young's modulus of the weak layer (MPa). Default is 0.25. - t : float, optional - Thickness of the weak layer (mm). Default is 10. - phi : float, optional - Inclination of the slab (Β°). Default is 0. - - Returns - ------- - first_contact : float - Cut length at first contact (mm). - full_contact : float - Cut length at which the slab comes into full contact (more than - a singular point) with the base layer (mm). - steady_state : float - Steady-state touchdown distance (mm). - """ - # Check if layering is defined - layers = ( - layers - if layers - else [ - [240, 200], - ] - ) - - # Initialize model with user input - touchdown = weac.Layered(system="pst-", touchdown=True) - - # Set material properties - touchdown.set_foundation_properties(E=Ewl, t=t, update=True) - touchdown.set_beam_properties(layers=layers, C0=C0, C1=C1, update=True) - - # Assemble very long dummy PST to compute crack length where the slab - # first comes in contact with base layer after weak-layer collapse - touchdown.calc_segments(L=1e5, a=0, phi=phi) - first_contact = touchdown.calc_a1() - - # Compute ut length at which the slab comes into full contact (more - # than a singular point) with the base layer - full_contact = touchdown.calc_a2() - - # Compute steady-state touchdown distance in a dummy PST with a cut - # of 5 times the first contact distance - touchdown.calc_segments(L=1e5, a=5 * first_contact, phi=phi) - steady_state = touchdown.calc_lC() - - # Return first-contact cut length, full-contact cut length, - # and steady-state touchdown distance (mm) - return first_contact, full_contact, steady_state diff --git a/weac/utils/__init__.py b/weac/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/weac/utils/geldsetzer.py b/weac/utils/geldsetzer.py new file mode 100644 index 0000000..ce5e214 --- /dev/null +++ b/weac/utils/geldsetzer.py @@ -0,0 +1,166 @@ +""" +Hand hardness + Grain Type Parameterization to Density +according to Geldsetzer & Jamieson (2000) +`https://arc.lib.montana.edu/snow-science/objects/issw-2000-121-127.pdf` + +Inputs: +Hand Hardness + Grain Type +Output: +Density [kg/m^3] +""" + +SKIP_VALUE = "!skip" + + +DENSITY_PARAMETERS = { + SKIP_VALUE: (0, 0), + "SH": (125, 0), # 125 kg/m^3 so that bergfeld is E~1.0 + "PP": (45, 36), + "PPgp": (83, 37), + "DF": (65, 36), + "FCmx": (56, 64), + "FC": (112, 46), + "DH": (185, 25), + "RGmx": (91, 42), + "RG": (154, 1.51), + "MFCr": (292.25, 0), +} + +# Map SnowPilot grain type to those we know +GRAIN_TYPE = { + "": SKIP_VALUE, + "DF": "DF", + "DFbk": "DF", + "DFdc": "DF", + "DH": "DH", + "DHch": "DH", + "DHcp": "DH", + "DHla": "DH", + "DHpr": "DH", + "DHxr": "DH", + "FC": "FC", + "FCsf": "FCmx", + "FCso": "FCmx", + "FCxr": "FCmx", + "IF": "MFCr", + "IFbi": "MFCr", + "IFic": "MFCr", + "IFil": "MFCr", + "IFrc": "MFCr", + "IFsc": "MFCr", + "MF": "MFCr", + "MFcl": "MFCr", + "MFcr": "MFCr", + "MFpc": "MFCr", + "MFsl": "MFCr", + "PP": "PP", + "PPco": "PP", + "PPgp": "PPgp", + "gp": "PPgp", + "PPhl": "PP", + "PPip": "PP", + "PPir": "PP", + "PPnd": "PP", + "PPpl": "PP", + "PPrm": "PP", + "PPsd": "PP", + "RG": "RG", + "RGlr": "RGmx", + "RGsr": "RGmx", + "RGwp": "RGmx", + "RGxf": "RGmx", + "SH": "SH", + "SHcv": "SH", + "SHsu": "SH", + "SHxr": "SH", + "WG": "WG", +} + +# Translate hand hardness to numerical values +HAND_HARDNESS = { + "": SKIP_VALUE, + "F-": 0.67, + "F": 1, + "F+": 1.33, + "4F-": 1.67, + "4F": 2, + "4F+": 2.33, + "1F-": 2.67, + "1F": 3, + "1F+": 3.33, + "P-": 3.67, + "P": 4, + "P+": 4.33, + "K-": 4.67, + "K": 5, + "K+": 5.33, + "I-": 5.67, + "I": 6, + "I+": 6.33, +} + +GRAIN_TYPE_TO_DENSITY = { + "PP": 84.9, + "PPgp": 162.3, + "DF": 136.3, + "RG": 247.4, + "RGmx": 220.6, + "FC": 248.2, + "FCmx": 288.8, + "DH": 252.8, + "WG": 254.3, + "MFCr": 292.3, + "SH": 125, +} + +HAND_HARDNESS_TO_DENSITY = { + "F-": 71.7, + "F": 103.7, + "F+": 118.4, + "4F-": 127.9, + "4F": 158.2, + "4F+": 163.7, + "1F-": 188.6, + "1F": 208, + "1F+": 224.4, + "P-": 252.8, + "P": 275.9, + "P+": 314.6, + "K-": 359.1, + "K": 347.4, + "K+": 407.8, + "I-": 407.8, + "I": 407.8, + "I+": 407.8, +} + + +def compute_density(grainform: str | None, hardness: str | None) -> float: + """ + Geldsetzer & Jamieson (2000) + `https://arc.lib.montana.edu/snow-science/objects/issw-2000-121-127.pdf` + """ + # Adaptation based on CAAML profiles (which sometimes provide top and bottom hardness) + if hardness is None and grainform is None: + raise ValueError("Provide at least one of grainform or hardness") + if hardness is None: + grain_type = GRAIN_TYPE[grainform] + return GRAIN_TYPE_TO_DENSITY[grain_type] + if grainform is None: + return HAND_HARDNESS_TO_DENSITY[hardness] + + hardness_value = HAND_HARDNESS[hardness] + grain_type = GRAIN_TYPE[grainform] + a, b = DENSITY_PARAMETERS[grain_type] + + if grain_type == SKIP_VALUE: + raise ValueError(f"Grain type is {SKIP_VALUE}") + if hardness_value == SKIP_VALUE: + raise ValueError(f"Hardness value is {SKIP_VALUE}") + + if grain_type == "RG": + # Special computation for 'RG' grain form + rho = a + b * (hardness_value**3.15) + else: + rho = a + b * hardness_value + return rho diff --git a/weac/utils/misc.py b/weac/utils/misc.py new file mode 100644 index 0000000..a7e1559 --- /dev/null +++ b/weac/utils/misc.py @@ -0,0 +1,127 @@ +""" +This module contains miscellaneous utility functions. +""" + +from typing import Literal + +import numpy as np + +from weac.components import Layer +from weac.constants import G_MM_S2, LSKI_MM + + +def decompose_to_normal_tangential(f: float, phi: float) -> tuple[float, float]: + """ + Resolve a gravity-type force/line-load into its tangential (downslope) and + normal (into-slope) components with respect to an inclined surface. + + Parameters + ---------- + f : float + is interpreted as a vertical load magnitude + acting straight downward (global y negative). + phi : float + Surface dip angle `in degrees`, measured from horizontal. + Positive `phi` means the surface slopes upward in +x. + + Returns + ------- + f_norm, f_tan : float + Magnitudes of the tangential ( + downslope ) and normal + ( + into-slope ) components, respectively. + """ + # Convert units + phi = np.deg2rad(phi) # Convert inclination to rad + # Split into components + f_norm = f * np.cos(phi) # Normal direction + f_tan = -f * np.sin(phi) # Tangential direction + return f_norm, f_tan + + +def get_skier_point_load(m: float) -> float: + """ + Calculate skier point load. + + Arguments + --------- + m : float + Skier weight [kg]. + + Returns + ------- + f : float + Skier load [N/mm]. + """ + F = 1e-3 * m * G_MM_S2 / LSKI_MM # Total skier + return F + + +def load_dummy_profile( + profile_id: Literal[ + "a", "b", "c", "d", "e", "f", "h", "soft", "medium", "hard", "comp" + ], +) -> list[Layer]: + """Define standard layering types for comparison.""" + soft_layer = Layer(rho=180, h=120, E=5) + medium_layer = Layer(rho=270, h=120, E=30) + hard_layer = Layer(rho=350, h=120, E=93.8) + + tested_layers = [ + Layer(rho=350, h=120), + Layer(rho=270, h=120), + Layer(rho=180, h=120), + ] + + # Database (top to bottom) + database = { + # Layered + "a": [hard_layer, medium_layer, soft_layer], + "b": [soft_layer, medium_layer, hard_layer], + "c": [hard_layer, soft_layer, hard_layer], + "d": [soft_layer, hard_layer, soft_layer], + "e": [hard_layer, soft_layer, soft_layer], + "f": [soft_layer, soft_layer, hard_layer], + "tested": tested_layers, + # Homogeneous + "h": [medium_layer, medium_layer, medium_layer], + "soft": [soft_layer, soft_layer, soft_layer], + "medium": [medium_layer, medium_layer, medium_layer], + "hard": [hard_layer, hard_layer, hard_layer], + # Comparison + "comp": [ + Layer(rho=240, h=200, E=5.23), + ], + } + + # Load profile + try: + profile = database[profile_id.lower()] + except KeyError: + raise ValueError(f"Profile {profile_id} is not defined.") from None + return profile + + +def isnotebook() -> bool: + """ + Check if code is running in a Jupyter notebook environment. + + Returns + ------- + bool + True if running in Jupyter notebook, False otherwise. + """ + try: + # Check if we're in IPython + from IPython import get_ipython # pylint: disable=import-outside-toplevel + + if get_ipython() is None: + return False + + # Check if we're specifically in a notebook (not just IPython terminal) + if get_ipython().__class__.__name__ == "ZMQInteractiveShell": + return True # Jupyter notebook + if get_ipython().__class__.__name__ == "TerminalInteractiveShell": + return False # IPython terminal + return False # Other IPython environments + except ImportError: + return False # IPython not available diff --git a/weac/utils/snow_types.py b/weac/utils/snow_types.py new file mode 100644 index 0000000..7e4d9c4 --- /dev/null +++ b/weac/utils/snow_types.py @@ -0,0 +1,82 @@ +""" +Snow grain types and hand hardness values. + +These values are used in Pydantic models for validation and correspond to the +parameterizations available in `geldsetzer.py`. +""" + +from enum import Enum + + +class GrainType(str, Enum): + """SnowPilot grain type codes (see `geldsetzer.GRAIN_TYPE`).""" + + DF = "DF" + DFbk = "DFbk" + DFdc = "DFdc" + DH = "DH" + DHch = "DHch" + DHcp = "DHcp" + DHla = "DHla" + DHpr = "DHpr" + DHxr = "DHxr" + FC = "FC" + FCsf = "FCsf" + FCso = "FCso" + FCxr = "FCxr" + IF = "IF" + IFbi = "IFbi" + IFic = "IFic" + IFil = "IFil" + IFrc = "IFrc" + IFsc = "IFsc" + MF = "MF" + MFcl = "MFcl" + MFcr = "MFcr" + MFpc = "MFpc" + MFsl = "MFsl" + PP = "PP" + PPco = "PPco" + PPgp = "PPgp" + PPhl = "PPhl" + PPip = "PPip" + PPir = "PPir" + PPnd = "PPnd" + PPpl = "PPpl" + PPrm = "PPrm" + PPsd = "PPsd" + RG = "RG" + RGlr = "RGlr" + RGsr = "RGsr" + RGwp = "RGwp" + RGxf = "RGxf" + SH = "SH" + SHcv = "SHcv" + SHsu = "SHsu" + SHxr = "SHxr" + + +class HandHardness(str, Enum): + """Field hand hardness codes (see `geldsetzer.HAND_HARDNESS`). + + Enum member names avoid starting with digits and special characters. + """ + + Fm = "F-" + F = "F" + Fp = "F+" + _4Fm = "4F-" + _4F = "4F" + _4Fp = "4F+" + _1Fm = "1F-" + _1F = "1F" + _1Fp = "1F+" + Pm = "P-" + P = "P" + Pp = "P+" + Km = "K-" + K = "K" + Kp = "K+" + Im = "I-" + I = "I" + Ip = "I+" diff --git a/weac/utils/snowpilot_parser.py b/weac/utils/snowpilot_parser.py new file mode 100644 index 0000000..3c015ec --- /dev/null +++ b/weac/utils/snowpilot_parser.py @@ -0,0 +1,332 @@ +""" +Utilizes the snowpylot library to convert a CAAML file to a WEAC ModelInput. + +The snowpylot library is used to parse the CAAML file and extract the snowpit. +The snowpit is then converted to a List of WEAC ModelInput. + +Based on the different stability tests performed, several scenarios are created. +Each scenario is a WEAC ModelInput. + +The scenarios are created based on the following logic: +- For each PropSawTest, a scenario is created with `the cut length` and `a standard segment.` +- For each ExtColumnTest, a scenario is created with `a standard segment.` +- For each ComprTest, a scenario is created with `a standard segment.` +- For each RBlockTest, a scenario is created with `a standard segment.` + +The `a standard segment` is a segment with a length of 1000 mm and a foundation of True. + +The `the cut length` is the cut length of the PropSawTest. +The `the column length` is the column length of the PropSawTest. +""" + +import logging +from typing import List, Tuple + +import numpy as np +from snowpylot import caaml_parser +from snowpylot.layer import Layer as SnowpylotLayer +from snowpylot.snow_pit import SnowPit +from snowpylot.snow_profile import DensityObs + +# Import WEAC components +from weac.components import ( + Layer, + WeakLayer, +) +from weac.utils.geldsetzer import compute_density + +logger = logging.getLogger(__name__) + +convert_to_mm = {"cm": 10, "mm": 1, "m": 1000, "dm": 100} +convert_to_deg = {"deg": 1, "rad": 180 / np.pi} + + +class SnowPilotParser: + """Parser for SnowPilot files using the snowpylot library.""" + + def __init__(self, file_path: str): + self.snowpit: SnowPit = caaml_parser(file_path) + + def extract_layers(self) -> Tuple[List[Layer], List[str]]: + """Extract layers from snowpit.""" + snowpit = self.snowpit + # Extract layers from snowpit: List[SnowpylotLayer] + sp_layers: List[SnowpylotLayer] = [ + layer + for layer in snowpit.snow_profile.layers + if layer.depth_top is not None + ] + sp_layers = sorted(sp_layers, key=lambda x: x.depth_top[0]) # type: ignore + + # Extract density layers from snowpit: List[DensityObs] + sp_density_layers: List[DensityObs] = [ + layer + for layer in snowpit.snow_profile.density_profile + if layer.depth_top is not None + ] + sp_density_layers = sorted(sp_density_layers, key=lambda x: x.depth_top[0]) # type: ignore + + # Populate WEAC layers: List[Layer] + layers: List[Layer] = [] + density_methods: List[str] = [] + for _i, layer in enumerate(sp_layers): + # Parameters + grain_type = None + grain_size = None + hand_hardness = None + density = None + thickness = None + + # extract THICKNESS + if layer.thickness is not None: + thickness, unit = layer.thickness + thickness = thickness * convert_to_mm[unit] # Convert to mm + else: + raise ValueError("Thickness not found") + + # extract GRAIN TYPE and SIZE + if layer.grain_form_primary: + if layer.grain_form_primary.grain_form: + grain_type = layer.grain_form_primary.grain_form + if layer.grain_form_primary.grain_size_avg: + grain_size = ( + layer.grain_form_primary.grain_size_avg[0] + * convert_to_mm[layer.grain_form_primary.grain_size_avg[1]] + ) + elif layer.grain_form_primary.grain_size_max: + grain_size = ( + layer.grain_form_primary.grain_size_max[0] + * convert_to_mm[layer.grain_form_primary.grain_size_max[1]] + ) + + # extract DENSITY + # Get layer depth range in mm for density matching + layer_depth_top_mm = layer.depth_top[0] * convert_to_mm[layer.depth_top[1]] + layer_depth_bottom_mm = layer_depth_top_mm + thickness + # Try to find density measurement that overlaps with this layer + measured_density = self.get_density_for_layer_range( + layer_depth_top_mm, layer_depth_bottom_mm, sp_density_layers + ) + + # Handle hardness and create layers accordingly + if layer.hardness_top is not None and layer.hardness_bottom is not None: + hand_hardness_top = layer.hardness_top + hand_hardness_bottom = layer.hardness_bottom + + # Two hardness values - split into two layers + half_thickness = thickness / 2 + layer_mid_depth_mm = layer_depth_top_mm + half_thickness + + # Create top layer (first half) + if measured_density is not None: + density_top = self.get_density_for_layer_range( + layer_depth_top_mm, layer_mid_depth_mm, sp_density_layers + ) + if density_top is None: + density_methods.append("geldsetzer") + density_top = compute_density(grain_type, hand_hardness_top) + else: + density_methods.append("density_obs") + else: + density_methods.append("geldsetzer") + density_top = compute_density(grain_type, hand_hardness_top) + + layers.append( + Layer( + rho=density_top, + h=half_thickness, + grain_type=grain_type, + grain_size=grain_size, + hand_hardness=hand_hardness_top, + ) + ) + + # Create bottom layer (second half) + if measured_density is not None: + density_bottom = self.get_density_for_layer_range( + layer_mid_depth_mm, layer_depth_bottom_mm, sp_density_layers + ) + if density_bottom is None: + density_methods.append("geldsetzer") + density_bottom = compute_density( + grain_type, hand_hardness_bottom + ) + else: + density_methods.append("density_obs") + else: + try: + density_methods.append("geldsetzer") + density_bottom = compute_density( + grain_type, hand_hardness_bottom + ) + except Exception as exc: + raise AttributeError( + "Layer is missing density information; density profile, " + "hand hardness and grain type are all missing. " + "Excluding SnowPit from calculations." + ) from exc + + layers.append( + Layer( + rho=density_bottom, + h=half_thickness, + grain_type=grain_type, + grain_size=grain_size, + hand_hardness=hand_hardness_bottom, + ) + ) + else: + # Single hardness value - create one layer + hand_hardness = layer.hardness + + if measured_density is not None: + density = measured_density + density_methods.append("density_obs") + else: + try: + density_methods.append("geldsetzer") + density = compute_density(grain_type, hand_hardness) + except Exception as exc: + raise AttributeError( + "Layer is missing density information; density profile, " + "hand hardness and grain type are all missing. " + "Excluding SnowPit from calculations." + ) from exc + + layers.append( + Layer( + rho=density, + h=thickness, + grain_type=grain_type, + grain_size=grain_size, + hand_hardness=hand_hardness, + ) + ) + + if len(layers) == 0: + raise AttributeError( + "No layers found for snowpit. Excluding SnowPit from calculations." + ) + return layers, density_methods + + def get_density_for_layer_range( + self, + layer_top_mm: float, + layer_bottom_mm: float, + sp_density_layers: List[DensityObs], + ) -> float | None: + """Find density measurements that overlap with the given layer depth range. + + Args: + layer_top_mm: Top depth of layer in mm + layer_bottom_mm: Bottom depth of layer in mm + sp_density_layers: List of density observations + + Returns: + Average density from overlapping measurements, or None if no overlap + """ + if not sp_density_layers: + return None + + overlapping_densities = [] + overlapping_weights = [] + + for density_obs in sp_density_layers: + if density_obs.depth_top is None or density_obs.thickness is None: + continue + + # Convert density observation depth range to mm + density_top_mm = ( + density_obs.depth_top[0] * convert_to_mm[density_obs.depth_top[1]] + ) + density_thickness_mm = ( + density_obs.thickness[0] * convert_to_mm[density_obs.thickness[1]] + ) + density_bottom_mm = density_top_mm + density_thickness_mm + + # Check for overlap between layer and density measurement + overlap_top = max(layer_top_mm, density_top_mm) + overlap_bottom = min(layer_bottom_mm, density_bottom_mm) + + if overlap_top < overlap_bottom: # There is overlap + overlap_thickness = overlap_bottom - overlap_top + + # Extract density value + if density_obs.density is not None: + density_value = density_obs.density[0] # (value, unit) + + overlapping_densities.append(density_value) + overlapping_weights.append(overlap_thickness) + + if overlapping_densities: + # Calculate weighted average based on overlap thickness + total_weight = sum(overlapping_weights) + if total_weight > 0: + weighted_density = ( + sum( + d * w + for d, w in zip(overlapping_densities, overlapping_weights) + ) + / total_weight + ) + return float(weighted_density) + return None + + def extract_weak_layer_and_layers_above( + self, weak_layer_depth: float, layers: List[Layer] + ) -> Tuple[WeakLayer, List[Layer]]: + """Extract weak layer and layers above the weak layer for the given + depth_top extracted from the stability test.""" + depth = 0 + layers_above = [] + weak_layer_rho = None + weak_layer_hand_hardness = None + weak_layer_grain_type = None + weak_layer_grain_size = None + if weak_layer_depth <= 0: + raise ValueError( + "The depth of the weak layer is not positive. " + "Excluding SnowPit from calculations." + ) + if weak_layer_depth > sum(layer.h for layer in layers): + raise ValueError( + "The depth of the weak layer is below the recorded layers. " + "Excluding SnowPit from calculations." + ) + layers = [layer.model_copy(deep=True) for layer in layers] + for i, layer in enumerate(layers): + if depth + layer.h < weak_layer_depth: + layers_above.append(layer) + depth += layer.h + elif depth < weak_layer_depth < depth + layer.h: + layer.h = weak_layer_depth - depth + layers_above.append(layer) + weak_layer_rho = layers[i].rho + weak_layer_hand_hardness = layers[i].hand_hardness + weak_layer_grain_type = layers[i].grain_type + weak_layer_grain_size = layers[i].grain_size + break + elif depth + layer.h == weak_layer_depth: + if i + 1 < len(layers): + layers_above.append(layer) + weak_layer_rho = layers[i + 1].rho + weak_layer_hand_hardness = layers[i + 1].hand_hardness + weak_layer_grain_type = layers[i + 1].grain_type + weak_layer_grain_size = layers[i + 1].grain_size + else: + weak_layer_rho = layers[i].rho + weak_layer_hand_hardness = layers[i].hand_hardness + weak_layer_grain_type = layers[i].grain_type + weak_layer_grain_size = layers[i].grain_size + break + + weak_layer = WeakLayer( + rho=weak_layer_rho, + h=20.0, + hand_hardness=weak_layer_hand_hardness, + grain_type=weak_layer_grain_type, + grain_size=weak_layer_grain_size, + ) + if len(layers_above) == 0: + raise ValueError("No layers above weak layer found") + return weak_layer, layers_above