morphogen 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- morphogen/__init__.py +60 -0
- morphogen/__main__.py +7 -0
- morphogen/_platform.py +55 -0
- morphogen/_public.py +153 -0
- morphogen/_utils.py +80 -0
- morphogen/_version.py +1 -0
- morphogen/analysis/__init__.py +174 -0
- morphogen/analysis/anisotropy.py +135 -0
- morphogen/analysis/basic.py +38 -0
- morphogen/analysis/cells.py +54 -0
- morphogen/analysis/connectivity.py +156 -0
- morphogen/analysis/correlation.py +195 -0
- morphogen/analysis/covariance.py +80 -0
- morphogen/analysis/fractal.py +54 -0
- morphogen/analysis/measures.py +188 -0
- morphogen/analysis/morphology.py +265 -0
- morphogen/analysis/particles.py +160 -0
- morphogen/analysis/percolation.py +2034 -0
- morphogen/analysis/power_laws.py +143 -0
- morphogen/analysis/random_sets.py +351 -0
- morphogen/analysis/stereology.py +289 -0
- morphogen/analysis/surface.py +107 -0
- morphogen/analysis/topology.py +92 -0
- morphogen/automata/__init__.py +74 -0
- morphogen/automata/engine.py +211 -0
- morphogen/automata/growth.py +686 -0
- morphogen/automata/lattice.py +143 -0
- morphogen/automata/reaction.py +255 -0
- morphogen/automata/rules.py +353 -0
- morphogen/automata/tilings.py +1715 -0
- morphogen/cli.py +3526 -0
- morphogen/config.py +2167 -0
- morphogen/contact/__init__.py +113 -0
- morphogen/contact/experiments.py +368 -0
- morphogen/contact/hertz.py +104 -0
- morphogen/contact/kernels.py +827 -0
- morphogen/contact/periodic.py +278 -0
- morphogen/contact/problem.py +578 -0
- morphogen/contact/surfaces.py +310 -0
- morphogen/coupling/__init__.py +43 -0
- morphogen/coupling/ageing.py +143 -0
- morphogen/coupling/diffusion.py +226 -0
- morphogen/coupling/fenicsx.py +484 -0
- morphogen/coupling/oxidation.py +447 -0
- morphogen/coupling/plates.py +247 -0
- morphogen/design/__init__.py +51 -0
- morphogen/design/csp.py +616 -0
- morphogen/design/frames.py +277 -0
- morphogen/design/search.py +287 -0
- morphogen/design/tiles.py +336 -0
- morphogen/distributions.py +312 -0
- morphogen/domain.py +203 -0
- morphogen/dynamics/__init__.py +179 -0
- morphogen/dynamics/model.py +638 -0
- morphogen/dynamics/openradioss.py +643 -0
- morphogen/dynamics/results.py +515 -0
- morphogen/fracture/__init__.py +170 -0
- morphogen/fracture/bulk.py +349 -0
- morphogen/fracture/cohesive.py +1614 -0
- morphogen/fracture/ductile.py +557 -0
- morphogen/fracture/lefm.py +1168 -0
- morphogen/fracture/mixed.py +1178 -0
- morphogen/fracture/periodic.py +733 -0
- morphogen/fracture/phasefield.py +714 -0
- morphogen/fracture/phasefield_finite.py +368 -0
- morphogen/fracture/surface.py +572 -0
- morphogen/fracture/toughness.py +566 -0
- morphogen/gpu.py +108 -0
- morphogen/gui/__init__.py +8 -0
- morphogen/gui/api.py +1927 -0
- morphogen/gui/desktop.py +387 -0
- morphogen/gui/icon.png +0 -0
- morphogen/gui/index.html +1909 -0
- morphogen/gui/server.py +229 -0
- morphogen/gui/tools/__init__.py +629 -0
- morphogen/gui/tools/compare.py +149 -0
- morphogen/gui/tools/contact.py +391 -0
- morphogen/gui/tools/couplings.py +1085 -0
- morphogen/gui/tools/crackfront.py +245 -0
- morphogen/gui/tools/design.py +224 -0
- morphogen/gui/tools/dynamics.py +824 -0
- morphogen/gui/tools/fracture.py +2586 -0
- morphogen/gui/tools/interop.py +1654 -0
- morphogen/gui/tools/learning.py +595 -0
- morphogen/gui/tools/mechanics.py +3881 -0
- morphogen/gui/tools/nonlocal_damage.py +1321 -0
- morphogen/gui/tools/phasefield.py +215 -0
- morphogen/gui/tools/physics.py +597 -0
- morphogen/gui/tools/stability.py +1756 -0
- morphogen/gui/tools/statistics.py +1408 -0
- morphogen/gui/viewer.js +1100 -0
- morphogen/homogenization/__init__.py +210 -0
- morphogen/homogenization/acoustics.py +566 -0
- morphogen/homogenization/amg.py +1005 -0
- morphogen/homogenization/apparent.py +1046 -0
- morphogen/homogenization/behaviours.cu +2285 -0
- morphogen/homogenization/behaviours.py +944 -0
- morphogen/homogenization/beremin.py +263 -0
- morphogen/homogenization/bifurcation.py +1085 -0
- morphogen/homogenization/bloch.py +507 -0
- morphogen/homogenization/bounds.py +226 -0
- morphogen/homogenization/core.py +458 -0
- morphogen/homogenization/coupled.py +1135 -0
- morphogen/homogenization/crystal.py +2967 -0
- morphogen/homogenization/dilatation.py +454 -0
- morphogen/homogenization/elements.py +157 -0
- morphogen/homogenization/fatigue.py +768 -0
- morphogen/homogenization/fe.py +1739 -0
- morphogen/homogenization/fenicsx.py +307 -0
- morphogen/homogenization/fft.py +499 -0
- morphogen/homogenization/fft_nonlinear.py +391 -0
- morphogen/homogenization/finite.py +613 -0
- morphogen/homogenization/flow.py +361 -0
- morphogen/homogenization/frames.py +1125 -0
- morphogen/homogenization/gpu.py +1241 -0
- morphogen/homogenization/harmonic.py +427 -0
- morphogen/homogenization/identification.py +579 -0
- morphogen/homogenization/kernels.py +760 -0
- morphogen/homogenization/laws.py +2061 -0
- morphogen/homogenization/materials.py +1080 -0
- morphogen/homogenization/mfront.py +589 -0
- morphogen/homogenization/networks.py +880 -0
- morphogen/homogenization/nonlinear.py +2612 -0
- morphogen/homogenization/ntfa.py +577 -0
- morphogen/homogenization/paths.py +476 -0
- morphogen/homogenization/photonic.py +467 -0
- morphogen/homogenization/poroelastic.py +212 -0
- morphogen/homogenization/porous.py +1120 -0
- morphogen/homogenization/postprocess.py +290 -0
- morphogen/homogenization/solvers.py +1140 -0
- morphogen/homogenization/tensors.py +240 -0
- morphogen/homogenization/voxel_fe.py +457 -0
- morphogen/homogenization/xfem.py +1016 -0
- morphogen/homogenization/zmat.py +1258 -0
- morphogen/iga/__init__.py +48 -0
- morphogen/iga/analysis.py +508 -0
- morphogen/iga/basis.py +214 -0
- morphogen/iga/geometry.py +501 -0
- morphogen/iga/homogenization.py +219 -0
- morphogen/iga/optimization.py +700 -0
- morphogen/iga/shapes.py +331 -0
- morphogen/image.py +128 -0
- morphogen/io/__init__.py +246 -0
- morphogen/io/amitex.py +741 -0
- morphogen/io/ebsd.py +881 -0
- morphogen/io/export.py +196 -0
- morphogen/io/geometry.py +158 -0
- morphogen/io/medit.py +147 -0
- morphogen/io/meshes.py +844 -0
- morphogen/io/metaimage.py +97 -0
- morphogen/io/mfront.py +1104 -0
- morphogen/io/native.py +57 -0
- morphogen/io/radioss.py +764 -0
- morphogen/io/solvers.py +371 -0
- morphogen/io/tables.py +278 -0
- morphogen/io/tiff.py +66 -0
- morphogen/io/vtk.py +701 -0
- morphogen/io/xdmf.py +200 -0
- morphogen/kernels/__init__.py +5 -0
- morphogen/kernels/annealing.py +192 -0
- morphogen/kernels/cells.py +69 -0
- morphogen/kernels/collective.py +87 -0
- morphogen/kernels/force_biased.py +595 -0
- morphogen/kernels/implicit.py +145 -0
- morphogen/kernels/leaves.py +132 -0
- morphogen/kernels/packing.py +304 -0
- morphogen/kernels/raster.py +279 -0
- morphogen/kernels/rsa.py +371 -0
- morphogen/kernels/union.py +135 -0
- morphogen/kernels/watershed.py +190 -0
- morphogen/laser/__init__.py +234 -0
- morphogen/laser/architectures.py +375 -0
- morphogen/laser/bending.py +216 -0
- morphogen/laser/cells.py +1694 -0
- morphogen/laser/design.py +940 -0
- morphogen/laser/figures.py +227 -0
- morphogen/laser/heat.py +804 -0
- morphogen/laser/materials.py +691 -0
- morphogen/laser/mechanics.py +1670 -0
- morphogen/laser/metallurgy.py +615 -0
- morphogen/laser/patterns.py +828 -0
- morphogen/laser/periodic.py +392 -0
- morphogen/laser/process.py +362 -0
- morphogen/laser/run.py +534 -0
- morphogen/laser/solid.py +216 -0
- morphogen/laser/specimen.py +200 -0
- morphogen/laser/structures.py +708 -0
- morphogen/learning/__init__.py +81 -0
- morphogen/learning/behaviour.py +398 -0
- morphogen/learning/data.py +328 -0
- morphogen/learning/learned.cpp +668 -0
- morphogen/learning/logarithmic.py +202 -0
- morphogen/learning/mfront.py +409 -0
- morphogen/learning/networks.py +767 -0
- morphogen/learning/run.py +212 -0
- morphogen/learning/standard.py +814 -0
- morphogen/learning/training.py +235 -0
- morphogen/mesh/__init__.py +29 -0
- morphogen/mesh/conforming.py +1423 -0
- morphogen/mesh/curved.py +600 -0
- morphogen/mesh/exact.py +1717 -0
- morphogen/mesh/octree.py +350 -0
- morphogen/mesh/polycrystal.py +1041 -0
- morphogen/mesh/polyhedra.py +677 -0
- morphogen/mesh/regularize.py +570 -0
- morphogen/mesh/surface.py +97 -0
- morphogen/mesh/tetra.py +512 -0
- morphogen/mesh/voxel.py +124 -0
- morphogen/micromorphic/__init__.py +31 -0
- morphogen/micromorphic/damage.py +359 -0
- morphogen/micromorphic/ductile.py +534 -0
- morphogen/micromorphic/finite.py +220 -0
- morphogen/micromorphic/microfoam.py +787 -0
- morphogen/micromorphic/space.py +341 -0
- morphogen/models/__init__.py +195 -0
- morphogen/models/affine.py +384 -0
- morphogen/models/automata.py +592 -0
- morphogen/models/base.py +500 -0
- morphogen/models/boolean.py +310 -0
- morphogen/models/bouligand.py +331 -0
- morphogen/models/branching.py +241 -0
- morphogen/models/combination.py +430 -0
- morphogen/models/deadleaves.py +766 -0
- morphogen/models/design.py +289 -0
- morphogen/models/ebsd.py +206 -0
- morphogen/models/fibers.py +1476 -0
- morphogen/models/foam.py +594 -0
- morphogen/models/gaussian.py +314 -0
- morphogen/models/growth.py +459 -0
- morphogen/models/hardcore.py +317 -0
- morphogen/models/hierarchical.py +269 -0
- morphogen/models/honeycomb.py +749 -0
- morphogen/models/implicit.py +177 -0
- morphogen/models/laminate.py +470 -0
- morphogen/models/lattice.py +351 -0
- morphogen/models/lattice_field.py +345 -0
- morphogen/models/levelset_foam.py +563 -0
- morphogen/models/nacre.py +411 -0
- morphogen/models/nested.py +924 -0
- morphogen/models/osteons.py +374 -0
- morphogen/models/pieces.py +167 -0
- morphogen/models/planar.py +126 -0
- morphogen/models/reconstruction.py +203 -0
- morphogen/models/scale_rich.py +1409 -0
- morphogen/models/scale_rich_3d.py +1616 -0
- morphogen/models/tessellation.py +735 -0
- morphogen/models/tiling_field.py +302 -0
- morphogen/models/tpms.py +197 -0
- morphogen/models/transparent.py +406 -0
- morphogen/models/union.py +141 -0
- morphogen/optimization/__init__.py +43 -0
- morphogen/optimization/cell.py +295 -0
- morphogen/optimization/filters.py +115 -0
- morphogen/optimization/mma.py +226 -0
- morphogen/optimization/run.py +219 -0
- morphogen/optimization/topology.py +632 -0
- morphogen/orientations.py +568 -0
- morphogen/parallel.py +599 -0
- morphogen/pipeline.py +978 -0
- morphogen/primitives.py +188 -0
- morphogen/results.py +564 -0
- morphogen/rve/__init__.py +73 -0
- morphogen/rve/report.py +627 -0
- morphogen/rve/scaling.py +363 -0
- morphogen/rve/study.py +1054 -0
- morphogen/rve/windows.py +345 -0
- morphogen/seeding.py +51 -0
- morphogen/settings.py +118 -0
- morphogen/stopping.py +48 -0
- morphogen/symmetry.py +384 -0
- morphogen/templates/activator_inhibitor.yaml +22 -0
- morphogen/templates/aggregation.yaml +23 -0
- morphogen/templates/boolean_cylinders.yaml +20 -0
- morphogen/templates/boolean_spheres.yaml +22 -0
- morphogen/templates/bouligand.yaml +28 -0
- morphogen/templates/cellular_automaton.yaml +25 -0
- morphogen/templates/coated_spheres.yaml +26 -0
- morphogen/templates/contact_fibers.yaml +27 -0
- morphogen/templates/cox_nanocomposite.yaml +22 -0
- morphogen/templates/cross_linked_fibers.yaml +26 -0
- morphogen/templates/curved_arcs.yaml +28 -0
- morphogen/templates/curved_fibers.yaml +24 -0
- morphogen/templates/dead_leaves.yaml +22 -0
- morphogen/templates/delaunay_network.yaml +22 -0
- morphogen/templates/dense_packing.yaml +22 -0
- morphogen/templates/diffusion.yaml +33 -0
- morphogen/templates/ebsd.yaml +34 -0
- morphogen/templates/ebsd_map.ctf +3087 -0
- morphogen/templates/fracture_composite.yaml +42 -0
- morphogen/templates/fracture_rubber.yaml +47 -0
- morphogen/templates/gaussian_excursion.yaml +17 -0
- morphogen/templates/graded_lattice.yaml +24 -0
- morphogen/templates/hardcore_fibers.yaml +22 -0
- morphogen/templates/hardcore_spheres.yaml +22 -0
- morphogen/templates/hierarchical_lattice.yaml +22 -0
- morphogen/templates/homogenization_acoustic_foam.yaml +36 -0
- morphogen/templates/homogenization_beremin.yaml +50 -0
- morphogen/templates/homogenization_cleavage.yaml +51 -0
- morphogen/templates/homogenization_cleavage_band.yaml +55 -0
- morphogen/templates/homogenization_contact.yaml +43 -0
- morphogen/templates/homogenization_crack_closure.yaml +49 -0
- morphogen/templates/homogenization_crystal_plasticity.yaml +50 -0
- morphogen/templates/homogenization_crystal_plasticity_fft.yaml +52 -0
- morphogen/templates/homogenization_crystallization.yaml +30 -0
- morphogen/templates/homogenization_debonding.yaml +43 -0
- morphogen/templates/homogenization_detwinning.yaml +58 -0
- morphogen/templates/homogenization_ductile_damage.yaml +47 -0
- morphogen/templates/homogenization_fatigue.yaml +40 -0
- morphogen/templates/homogenization_grain_fracture.yaml +56 -0
- morphogen/templates/homogenization_gyroid.yaml +30 -0
- morphogen/templates/homogenization_intergranular.yaml +43 -0
- morphogen/templates/homogenization_interphase.yaml +42 -0
- morphogen/templates/homogenization_mixed_loading.yaml +33 -0
- morphogen/templates/homogenization_ntfa.yaml +56 -0
- morphogen/templates/homogenization_piezoelectric.yaml +27 -0
- morphogen/templates/homogenization_polycrystal.yaml +30 -0
- morphogen/templates/homogenization_polycrystal_inclusions.yaml +30 -0
- morphogen/templates/homogenization_poroelastic.yaml +26 -0
- morphogen/templates/homogenization_rubber.yaml +40 -0
- morphogen/templates/homogenization_slip_cleavage.yaml +50 -0
- morphogen/templates/homogenization_spheres.yaml +31 -0
- morphogen/templates/homogenization_transport.yaml +29 -0
- morphogen/templates/homogenization_twinning.yaml +54 -0
- morphogen/templates/homogenization_viscoelastic.yaml +34 -0
- morphogen/templates/homogenization_viscoplastic.yaml +42 -0
- morphogen/templates/homogenization_voronoi.yaml +26 -0
- morphogen/templates/homogenization_xfem.yaml +23 -0
- morphogen/templates/hyperuniform_cells.yaml +24 -0
- morphogen/templates/laguerre.yaml +18 -0
- morphogen/templates/laser_bending.yaml +35 -0
- morphogen/templates/laser_cells.yaml +38 -0
- morphogen/templates/laser_corrugated.yaml +36 -0
- morphogen/templates/level_set_foam.yaml +29 -0
- morphogen/templates/menger_sponge.yaml +17 -0
- morphogen/templates/nacre.yaml +25 -0
- morphogen/templates/nucleation_growth.yaml +25 -0
- morphogen/templates/optimize_auxetic.yaml +29 -0
- morphogen/templates/optimize_auxetic_3d.yaml +27 -0
- morphogen/templates/optimize_bulk.yaml +23 -0
- morphogen/templates/optimize_conductivity.yaml +20 -0
- morphogen/templates/osteons.yaml +28 -0
- morphogen/templates/penetrable_spheres.yaml +21 -0
- morphogen/templates/poisson_fibers.yaml +21 -0
- morphogen/templates/random_laminate.yaml +26 -0
- morphogen/templates/random_lattice.yaml +27 -0
- morphogen/templates/random_walk_fibers.yaml +26 -0
- morphogen/templates/reaction_diffusion.yaml +22 -0
- morphogen/templates/reconstruction.yaml +22 -0
- morphogen/templates/rve_cellular_automaton.yaml +23 -0
- morphogen/templates/rve_crystal_plasticity_fft.yaml +51 -0
- morphogen/templates/rve_multiphysics.yaml +43 -0
- morphogen/templates/rve_poisson_fibers.yaml +22 -0
- morphogen/templates/rve_poisson_fibers_fe.yaml +33 -0
- morphogen/templates/rve_voronoi_windows.yaml +20 -0
- morphogen/templates/scale_rich_network.yaml +29 -0
- morphogen/templates/scale_rich_plates.yaml +30 -0
- morphogen/templates/sequential_dead_leaves.yaml +25 -0
- morphogen/templates/strut_lattice.yaml +21 -0
- morphogen/templates/tile_assembly.yaml +28 -0
- morphogen/templates/tpms.yaml +19 -0
- morphogen/templates/trabecular_bone.yaml +29 -0
- morphogen/templates/transparent_dead_leaves.yaml +23 -0
- morphogen/templates/vascular_tree.yaml +23 -0
- morphogen/templates/voronoi.yaml +20 -0
- morphogen/templates/wood.yaml +34 -0
- morphogen/templates/workflow.yaml +56 -0
- morphogen/texture.py +665 -0
- morphogen/theory.py +162 -0
- morphogen/viz/__init__.py +12 -0
- morphogen/viz/export.py +244 -0
- morphogen/viz/figures.py +707 -0
- morphogen/viz/png.py +148 -0
- morphogen/viz/sections.py +696 -0
- morphogen/viz/surfaces.py +1352 -0
- morphogen/viz/video.py +904 -0
- morphogen/viz/workflow.py +488 -0
- morphogen-1.0.0.dist-info/METADATA +2316 -0
- morphogen-1.0.0.dist-info/RECORD +381 -0
- morphogen-1.0.0.dist-info/WHEEL +4 -0
- morphogen-1.0.0.dist-info/entry_points.txt +5 -0
- morphogen-1.0.0.dist-info/licenses/LICENSE +674 -0
morphogen/results.py
ADDED
|
@@ -0,0 +1,564 @@
|
|
|
1
|
+
"""Database of the configurations tested and of their results, and Ashby charts.
|
|
2
|
+
|
|
3
|
+
A :class:`ResultsDatabase` is one SQLite file (Python's standard library). Every run
|
|
4
|
+
directory added (:meth:`ResultsDatabase.add_run`: the outputs of ``morphogen run``, or of
|
|
5
|
+
a run with ``outputs.database``) contributes one record per realization: its
|
|
6
|
+
configuration flattened into dotted keys (``model.type``, ``model.radius``,
|
|
7
|
+
``domain.size``, ``homogenization.materials.1.young``...) and its row of results
|
|
8
|
+
(measures, apparent properties, solid fraction, relative, normalized and specific values:
|
|
9
|
+
:mod:`morphogen.homogenization.postprocess`). Records are selected by conditions on any
|
|
10
|
+
key (:func:`parse_condition`): ``model.type == gyroid``, ``solid_fraction < 0.3``,
|
|
11
|
+
``model.type in gyroid,octet``, ``run_name ~ lattice*``.
|
|
12
|
+
|
|
13
|
+
Ashby charts (:func:`ashby_chart`) place records in a space of two properties, by default
|
|
14
|
+
normalized: a relative property (``E / E_s``) against the relative density (the solid
|
|
15
|
+
fraction), on logarithmic axes, one family per value of a key (the model by default),
|
|
16
|
+
with the scaling laws of cellular solids ``P / P_s = phi^n`` (Gibson & Ashby 1997:
|
|
17
|
+
``n = 1`` for stretching-dominated architectures, the rule of mixtures; ``n = 2`` for
|
|
18
|
+
bending-dominated open-cell foams).
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
from __future__ import annotations
|
|
22
|
+
|
|
23
|
+
import csv
|
|
24
|
+
import fnmatch
|
|
25
|
+
import json
|
|
26
|
+
import math
|
|
27
|
+
import sqlite3
|
|
28
|
+
import time
|
|
29
|
+
from pathlib import Path
|
|
30
|
+
|
|
31
|
+
import numpy as np
|
|
32
|
+
|
|
33
|
+
#: Runs and their realizations; a record is the JSON of the flattened configuration
|
|
34
|
+
#: merged with the row of results of one realization.
|
|
35
|
+
SCHEMA = """
|
|
36
|
+
CREATE TABLE IF NOT EXISTS runs (
|
|
37
|
+
id INTEGER PRIMARY KEY,
|
|
38
|
+
path TEXT UNIQUE,
|
|
39
|
+
name TEXT,
|
|
40
|
+
added TEXT,
|
|
41
|
+
config TEXT,
|
|
42
|
+
version TEXT
|
|
43
|
+
);
|
|
44
|
+
CREATE TABLE IF NOT EXISTS samples (
|
|
45
|
+
run INTEGER REFERENCES runs(id) ON DELETE CASCADE,
|
|
46
|
+
realization INTEGER,
|
|
47
|
+
data TEXT,
|
|
48
|
+
PRIMARY KEY (run, realization)
|
|
49
|
+
);
|
|
50
|
+
"""
|
|
51
|
+
|
|
52
|
+
#: Parts of a configuration that do not describe the microstructure or its computation.
|
|
53
|
+
_SKIPPED = ("outputs", "rve")
|
|
54
|
+
|
|
55
|
+
OPERATORS = ("==", "!=", "<=", ">=", "<", ">", " not in ", " in ", "~")
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def flatten(data: dict, prefix: str = "") -> dict:
|
|
59
|
+
"""Nested mappings as one level of dotted keys; lists become JSON text."""
|
|
60
|
+
out: dict = {}
|
|
61
|
+
for key, value in data.items():
|
|
62
|
+
name = f"{prefix}{key}"
|
|
63
|
+
if isinstance(value, dict):
|
|
64
|
+
out.update(flatten(value, name + "."))
|
|
65
|
+
elif isinstance(value, (list, tuple)):
|
|
66
|
+
out[name] = json.dumps(value)
|
|
67
|
+
else:
|
|
68
|
+
out[name] = value
|
|
69
|
+
return out
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
def _value(text: str):
|
|
73
|
+
"""A condition's value: a number, a boolean, or a string."""
|
|
74
|
+
t = text.strip().strip("'\"")
|
|
75
|
+
low = t.lower()
|
|
76
|
+
if low in ("true", "false"):
|
|
77
|
+
return low == "true"
|
|
78
|
+
try:
|
|
79
|
+
return float(t)
|
|
80
|
+
except ValueError:
|
|
81
|
+
return t
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
def parse_condition(text: str) -> tuple[str, str, object]:
|
|
85
|
+
"""``"key OP value"`` with OP one of ``== != < <= > >= in, not in`` (comma-separated
|
|
86
|
+
values) or ``~`` (shell pattern, e.g. ``lattice*``)."""
|
|
87
|
+
for op in OPERATORS:
|
|
88
|
+
key, sep, value = text.partition(op)
|
|
89
|
+
if sep and key.strip():
|
|
90
|
+
if op.strip() in ("in", "not in"):
|
|
91
|
+
return key.strip(), op.strip(), [_value(v) for v in value.split(",")]
|
|
92
|
+
return key.strip(), op, _value(value)
|
|
93
|
+
raise ValueError(f"condition {text!r}: expected 'key OP value' with OP in == != < <= > >= in ~")
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
def _equal(a, b) -> bool:
|
|
97
|
+
if isinstance(a, bool) or isinstance(b, bool):
|
|
98
|
+
return bool(a) == bool(b) and isinstance(a, bool) == isinstance(b, bool)
|
|
99
|
+
if isinstance(a, (int, float)) and isinstance(b, (int, float)):
|
|
100
|
+
return float(a) == float(b)
|
|
101
|
+
return str(a) == str(b)
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
def matches(record: dict, conditions) -> bool:
|
|
105
|
+
"""Whether a record satisfies every condition (strings or parsed tuples); a missing
|
|
106
|
+
key fails every condition but ``!=`` and ``not in``."""
|
|
107
|
+
for cond in conditions:
|
|
108
|
+
key, op, value = parse_condition(cond) if isinstance(cond, str) else cond
|
|
109
|
+
if key not in record:
|
|
110
|
+
if op in ("!=", "not in"):
|
|
111
|
+
continue
|
|
112
|
+
return False
|
|
113
|
+
v = record[key]
|
|
114
|
+
if op == "==":
|
|
115
|
+
ok = _equal(v, value)
|
|
116
|
+
elif op == "!=":
|
|
117
|
+
ok = not _equal(v, value)
|
|
118
|
+
elif op == "in":
|
|
119
|
+
ok = any(_equal(v, w) for w in value)
|
|
120
|
+
elif op == "not in":
|
|
121
|
+
ok = not any(_equal(v, w) for w in value)
|
|
122
|
+
elif op == "~":
|
|
123
|
+
ok = fnmatch.fnmatchcase(str(v), str(value))
|
|
124
|
+
else:
|
|
125
|
+
try:
|
|
126
|
+
a, b = float(v), float(value)
|
|
127
|
+
except (TypeError, ValueError):
|
|
128
|
+
return False
|
|
129
|
+
ok = {"<": a < b, "<=": a <= b, ">": a > b, ">=": a >= b}[op]
|
|
130
|
+
if not ok:
|
|
131
|
+
return False
|
|
132
|
+
return True
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
class ResultsDatabase:
|
|
136
|
+
"""SQLite database of runs and of the results of their realizations."""
|
|
137
|
+
|
|
138
|
+
def __init__(self, path):
|
|
139
|
+
self.path = Path(path)
|
|
140
|
+
self.connection = sqlite3.connect(str(self.path))
|
|
141
|
+
self.connection.execute("PRAGMA foreign_keys = ON")
|
|
142
|
+
self.connection.executescript(SCHEMA)
|
|
143
|
+
|
|
144
|
+
def __enter__(self) -> ResultsDatabase:
|
|
145
|
+
return self
|
|
146
|
+
|
|
147
|
+
def __exit__(self, *exc) -> None:
|
|
148
|
+
self.close()
|
|
149
|
+
|
|
150
|
+
def close(self) -> None:
|
|
151
|
+
self.connection.close()
|
|
152
|
+
|
|
153
|
+
def add_run(self, directory, *, name: str | None = None) -> int:
|
|
154
|
+
"""Add (or replace) the realizations of a run directory: its configuration
|
|
155
|
+
(``run.json``) and results (``results.csv``, or the files of split runs). Returns
|
|
156
|
+
the number of records."""
|
|
157
|
+
from morphogen import pipeline
|
|
158
|
+
|
|
159
|
+
directory = Path(directory).resolve()
|
|
160
|
+
manifests = [directory / "run.json", *sorted(directory.glob("run_task*of*.json"))]
|
|
161
|
+
manifest = next((m for m in manifests if m.exists()), None)
|
|
162
|
+
if manifest is None:
|
|
163
|
+
raise ValueError(f"{directory}: not the output directory of a run (no run.json)")
|
|
164
|
+
info = json.loads(manifest.read_text(encoding="utf-8"))
|
|
165
|
+
config = info.get("config", {})
|
|
166
|
+
rows = pipeline.collect_results(directory)
|
|
167
|
+
name = name or config.get("outputs", {}).get("name") or directory.name
|
|
168
|
+
version = info.get("versions", {}).get("morphogen", "")
|
|
169
|
+
return self.add_records(
|
|
170
|
+
rows, name=name, config=config, path=str(directory), version=version
|
|
171
|
+
)
|
|
172
|
+
|
|
173
|
+
def add_records(
|
|
174
|
+
self,
|
|
175
|
+
rows: list[dict],
|
|
176
|
+
*,
|
|
177
|
+
name: str,
|
|
178
|
+
config: dict | None = None,
|
|
179
|
+
path: str | None = None,
|
|
180
|
+
version: str = "",
|
|
181
|
+
) -> int:
|
|
182
|
+
"""Add the rows of a run (one per realization) with its configuration; a run of
|
|
183
|
+
the same ``path`` (default: the name) is replaced."""
|
|
184
|
+
config = config or {}
|
|
185
|
+
base = flatten({k: v for k, v in config.items() if k not in _SKIPPED})
|
|
186
|
+
key = path or f"name:{name}"
|
|
187
|
+
with self.connection:
|
|
188
|
+
self.connection.execute("DELETE FROM runs WHERE path = ?", (key,))
|
|
189
|
+
cur = self.connection.execute(
|
|
190
|
+
"INSERT INTO runs (path, name, added, config, version) VALUES (?, ?, ?, ?, ?)",
|
|
191
|
+
(key, name, time.strftime("%Y-%m-%d %H:%M:%S"), json.dumps(config), version),
|
|
192
|
+
)
|
|
193
|
+
run = cur.lastrowid
|
|
194
|
+
data = []
|
|
195
|
+
for i, row in enumerate(rows):
|
|
196
|
+
record = {"run": run, "run_name": name, **base, **row}
|
|
197
|
+
realization = int(row.get("realization", i))
|
|
198
|
+
data.append((run, realization, json.dumps(record)))
|
|
199
|
+
self.connection.executemany(
|
|
200
|
+
"INSERT OR REPLACE INTO samples (run, realization, data) VALUES (?, ?, ?)", data
|
|
201
|
+
)
|
|
202
|
+
return len(rows)
|
|
203
|
+
|
|
204
|
+
def remove(self, run) -> int:
|
|
205
|
+
"""Remove a run (its id, path or name); returns the number of runs removed."""
|
|
206
|
+
with self.connection:
|
|
207
|
+
if isinstance(run, int) or str(run).isdigit():
|
|
208
|
+
cur = self.connection.execute("DELETE FROM runs WHERE id = ?", (int(run),))
|
|
209
|
+
else:
|
|
210
|
+
text = str(run)
|
|
211
|
+
resolved = str(Path(text).resolve())
|
|
212
|
+
cur = self.connection.execute(
|
|
213
|
+
"DELETE FROM runs WHERE path IN (?, ?) OR name = ?", (text, resolved, text)
|
|
214
|
+
)
|
|
215
|
+
return cur.rowcount
|
|
216
|
+
|
|
217
|
+
def runs(self) -> list[dict]:
|
|
218
|
+
"""Runs: id, name, path, date added, version and number of records."""
|
|
219
|
+
rows = self.connection.execute(
|
|
220
|
+
"SELECT r.id, r.name, r.path, r.added, r.version, COUNT(s.run) FROM runs r "
|
|
221
|
+
"LEFT JOIN samples s ON s.run = r.id GROUP BY r.id ORDER BY r.id"
|
|
222
|
+
).fetchall()
|
|
223
|
+
keys = ("id", "name", "path", "added", "version", "records")
|
|
224
|
+
return [dict(zip(keys, r, strict=True)) for r in rows]
|
|
225
|
+
|
|
226
|
+
def records(self, where=()) -> list[dict]:
|
|
227
|
+
"""Records satisfying every condition of ``where`` (see :func:`matches`)."""
|
|
228
|
+
conditions = [parse_condition(c) if isinstance(c, str) else c for c in where]
|
|
229
|
+
out = []
|
|
230
|
+
for (data,) in self.connection.execute(
|
|
231
|
+
"SELECT data FROM samples ORDER BY run, realization"
|
|
232
|
+
):
|
|
233
|
+
record = json.loads(data)
|
|
234
|
+
if matches(record, conditions):
|
|
235
|
+
out.append(record)
|
|
236
|
+
return out
|
|
237
|
+
|
|
238
|
+
def keys(self, where=()) -> dict[str, dict]:
|
|
239
|
+
"""Keys of the records: how many records hold each, and whether its values are all
|
|
240
|
+
numbers."""
|
|
241
|
+
out: dict[str, dict] = {}
|
|
242
|
+
for record in self.records(where):
|
|
243
|
+
for k, v in record.items():
|
|
244
|
+
entry = out.setdefault(k, {"count": 0, "numeric": True})
|
|
245
|
+
entry["count"] += 1
|
|
246
|
+
if isinstance(v, bool) or not isinstance(v, (int, float)):
|
|
247
|
+
entry["numeric"] = False
|
|
248
|
+
return dict(sorted(out.items()))
|
|
249
|
+
|
|
250
|
+
|
|
251
|
+
def record_run(directory, database, *, name: str | None = None) -> int:
|
|
252
|
+
"""Add a run directory to a database file (created if needed)."""
|
|
253
|
+
with ResultsDatabase(database) as db:
|
|
254
|
+
return db.add_run(directory, name=name)
|
|
255
|
+
|
|
256
|
+
|
|
257
|
+
def write_records(records: list[dict], path, keys=None) -> Path:
|
|
258
|
+
"""CSV of records (all their keys, or ``keys``): the table view of a chart."""
|
|
259
|
+
if keys is None:
|
|
260
|
+
keys = []
|
|
261
|
+
for r in records:
|
|
262
|
+
keys.extend(k for k in r if k not in keys)
|
|
263
|
+
path = Path(path)
|
|
264
|
+
with open(path, "w", encoding="utf-8", newline="") as f:
|
|
265
|
+
writer = csv.DictWriter(f, fieldnames=list(keys), lineterminator="\n")
|
|
266
|
+
writer.writeheader()
|
|
267
|
+
for r in records:
|
|
268
|
+
writer.writerow({k: r.get(k, "") for k in keys})
|
|
269
|
+
return path
|
|
270
|
+
|
|
271
|
+
|
|
272
|
+
# -- Ashby charts ----------------------------------------------------------------------------
|
|
273
|
+
|
|
274
|
+
#: Categorical slots of scatter charts (any two families can be neighbours: three hues pass
|
|
275
|
+
#: the colour-vision checks together; more families fold into "Other"), light and dark.
|
|
276
|
+
SERIES = {"light": ("#2a78d6", "#eb6834", "#1baf7a"), "dark": ("#3987e5", "#d95926", "#199e70")}
|
|
277
|
+
MARKERS = ("o", "s", "^")
|
|
278
|
+
THEMES = {
|
|
279
|
+
"light": {
|
|
280
|
+
"surface": "#fcfcfb",
|
|
281
|
+
"ink": "#0b0b0b",
|
|
282
|
+
"secondary": "#52514e",
|
|
283
|
+
"muted": "#898781",
|
|
284
|
+
"grid": "#e1e0d9",
|
|
285
|
+
"axis": "#c3c2b7",
|
|
286
|
+
},
|
|
287
|
+
"dark": {
|
|
288
|
+
"surface": "#1a1a19",
|
|
289
|
+
"ink": "#f0efec",
|
|
290
|
+
"secondary": "#c3c2b7",
|
|
291
|
+
"muted": "#898781",
|
|
292
|
+
"grid": "#2c2c2a",
|
|
293
|
+
"axis": "#383835",
|
|
294
|
+
},
|
|
295
|
+
}
|
|
296
|
+
OTHER = "Other"
|
|
297
|
+
|
|
298
|
+
|
|
299
|
+
def default_axes(records: list[dict]) -> tuple[str, str]:
|
|
300
|
+
"""The relative density and the first relative property found (Young's modulus first,
|
|
301
|
+
then the bulk and shear moduli, then any)."""
|
|
302
|
+
keys = {k for r in records for k in r}
|
|
303
|
+
relative = sorted(k for k in keys if k.endswith(".relative"))
|
|
304
|
+
for prop in ("E1", "bulk_modulus", "shear_modulus", "conductivity"):
|
|
305
|
+
hits = [k for k in relative if prop in k.split(".")]
|
|
306
|
+
if hits:
|
|
307
|
+
return "solid_fraction", hits[0]
|
|
308
|
+
if relative:
|
|
309
|
+
return "solid_fraction", relative[0]
|
|
310
|
+
raise ValueError("no relative property in the records: give the keys of the axes")
|
|
311
|
+
|
|
312
|
+
|
|
313
|
+
def ashby_points(
|
|
314
|
+
records: list[dict],
|
|
315
|
+
x: str | None = None,
|
|
316
|
+
y: str | None = None,
|
|
317
|
+
by: str | None = "model.type",
|
|
318
|
+
*,
|
|
319
|
+
log: bool = True,
|
|
320
|
+
groups: list | None = None,
|
|
321
|
+
max_groups: int = 3,
|
|
322
|
+
) -> dict:
|
|
323
|
+
"""Points of an Ashby chart: the families (values of ``by``) with their points, the
|
|
324
|
+
first ``max_groups`` in their own colour (by size, or the order of ``groups``), the
|
|
325
|
+
others folded into "Other". Records without finite values (positive ones on
|
|
326
|
+
logarithmic axes) are left out."""
|
|
327
|
+
if x is None or y is None:
|
|
328
|
+
dx, dy = default_axes(records)
|
|
329
|
+
x, y = x or dx, y or dy
|
|
330
|
+
families: dict[str, list] = {}
|
|
331
|
+
for r in records:
|
|
332
|
+
try:
|
|
333
|
+
vx, vy = float(r[x]), float(r[y])
|
|
334
|
+
except (KeyError, TypeError, ValueError):
|
|
335
|
+
continue
|
|
336
|
+
if not (math.isfinite(vx) and math.isfinite(vy)) or (log and (vx <= 0 or vy <= 0)):
|
|
337
|
+
continue
|
|
338
|
+
name = str(r.get(by, "")) if by else ""
|
|
339
|
+
families.setdefault(name, []).append(
|
|
340
|
+
{"x": vx, "y": vy, "run": r.get("run_name", ""), "realization": r.get("realization")}
|
|
341
|
+
)
|
|
342
|
+
order = [str(g) for g in groups if str(g) in families] if groups else []
|
|
343
|
+
order += sorted((g for g in families if g not in order), key=lambda g: -len(families[g]))
|
|
344
|
+
shown, folded = order[:max_groups], order[max_groups:]
|
|
345
|
+
out = [{"name": g, "slot": i, "points": families[g]} for i, g in enumerate(shown)]
|
|
346
|
+
if folded:
|
|
347
|
+
pts = [p for g in folded for p in families[g]]
|
|
348
|
+
out.append({"name": OTHER, "slot": None, "points": pts, "members": folded})
|
|
349
|
+
return {"x": x, "y": y, "by": by, "log": log, "groups": out}
|
|
350
|
+
|
|
351
|
+
|
|
352
|
+
#: Names and symbols of the properties in the keys of the records.
|
|
353
|
+
_NAMES = {
|
|
354
|
+
"bulk_modulus": ("bulk modulus", "K"),
|
|
355
|
+
"shear_modulus": ("shear modulus", "G"),
|
|
356
|
+
"conductivity": ("conductivity", "k"),
|
|
357
|
+
"mean": ("conductivity", "k"),
|
|
358
|
+
"E1": ("Young's modulus E1", "E"),
|
|
359
|
+
"E2": ("Young's modulus E2", "E"),
|
|
360
|
+
"E3": ("Young's modulus E3", "E"),
|
|
361
|
+
"G12": ("shear modulus G12", "G"),
|
|
362
|
+
"G23": ("shear modulus G23", "G"),
|
|
363
|
+
"G31": ("shear modulus G31", "G"),
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
|
|
367
|
+
def axis_label(key: str) -> str:
|
|
368
|
+
"""Readable name of a key: the relative density, a relative property..."""
|
|
369
|
+
if key == "solid_fraction":
|
|
370
|
+
return "Relative density ρ / ρs (solid fraction)"
|
|
371
|
+
if key == "density":
|
|
372
|
+
return "Density ρ"
|
|
373
|
+
parts = key.split(".")
|
|
374
|
+
kind = parts[-1] if parts[-1] in ("relative", "normalized", "specific") else None
|
|
375
|
+
core = parts[:-1] if kind else parts
|
|
376
|
+
bcs = ("kubc", "periodic", "subc", "mixed")
|
|
377
|
+
bc = next((p for p in core if p in bcs), None)
|
|
378
|
+
core = [p for p in core if p not in bcs] or [key]
|
|
379
|
+
name, symbol = _NAMES.get(core[-1], (core[-1].replace("_", " "), "P"))
|
|
380
|
+
entry, notes = core[-1], [bc] if bc else []
|
|
381
|
+
if core[0] == "stiffness" and len(entry) == 3 and entry[0] in "CS" and entry[1:].isdigit():
|
|
382
|
+
# an entry of the stiffness or of its compliance, in morphoGen's Voigt notation
|
|
383
|
+
name = f"{'stiffness' if entry[0] == 'C' else 'compliance'} {entry}"
|
|
384
|
+
symbol, notes = entry, [*notes, "Voigt 11 22 33 23 31 12, engineering shears"]
|
|
385
|
+
suffix = f", {bc}" if bc else ""
|
|
386
|
+
if kind == "relative":
|
|
387
|
+
return f"Relative {name} ({symbol} / {symbol}s{suffix})"
|
|
388
|
+
if kind == "normalized":
|
|
389
|
+
return f"Normalized {name} ({symbol} / (ρ/ρs {symbol}s){suffix})"
|
|
390
|
+
if kind == "specific":
|
|
391
|
+
return f"Specific {name} ({symbol} / ρ{suffix})"
|
|
392
|
+
return f"{name[:1].upper()}{name[1:]}" + (f" ({'; '.join(notes)})" if notes else "")
|
|
393
|
+
|
|
394
|
+
|
|
395
|
+
def _hull(points: np.ndarray) -> np.ndarray | None:
|
|
396
|
+
"""Convex hull (in order) of 2D points, or None for fewer than three points or a
|
|
397
|
+
degenerate set."""
|
|
398
|
+
if len(points) < 3:
|
|
399
|
+
return None
|
|
400
|
+
from scipy.spatial import ConvexHull, QhullError
|
|
401
|
+
|
|
402
|
+
try:
|
|
403
|
+
return points[ConvexHull(points).vertices]
|
|
404
|
+
except QhullError:
|
|
405
|
+
return None
|
|
406
|
+
|
|
407
|
+
|
|
408
|
+
def ashby_chart(
|
|
409
|
+
records: list[dict],
|
|
410
|
+
path,
|
|
411
|
+
x: str | None = None,
|
|
412
|
+
y: str | None = None,
|
|
413
|
+
by: str | None = "model.type",
|
|
414
|
+
*,
|
|
415
|
+
log: bool = True,
|
|
416
|
+
guides=None,
|
|
417
|
+
groups: list | None = None,
|
|
418
|
+
theme: str = "light",
|
|
419
|
+
title: str | None = None,
|
|
420
|
+
) -> Path:
|
|
421
|
+
"""Ashby chart of records as a PNG, SVG or PDF file (needs matplotlib): one family per
|
|
422
|
+
value of ``by`` (three in colour, with their markers, envelopes and direct labels;
|
|
423
|
+
others in "Other"), on logarithmic axes by default, with the lines ``y = x^n`` for
|
|
424
|
+
``guides`` (default: n = 1 and 2 when the axes are relative)."""
|
|
425
|
+
try:
|
|
426
|
+
import matplotlib
|
|
427
|
+
|
|
428
|
+
matplotlib.use("Agg")
|
|
429
|
+
import matplotlib.pyplot as plt
|
|
430
|
+
except ImportError: # pragma: no cover - optional dependency
|
|
431
|
+
raise ImportError("Ashby charts need matplotlib: pip install 'morphogen[plot]'") from None
|
|
432
|
+
if theme not in THEMES:
|
|
433
|
+
raise ValueError(f"theme: one of {list(THEMES)}")
|
|
434
|
+
data = ashby_points(records, x, y, by, log=log, groups=groups)
|
|
435
|
+
if not any(g["points"] for g in data["groups"]):
|
|
436
|
+
raise ValueError(f"no record has values of {data['x']!r} and {data['y']!r}")
|
|
437
|
+
colours, ink = SERIES[theme], THEMES[theme]
|
|
438
|
+
relative = data["x"] == "solid_fraction" and data["y"].endswith(".relative")
|
|
439
|
+
if guides is None:
|
|
440
|
+
guides = (1, 2) if relative and log else ()
|
|
441
|
+
fig, ax = plt.subplots(figsize=(6.4, 4.8), dpi=150)
|
|
442
|
+
fig.patch.set_facecolor(ink["surface"])
|
|
443
|
+
ax.set_facecolor(ink["surface"])
|
|
444
|
+
for side in ("top", "right"):
|
|
445
|
+
ax.spines[side].set_visible(False)
|
|
446
|
+
for side in ("left", "bottom"):
|
|
447
|
+
ax.spines[side].set_color(ink["axis"])
|
|
448
|
+
ax.spines[side].set_linewidth(0.8)
|
|
449
|
+
ax.tick_params(colors=ink["axis"], labelcolor=ink["secondary"], labelsize=8, width=0.8)
|
|
450
|
+
ax.grid(True, which="major", color=ink["grid"], linewidth=0.6)
|
|
451
|
+
ax.set_axisbelow(True)
|
|
452
|
+
if log:
|
|
453
|
+
ax.set_xscale("log")
|
|
454
|
+
ax.set_yscale("log")
|
|
455
|
+
count = sum(len(g["points"]) for g in data["groups"])
|
|
456
|
+
placed: list = [] # boxes of the labels drawn, in display coordinates
|
|
457
|
+
for g in data["groups"]:
|
|
458
|
+
pts = np.array([[p["x"], p["y"]] for p in g["points"]])
|
|
459
|
+
colour = ink["muted"] if g["slot"] is None else colours[g["slot"]]
|
|
460
|
+
marker = "o" if g["slot"] is None else MARKERS[g["slot"]]
|
|
461
|
+
hull = None if g["slot"] is None else _hull(np.log10(pts) if log else pts)
|
|
462
|
+
if hull is not None: # the envelope of a family (not of the others folded)
|
|
463
|
+
ax.fill(*(10.0**hull.T if log else hull.T), color=colour, alpha=0.1, linewidth=0)
|
|
464
|
+
if g["slot"] is not None:
|
|
465
|
+
label = g["name"]
|
|
466
|
+
elif len(g["members"]) == 1:
|
|
467
|
+
label = f"{OTHER}: {g['members'][0]}"
|
|
468
|
+
else:
|
|
469
|
+
label = f"{OTHER} ({len(g['members'])} families)"
|
|
470
|
+
ax.scatter(
|
|
471
|
+
pts[:, 0],
|
|
472
|
+
pts[:, 1],
|
|
473
|
+
s=40,
|
|
474
|
+
marker=marker,
|
|
475
|
+
color=colour,
|
|
476
|
+
edgecolors=ink["surface"],
|
|
477
|
+
linewidths=1.2,
|
|
478
|
+
zorder=3,
|
|
479
|
+
label=label or "all",
|
|
480
|
+
)
|
|
481
|
+
lo, hi = ax.get_xlim(), ax.get_ylim()
|
|
482
|
+
guide_marks = []
|
|
483
|
+
for n in guides:
|
|
484
|
+
xs = np.geomspace(max(lo[0], 1e-12), lo[1], 64) if log else np.linspace(*lo, 64)
|
|
485
|
+
ys = xs ** float(n)
|
|
486
|
+
keep = (ys >= hi[0]) & (ys <= hi[1])
|
|
487
|
+
if keep.sum() < 2:
|
|
488
|
+
continue
|
|
489
|
+
ax.plot(xs[keep], ys[keep], color=ink["muted"], linewidth=0.8, zorder=1)
|
|
490
|
+
guide_marks.append((f"n = {n:g}", np.column_stack([xs[keep], ys[keep]])))
|
|
491
|
+
ax.set_xlim(lo)
|
|
492
|
+
ax.set_ylim(hi)
|
|
493
|
+
fig.canvas.draw()
|
|
494
|
+
renderer = fig.canvas.get_renderer()
|
|
495
|
+
from matplotlib.transforms import Bbox
|
|
496
|
+
|
|
497
|
+
half = 4.0 * fig.dpi / 72.0 # the markers (s = 40 points^2), that labels must not hide
|
|
498
|
+
for g in data["groups"]:
|
|
499
|
+
for p in g["points"]:
|
|
500
|
+
cx, cy = ax.transData.transform((p["x"], p["y"]))
|
|
501
|
+
placed.append(Bbox.from_extents(cx - half, cy - half, cx + half, cy + half))
|
|
502
|
+
|
|
503
|
+
def place(text, anchors, offsets, **kw) -> None:
|
|
504
|
+
"""Draw a label at the first anchor and offset where it overlaps no other label
|
|
505
|
+
and no marker (``anchors``: one point or a list of them)."""
|
|
506
|
+
points = [anchors] if np.ndim(anchors) == 1 else list(anchors)
|
|
507
|
+
frame = ax.get_window_extent(renderer)
|
|
508
|
+
for xy in points:
|
|
509
|
+
for dx, dy, ha in offsets:
|
|
510
|
+
t = ax.annotate(text, xy, xytext=(dx, dy), textcoords="offset points", ha=ha, **kw)
|
|
511
|
+
box = t.get_window_extent(renderer).expanded(1.05, 1.15)
|
|
512
|
+
inside = frame.contains(box.x0, box.y0) and frame.contains(box.x1, box.y1)
|
|
513
|
+
if inside and not any(box.overlaps(b) for b in placed):
|
|
514
|
+
placed.append(box)
|
|
515
|
+
return
|
|
516
|
+
t.remove()
|
|
517
|
+
|
|
518
|
+
if len(data["groups"]) > 1: # beside the plot: it hides no point
|
|
519
|
+
legend = ax.legend(
|
|
520
|
+
frameon=False,
|
|
521
|
+
fontsize=8,
|
|
522
|
+
loc="upper left",
|
|
523
|
+
bbox_to_anchor=(1.02, 1.0),
|
|
524
|
+
title=by,
|
|
525
|
+
scatterpoints=1,
|
|
526
|
+
)
|
|
527
|
+
plt.setp(legend.get_texts(), color=ink["secondary"])
|
|
528
|
+
legend.get_title().set_color(ink["secondary"])
|
|
529
|
+
legend.get_title().set_fontsize(8)
|
|
530
|
+
for text, line in guide_marks: # the scaling laws, from their left end along them,
|
|
531
|
+
# under or over the rising line rather than across it
|
|
532
|
+
anchors = [line[int(f * (len(line) - 1))] for f in (0.0, 0.2, 0.4, 0.6)]
|
|
533
|
+
offsets = [(6, -12, "left"), (-6, 4, "right")]
|
|
534
|
+
place(text, anchors, offsets, fontsize=7, color=ink["muted"])
|
|
535
|
+
if len(data["groups"]) > 1: # direct labels of the families, where they fit
|
|
536
|
+
for g in data["groups"]:
|
|
537
|
+
if g["slot"] is None:
|
|
538
|
+
continue
|
|
539
|
+
pts = np.array([[p["x"], p["y"]] for p in g["points"]])
|
|
540
|
+
k = int(np.argmin(pts[:, 0]))
|
|
541
|
+
place(
|
|
542
|
+
g["name"],
|
|
543
|
+
pts[k],
|
|
544
|
+
[(-7, -3, "right"), (0, -13, "center"), (0, 7, "center"), (7, -3, "left")],
|
|
545
|
+
fontsize=8,
|
|
546
|
+
color=ink["secondary"],
|
|
547
|
+
)
|
|
548
|
+
if log:
|
|
549
|
+
from matplotlib.ticker import FuncFormatter, LogLocator
|
|
550
|
+
|
|
551
|
+
plain = FuncFormatter(lambda v, _: f"{v:g}")
|
|
552
|
+
for axis, (a, b) in ((ax.xaxis, lo), (ax.yaxis, hi)):
|
|
553
|
+
if np.log10(b / a) < 2.0: # less than two decades: ticks at 1, 2, 5
|
|
554
|
+
axis.set_major_locator(LogLocator(subs=(1.0, 2.0, 5.0)))
|
|
555
|
+
axis.set_major_formatter(plain)
|
|
556
|
+
axis.set_minor_formatter(FuncFormatter(lambda v, _: ""))
|
|
557
|
+
ax.set_xlabel(axis_label(data["x"]), color=ink["secondary"], fontsize=9)
|
|
558
|
+
ax.set_ylabel(axis_label(data["y"]), color=ink["secondary"], fontsize=9)
|
|
559
|
+
head = title or f"{axis_label(data['y'])} — {count} realization{'s' * (count != 1)}"
|
|
560
|
+
ax.set_title(head, color=ink["ink"], fontsize=10, loc="left")
|
|
561
|
+
path = Path(path)
|
|
562
|
+
fig.savefig(path, facecolor=ink["surface"], bbox_inches="tight")
|
|
563
|
+
plt.close(fig)
|
|
564
|
+
return path
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
"""Statistical size of the representative volume element (RVE).
|
|
2
|
+
|
|
3
|
+
* :mod:`morphogen.rve.scaling`: point variance, ensemble statistics, scaling law
|
|
4
|
+
``D_Z^2(V) = K V^-gamma``, RVE volume and number of realizations, window method.
|
|
5
|
+
* :mod:`morphogen.rve.study`: analysis of several properties and boundary conditions
|
|
6
|
+
following Dirrenberger et al. (2014): intervals, relative errors, fitted and imposed
|
|
7
|
+
exponents, RVE sizes with bootstrap intervals, isotropy, discrepancy between
|
|
8
|
+
boundary conditions; the mean stiffness and compliance per volume of each boundary
|
|
9
|
+
condition (:class:`TensorStatistics`: ``Cbar``, ``S = Cbar^-1``, the standard deviation
|
|
10
|
+
of each component, their RVE sizes).
|
|
11
|
+
* :mod:`morphogen.rve.windows`: the window method for tensors, the stiffness and the
|
|
12
|
+
conductivity of the windows of one periodic realization solved once per unit load by the
|
|
13
|
+
FFT solver (:class:`WindowTensors`: their mean mutual energies), and their statistics.
|
|
14
|
+
* :mod:`morphogen.rve.report`: Markdown, LaTeX and JSON reports, figures, the table of the
|
|
15
|
+
mean tensors per volume (``rve_stiffness.csv``).
|
|
16
|
+
"""
|
|
17
|
+
|
|
18
|
+
from morphogen.rve.scaling import (
|
|
19
|
+
ScalingLaw,
|
|
20
|
+
SizeStatistics,
|
|
21
|
+
ensemble_statistics,
|
|
22
|
+
fit_scaling_law,
|
|
23
|
+
fit_statistics,
|
|
24
|
+
point_variance,
|
|
25
|
+
point_variance_multiphase,
|
|
26
|
+
rve_table,
|
|
27
|
+
rve_volume_classic,
|
|
28
|
+
window_statistics,
|
|
29
|
+
)
|
|
30
|
+
from morphogen.rve.study import (
|
|
31
|
+
Series,
|
|
32
|
+
SeriesAnalysis,
|
|
33
|
+
StudyOptions,
|
|
34
|
+
StudyReport,
|
|
35
|
+
TensorStatistics,
|
|
36
|
+
analyze_series,
|
|
37
|
+
analyze_statistics,
|
|
38
|
+
analyze_study,
|
|
39
|
+
discrepancy,
|
|
40
|
+
is_tensor,
|
|
41
|
+
series_from_rows,
|
|
42
|
+
tensor_statistics,
|
|
43
|
+
tensors_from_rows,
|
|
44
|
+
)
|
|
45
|
+
from morphogen.rve.windows import WindowTensors, window_tensors
|
|
46
|
+
|
|
47
|
+
__all__ = [
|
|
48
|
+
"ScalingLaw",
|
|
49
|
+
"Series",
|
|
50
|
+
"SeriesAnalysis",
|
|
51
|
+
"SizeStatistics",
|
|
52
|
+
"StudyOptions",
|
|
53
|
+
"StudyReport",
|
|
54
|
+
"TensorStatistics",
|
|
55
|
+
"WindowTensors",
|
|
56
|
+
"analyze_series",
|
|
57
|
+
"analyze_statistics",
|
|
58
|
+
"analyze_study",
|
|
59
|
+
"discrepancy",
|
|
60
|
+
"ensemble_statistics",
|
|
61
|
+
"fit_scaling_law",
|
|
62
|
+
"fit_statistics",
|
|
63
|
+
"is_tensor",
|
|
64
|
+
"point_variance",
|
|
65
|
+
"point_variance_multiphase",
|
|
66
|
+
"rve_table",
|
|
67
|
+
"rve_volume_classic",
|
|
68
|
+
"series_from_rows",
|
|
69
|
+
"tensor_statistics",
|
|
70
|
+
"tensors_from_rows",
|
|
71
|
+
"window_statistics",
|
|
72
|
+
"window_tensors",
|
|
73
|
+
]
|