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
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
"""Isogeometric analysis: NURBS geometries, their analysis and their shape optimization.
|
|
2
|
+
|
|
3
|
+
* :mod:`morphogen.iga.basis`: B-spline functions, knot vectors, refinement operators;
|
|
4
|
+
* :mod:`morphogen.iga.geometry`: NURBS patches and their assemblies (:class:`Patch`,
|
|
5
|
+
:class:`Multipatch`), their refinements;
|
|
6
|
+
* :mod:`morphogen.iga.shapes`: rectangles, rings, plates and periodic cells with holes
|
|
7
|
+
(boxes, parallelograms, the sheet with alternating holes);
|
|
8
|
+
* :mod:`morphogen.iga.analysis`: linear elasticity and conduction (:class:`Analysis`);
|
|
9
|
+
* :mod:`morphogen.iga.homogenization`: the effective tensors of periodic cells, boxes
|
|
10
|
+
or cells of any lattice (:func:`homogenize`, :class:`Cell`);
|
|
11
|
+
* :mod:`morphogen.iga.optimization`: shape optimization with the control points as
|
|
12
|
+
variables, linked by the symmetries of a pattern, and analytical sensitivities
|
|
13
|
+
(:class:`ShapeDesign`, :func:`optimize_cell`, :func:`optimize_structure`).
|
|
14
|
+
|
|
15
|
+
The tutorial ``docs/tutorial_iga.md`` follows the package from a patch to the shape of
|
|
16
|
+
an auxetic sheet.
|
|
17
|
+
"""
|
|
18
|
+
|
|
19
|
+
from morphogen.iga import basis, homogenization, optimization, shapes
|
|
20
|
+
from morphogen.iga.analysis import Analysis, conduction_matrix, elastic_matrix
|
|
21
|
+
from morphogen.iga.geometry import Multipatch, Patch
|
|
22
|
+
from morphogen.iga.homogenization import Cell, CellSolution, homogenize, plane_constants
|
|
23
|
+
from morphogen.iga.optimization import (
|
|
24
|
+
ShapeDesign,
|
|
25
|
+
ShapeResult,
|
|
26
|
+
optimize_cell,
|
|
27
|
+
optimize_structure,
|
|
28
|
+
)
|
|
29
|
+
|
|
30
|
+
__all__ = [
|
|
31
|
+
"Analysis",
|
|
32
|
+
"Cell",
|
|
33
|
+
"CellSolution",
|
|
34
|
+
"Multipatch",
|
|
35
|
+
"Patch",
|
|
36
|
+
"ShapeDesign",
|
|
37
|
+
"ShapeResult",
|
|
38
|
+
"basis",
|
|
39
|
+
"conduction_matrix",
|
|
40
|
+
"elastic_matrix",
|
|
41
|
+
"homogenization",
|
|
42
|
+
"homogenize",
|
|
43
|
+
"optimization",
|
|
44
|
+
"optimize_cell",
|
|
45
|
+
"optimize_structure",
|
|
46
|
+
"plane_constants",
|
|
47
|
+
"shapes",
|
|
48
|
+
]
|
|
@@ -0,0 +1,508 @@
|
|
|
1
|
+
"""Isogeometric analysis of linear elasticity and conduction on NURBS assemblies.
|
|
2
|
+
|
|
3
|
+
The isoparametric concept of Hughes, Cottrell & Bazilevs (2005): the rational functions
|
|
4
|
+
``R_a`` that describe the geometry (:mod:`morphogen.iga.geometry`) interpolate the
|
|
5
|
+
unknowns too, ``u = sum_a R_a u_a``, the unknowns attached to the control points. The
|
|
6
|
+
geometry of the analysis is that of the design — a circle stays a circle at any
|
|
7
|
+
refinement —, and the functions are smooth across the elements of a patch (``C^(p-1)``
|
|
8
|
+
after a *k*-refinement), which gives more accuracy per unknown than finite elements of
|
|
9
|
+
the same degree.
|
|
10
|
+
|
|
11
|
+
Discretization. The elements are the knot spans of each patch; the integrals are those
|
|
12
|
+
of Gauss-Legendre with ``p + 1`` points per direction. At a point, the derivatives of the
|
|
13
|
+
functions with respect to the parameters give the Jacobian ``J = sum_a P_a (x) dR_a/dxi``
|
|
14
|
+
and the gradients ``dR_a/dx = dR_a/dxi J^-1``; the stiffness is ``K = sum int B^T D B det
|
|
15
|
+
J dxi``, as for finite elements, with ``B`` the strain operator of these gradients.
|
|
16
|
+
Strains and stresses are written in Voigt's notation with engineering shears: ``(11, 22,
|
|
17
|
+
12)`` in the plane, ``(11, 22, 33, 23, 31, 12)`` in space (the order of the rest of
|
|
18
|
+
morphoGen). In the plane, ``plane="strain"`` takes the stiffness of the plane components
|
|
19
|
+
of the three-dimensional law, ``plane="stress"`` its condensation at zero out-of-plane
|
|
20
|
+
stresses.
|
|
21
|
+
|
|
22
|
+
Conditions. The functions of an open knot vector interpolate at the ends of a patch:
|
|
23
|
+
the control points of a side carry the values of the unknown along it, so that a
|
|
24
|
+
uniform value (a clamped or symmetric side) is prescribed on them exactly; tractions
|
|
25
|
+
are integrated on the sides.
|
|
26
|
+
"""
|
|
27
|
+
|
|
28
|
+
from __future__ import annotations
|
|
29
|
+
|
|
30
|
+
from collections.abc import Callable, Iterator
|
|
31
|
+
from dataclasses import dataclass
|
|
32
|
+
|
|
33
|
+
import numpy as np
|
|
34
|
+
import scipy.sparse as sp
|
|
35
|
+
import scipy.sparse.linalg as spla
|
|
36
|
+
|
|
37
|
+
from morphogen.iga import basis as bs
|
|
38
|
+
from morphogen.iga.geometry import Multipatch, Patch
|
|
39
|
+
|
|
40
|
+
PLANES = ("strain", "stress")
|
|
41
|
+
PHYSICS = ("elastic", "conduction")
|
|
42
|
+
#: Elements of a patch integrated at once (memory of the arrays of their points)
|
|
43
|
+
_CHUNK = 4096
|
|
44
|
+
|
|
45
|
+
|
|
46
|
+
def elastic_matrix(material, ndim: int, plane: str = "strain") -> np.ndarray:
|
|
47
|
+
"""The stiffness of a material in Voigt's notation for an analysis of ``ndim``
|
|
48
|
+
dimensions: the 6 x 6 matrix of a solid; in the plane, its plane components (plane
|
|
49
|
+
strain) or its condensation at zero out-of-plane stresses (plane stress). ``material``:
|
|
50
|
+
a :class:`~morphogen.homogenization.materials.Material`, or a 6 x 6 (or, in the plane,
|
|
51
|
+
3 x 3) array."""
|
|
52
|
+
if hasattr(material, "matrix"):
|
|
53
|
+
full = np.asarray(material.matrix("elastic"), dtype=float)
|
|
54
|
+
else:
|
|
55
|
+
full = np.asarray(material, dtype=float)
|
|
56
|
+
if ndim == 3:
|
|
57
|
+
if full.shape != (6, 6):
|
|
58
|
+
raise ValueError("elastic_matrix: a 6 x 6 stiffness for a solid")
|
|
59
|
+
return full
|
|
60
|
+
if full.shape == (3, 3):
|
|
61
|
+
return full
|
|
62
|
+
if full.shape != (6, 6):
|
|
63
|
+
raise ValueError("elastic_matrix: a 6 x 6 stiffness, or 3 x 3 in the plane")
|
|
64
|
+
if plane not in PLANES:
|
|
65
|
+
raise ValueError(f"plane: one of {PLANES}")
|
|
66
|
+
kept, out = [0, 1, 5], [2, 3, 4]
|
|
67
|
+
if plane == "strain":
|
|
68
|
+
return full[np.ix_(kept, kept)]
|
|
69
|
+
coupling = full[np.ix_(kept, out)]
|
|
70
|
+
return full[np.ix_(kept, kept)] - coupling @ np.linalg.solve(
|
|
71
|
+
full[np.ix_(out, out)], full[np.ix_(out, kept)]
|
|
72
|
+
)
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def conduction_matrix(material, ndim: int) -> np.ndarray:
|
|
76
|
+
"""The conductivity tensor of a material for an analysis of ``ndim`` dimensions: a
|
|
77
|
+
:class:`~morphogen.homogenization.materials.Material`, a number or a tensor."""
|
|
78
|
+
if hasattr(material, "matrix"):
|
|
79
|
+
full = np.asarray(material.matrix("thermal"), dtype=float)
|
|
80
|
+
else:
|
|
81
|
+
full = np.asarray(material, dtype=float)
|
|
82
|
+
if full.ndim == 0:
|
|
83
|
+
return float(full) * np.eye(ndim)
|
|
84
|
+
return full[:ndim, :ndim]
|
|
85
|
+
|
|
86
|
+
|
|
87
|
+
@dataclass
|
|
88
|
+
class Points:
|
|
89
|
+
"""The integration points of a group of elements of a patch: the control points of
|
|
90
|
+
each element (``nodes``: elements x functions), the weights of the points times the
|
|
91
|
+
Jacobian (``weights``: elements x points), their positions, the functions there and
|
|
92
|
+
their gradients (elements x points x functions (x dim)), and the Jacobian
|
|
93
|
+
determinants."""
|
|
94
|
+
|
|
95
|
+
patch: int
|
|
96
|
+
nodes: np.ndarray
|
|
97
|
+
weights: np.ndarray
|
|
98
|
+
x: np.ndarray
|
|
99
|
+
values: np.ndarray
|
|
100
|
+
gradients: np.ndarray
|
|
101
|
+
jacobian: np.ndarray
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
def _directions(patch: Patch, extra: int):
|
|
105
|
+
"""For each direction of a patch: the functions and their derivatives at the Gauss
|
|
106
|
+
points of its elements (elements x points x degree + 1), the weights of the points
|
|
107
|
+
and the indices of these functions (elements x degree + 1)."""
|
|
108
|
+
out = []
|
|
109
|
+
for knots, degree in zip(patch.knots, patch.degrees, strict=True):
|
|
110
|
+
ends = bs.breakpoints(knots)
|
|
111
|
+
points, weights = bs.gauss(degree + 1 + extra)
|
|
112
|
+
u = ends[:-1, None] + np.diff(ends)[:, None] * points[None, :]
|
|
113
|
+
span, values = bs.basis(knots, degree, u.ravel(), 1)
|
|
114
|
+
shape = (len(ends) - 1, len(points), degree + 1)
|
|
115
|
+
index = span.reshape(u.shape)[:, :1] - degree + np.arange(degree + 1)[None, :]
|
|
116
|
+
out.append((values[0].reshape(shape), values[1].reshape(shape),
|
|
117
|
+
np.diff(ends)[:, None] * weights[None, :], index)) # fmt: skip
|
|
118
|
+
return out
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
def _tensor(directions, which: int | None, rows: np.ndarray) -> np.ndarray:
|
|
122
|
+
"""The products of the functions of the directions for the elements ``rows`` of the
|
|
123
|
+
first one (all those of the others), the direction ``which`` differentiated:
|
|
124
|
+
elements x points x functions."""
|
|
125
|
+
factors = [d[1] if k == which else d[0] for k, d in enumerate(directions)]
|
|
126
|
+
factors[0] = factors[0][rows]
|
|
127
|
+
if len(factors) == 2:
|
|
128
|
+
out = np.einsum("iga,jhb->ijghab", *factors)
|
|
129
|
+
else:
|
|
130
|
+
out = np.einsum("iga,jhb,kfc->ijkghfabc", *factors)
|
|
131
|
+
n = len(factors)
|
|
132
|
+
elements = int(np.prod(out.shape[:n]))
|
|
133
|
+
points = int(np.prod(out.shape[n : 2 * n]))
|
|
134
|
+
return out.reshape(elements, points, -1)
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
def patch_points(model: Multipatch, k: int, extra: int = 0) -> Iterator[Points]:
|
|
138
|
+
"""The integration points of patch ``k`` of an assembly, by groups of elements
|
|
139
|
+
(``extra`` Gauss points per direction beyond ``degree + 1``)."""
|
|
140
|
+
patch, ids = model.patches[k], model.ids[k]
|
|
141
|
+
ndim = patch.ndim
|
|
142
|
+
if patch.dim != ndim or ndim not in (2, 3):
|
|
143
|
+
raise ValueError("analysis: surfaces of the plane or solids")
|
|
144
|
+
directions = _directions(patch, extra)
|
|
145
|
+
others = int(np.prod([len(d[2]) for d in directions[1:]]))
|
|
146
|
+
step = max(1, _CHUNK // others)
|
|
147
|
+
for start in range(0, len(directions[0][2]), step):
|
|
148
|
+
rows = np.arange(start, min(start + step, len(directions[0][2])))
|
|
149
|
+
index = [d[3] for d in directions]
|
|
150
|
+
index[0] = index[0][rows]
|
|
151
|
+
if ndim == 2:
|
|
152
|
+
nodes = ids[index[0][:, None, :, None], index[1][None, :, None, :]]
|
|
153
|
+
w = np.einsum("ig,jh->ijgh", directions[0][2][rows], directions[1][2])
|
|
154
|
+
else:
|
|
155
|
+
nodes = ids[index[0][:, None, None, :, None, None],
|
|
156
|
+
index[1][None, :, None, None, :, None],
|
|
157
|
+
index[2][None, None, :, None, None, :]] # fmt: skip
|
|
158
|
+
w = np.einsum("ig,jh,kf->ijkghf", directions[0][2][rows], directions[1][2],
|
|
159
|
+
directions[2][2]) # fmt: skip
|
|
160
|
+
n_el = int(np.prod(nodes.shape[:ndim]))
|
|
161
|
+
nodes = nodes.reshape(n_el, -1)
|
|
162
|
+
w = w.reshape(n_el, -1)
|
|
163
|
+
weight = model.weights[nodes] # elements x functions
|
|
164
|
+
values = _tensor(directions, None, rows) * weight[:, None, :]
|
|
165
|
+
total = values.sum(axis=2)
|
|
166
|
+
values /= total[:, :, None]
|
|
167
|
+
derived = np.empty((*values.shape, ndim))
|
|
168
|
+
for d in range(ndim):
|
|
169
|
+
dn = _tensor(directions, d, rows) * weight[:, None, :]
|
|
170
|
+
derived[..., d] = (dn - values * dn.sum(axis=2)[:, :, None]) / total[:, :, None]
|
|
171
|
+
control = model.nodes[nodes] # elements x functions x dim
|
|
172
|
+
x = np.einsum("eqa,eak->eqk", values, control)
|
|
173
|
+
jac = np.einsum("eqad,eak->eqkd", derived, control)
|
|
174
|
+
det = np.linalg.det(jac)
|
|
175
|
+
gradients = np.einsum("eqad,eqdk->eqak", derived, np.linalg.inv(jac))
|
|
176
|
+
yield Points(k, nodes, w * det, x, values, gradients, det)
|
|
177
|
+
|
|
178
|
+
|
|
179
|
+
def strain_operator(gradients: np.ndarray) -> np.ndarray:
|
|
180
|
+
"""The strain operator ``B`` of the gradients of the functions (... x functions x
|
|
181
|
+
dim): ... x strains x (functions dim), in Voigt's notation with engineering shears."""
|
|
182
|
+
*lead, n, dim = gradients.shape
|
|
183
|
+
rows = 3 if dim == 2 else 6
|
|
184
|
+
b = np.zeros((*lead, rows, n, dim))
|
|
185
|
+
if dim == 2:
|
|
186
|
+
b[..., 0, :, 0] = gradients[..., 0]
|
|
187
|
+
b[..., 1, :, 1] = gradients[..., 1]
|
|
188
|
+
b[..., 2, :, 0] = gradients[..., 1]
|
|
189
|
+
b[..., 2, :, 1] = gradients[..., 0]
|
|
190
|
+
else:
|
|
191
|
+
gx, gy, gz = gradients[..., 0], gradients[..., 1], gradients[..., 2]
|
|
192
|
+
b[..., 0, :, 0] = gx
|
|
193
|
+
b[..., 1, :, 1] = gy
|
|
194
|
+
b[..., 2, :, 2] = gz
|
|
195
|
+
b[..., 3, :, 1] = gz
|
|
196
|
+
b[..., 3, :, 2] = gy
|
|
197
|
+
b[..., 4, :, 0] = gz
|
|
198
|
+
b[..., 4, :, 2] = gx
|
|
199
|
+
b[..., 5, :, 0] = gy
|
|
200
|
+
b[..., 5, :, 1] = gx
|
|
201
|
+
return b.reshape(*lead, rows, n * dim)
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
class Analysis:
|
|
205
|
+
"""The discretization of an assembly for a physics (see the module): ``"elastic"``
|
|
206
|
+
(``plane``: ``"strain"`` or ``"stress"`` for surfaces) or ``"conduction"``, with the
|
|
207
|
+
``materials`` of the phases of its patches (:class:`~morphogen.homogenization.
|
|
208
|
+
materials.Material`, or their matrices); ``extra`` Gauss points per direction beyond
|
|
209
|
+
``degree + 1``."""
|
|
210
|
+
|
|
211
|
+
def __init__(self, model: Multipatch, materials, *, physics: str = "elastic",
|
|
212
|
+
plane: str = "strain", extra: int = 0): # fmt: skip
|
|
213
|
+
if physics not in PHYSICS:
|
|
214
|
+
raise ValueError(f"physics: one of {PHYSICS}")
|
|
215
|
+
if isinstance(model, Patch):
|
|
216
|
+
model = Multipatch(model)
|
|
217
|
+
self.model = model
|
|
218
|
+
self.physics = physics
|
|
219
|
+
self.plane = plane
|
|
220
|
+
self.extra = int(extra)
|
|
221
|
+
self.dim = model.dim
|
|
222
|
+
#: Unknowns per control point, and components of the gradient-like measure
|
|
223
|
+
self.nd = self.dim if physics == "elastic" else 1
|
|
224
|
+
missing = [p for p in model.phases if p not in materials]
|
|
225
|
+
if missing:
|
|
226
|
+
raise ValueError(f"no material for phase(s) {missing}")
|
|
227
|
+
if physics == "elastic":
|
|
228
|
+
self.matrices = {p: elastic_matrix(materials[p], self.dim, plane) for p in model.phases}
|
|
229
|
+
else:
|
|
230
|
+
self.matrices = {p: conduction_matrix(materials[p], self.dim) for p in model.phases}
|
|
231
|
+
self.n_dofs = self.nd * model.n_nodes
|
|
232
|
+
|
|
233
|
+
# -- the points and their operators ---------------------------------------------------
|
|
234
|
+
|
|
235
|
+
def points(self) -> Iterator[tuple[Points, np.ndarray, np.ndarray, np.ndarray]]:
|
|
236
|
+
"""The groups of integration points with their operator ``B`` (strains, or
|
|
237
|
+
gradients: elements x points x components x unknowns of the element), the
|
|
238
|
+
matrix of their material and the unknowns of their elements."""
|
|
239
|
+
for k, patch in enumerate(self.model.patches):
|
|
240
|
+
for pts in patch_points(self.model, k, self.extra):
|
|
241
|
+
if np.any(pts.jacobian <= 0.0):
|
|
242
|
+
raise ValueError(
|
|
243
|
+
f"patch {k}: the Jacobian of its geometry is not positive everywhere "
|
|
244
|
+
"(a patch turned over, or folded)"
|
|
245
|
+
)
|
|
246
|
+
if self.physics == "elastic":
|
|
247
|
+
b = strain_operator(pts.gradients)
|
|
248
|
+
else:
|
|
249
|
+
b = np.swapaxes(pts.gradients, 2, 3)
|
|
250
|
+
dofs = (self.nd * pts.nodes[:, :, None] + np.arange(self.nd)).reshape(
|
|
251
|
+
len(pts.nodes), -1
|
|
252
|
+
)
|
|
253
|
+
yield pts, b, self.matrices[patch.phase], dofs
|
|
254
|
+
|
|
255
|
+
def matrix(self) -> sp.csr_matrix:
|
|
256
|
+
"""The stiffness (conductivity) matrix of all the unknowns."""
|
|
257
|
+
rows, cols, values = [], [], []
|
|
258
|
+
for pts, b, d, dofs in self.points():
|
|
259
|
+
ke = np.einsum("eq,eqsi,st,eqtj->eij", pts.weights, b, d, b, optimize=True)
|
|
260
|
+
n = dofs.shape[1]
|
|
261
|
+
rows.append(np.repeat(dofs, n, axis=1).ravel())
|
|
262
|
+
cols.append(np.tile(dofs, (1, n)).ravel())
|
|
263
|
+
values.append(ke.ravel())
|
|
264
|
+
matrix = sp.coo_matrix(
|
|
265
|
+
(np.concatenate(values), (np.concatenate(rows), np.concatenate(cols))),
|
|
266
|
+
shape=(self.n_dofs, self.n_dofs),
|
|
267
|
+
)
|
|
268
|
+
return matrix.tocsr()
|
|
269
|
+
|
|
270
|
+
def measure(self) -> float:
|
|
271
|
+
"""The area (volume) of the assembly."""
|
|
272
|
+
return float(sum(pts.weights.sum() for pts, _, _, _ in self.points()))
|
|
273
|
+
|
|
274
|
+
def uniform_loads(self) -> tuple[np.ndarray, np.ndarray]:
|
|
275
|
+
"""The nodal forces ``int B^T D E`` of the unit uniform strains (gradients) ``E``
|
|
276
|
+
(unknowns x components), and ``int D`` (components x components)."""
|
|
277
|
+
n = next(iter(self.matrices.values())).shape[0]
|
|
278
|
+
loads = np.zeros((self.n_dofs, n))
|
|
279
|
+
total = np.zeros((n, n))
|
|
280
|
+
for pts, b, d, dofs in self.points():
|
|
281
|
+
fe = np.einsum("eq,eqsi,st->eit", pts.weights, b, d)
|
|
282
|
+
for j in range(n):
|
|
283
|
+
np.add.at(loads[:, j], dofs, fe[:, :, j])
|
|
284
|
+
total += pts.weights.sum() * d
|
|
285
|
+
return loads, total
|
|
286
|
+
|
|
287
|
+
# -- loads ------------------------------------------------------------------------------
|
|
288
|
+
|
|
289
|
+
def side_load(self, patch: int, axis: int, end: int, traction) -> np.ndarray:
|
|
290
|
+
"""The nodal forces of a traction (a flux, for conduction) on a side of a
|
|
291
|
+
patch: a vector, or a function ``traction(x, n)`` of the points (points x dim)
|
|
292
|
+
and of the outward unit normals there."""
|
|
293
|
+
p = self.model.patches[patch]
|
|
294
|
+
local = self.model.side_nodes(patch, axis, end)
|
|
295
|
+
f = np.zeros((self.model.n_nodes, self.nd))
|
|
296
|
+
values, x, tangents, w, nodes, params = _side_points(p.side(axis, end), self.extra)
|
|
297
|
+
if self.dim == 2:
|
|
298
|
+
normal = np.stack([tangents[..., 1, 0], -tangents[..., 0, 0]], axis=-1)
|
|
299
|
+
else:
|
|
300
|
+
normal = np.cross(tangents[..., 0], tangents[..., 1])
|
|
301
|
+
size = np.linalg.norm(normal, axis=-1)
|
|
302
|
+
normal = normal / size[..., None]
|
|
303
|
+
# outwards: along the direction of the patch that leaves it through this side
|
|
304
|
+
full = np.insert(params.reshape(-1, p.ndim - 1), axis, p.knots[axis][-end], axis=1)
|
|
305
|
+
leaving = p.jacobian(full)[1][:, :, axis].reshape(x.shape) * (1.0 if end else -1.0)
|
|
306
|
+
normal = normal * np.sign(np.einsum("eqk,eqk->eq", normal, leaving))[..., None]
|
|
307
|
+
if callable(traction):
|
|
308
|
+
t = np.asarray(traction(x.reshape(-1, self.dim), normal.reshape(-1, self.dim)))
|
|
309
|
+
t = t.reshape(*x.shape[:2], self.nd)
|
|
310
|
+
else:
|
|
311
|
+
t = np.broadcast_to(np.asarray(traction, dtype=float), (*x.shape[:2], self.nd))
|
|
312
|
+
fe = np.einsum("eq,eqa,eqc->eac", w * size, values, t)
|
|
313
|
+
np.add.at(f, local[nodes], fe)
|
|
314
|
+
return f.ravel()
|
|
315
|
+
|
|
316
|
+
# -- solution ---------------------------------------------------------------------------
|
|
317
|
+
|
|
318
|
+
def dofs(self, nodes, components=None) -> np.ndarray:
|
|
319
|
+
"""The unknowns of control points: all their components, or those given."""
|
|
320
|
+
nodes = np.atleast_1d(np.asarray(nodes, dtype=np.int64))
|
|
321
|
+
components = range(self.nd) if components is None else np.atleast_1d(components)
|
|
322
|
+
return np.concatenate([self.nd * nodes + int(c) for c in components])
|
|
323
|
+
|
|
324
|
+
def solve(self, forces, fixed, values=0.0, matrix=None) -> np.ndarray:
|
|
325
|
+
"""The unknowns under nodal ``forces`` with the unknowns ``fixed`` prescribed to
|
|
326
|
+
``values`` (0 by default)."""
|
|
327
|
+
k = self.matrix() if matrix is None else matrix
|
|
328
|
+
fixed = np.unique(np.asarray(fixed, dtype=np.int64))
|
|
329
|
+
u = np.zeros(self.n_dofs)
|
|
330
|
+
u[fixed] = values
|
|
331
|
+
free = np.setdiff1d(np.arange(self.n_dofs), fixed)
|
|
332
|
+
rhs = np.asarray(forces, dtype=float)[free] - (k[free][:, fixed] @ u[fixed])
|
|
333
|
+
u[free] = spla.spsolve(k[free][:, free].tocsc(), rhs)
|
|
334
|
+
return u
|
|
335
|
+
|
|
336
|
+
# -- fields -----------------------------------------------------------------------------
|
|
337
|
+
|
|
338
|
+
def fields(self, u, counts: int = 4) -> list[dict]:
|
|
339
|
+
"""For each patch, on a grid of parameters (``counts`` per element and direction):
|
|
340
|
+
the positions, the unknown and, for the elastic problems, the strains and the
|
|
341
|
+
stresses there (Voigt's notation); for conduction, the gradient and the flux."""
|
|
342
|
+
u = np.asarray(u, dtype=float).reshape(-1, self.nd)
|
|
343
|
+
out = []
|
|
344
|
+
for k, patch in enumerate(self.model.patches):
|
|
345
|
+
params = _grid(patch, counts)
|
|
346
|
+
values, gradients, x = _functions_at(self.model, k, params)
|
|
347
|
+
nodes = self.model.ids[k].ravel()
|
|
348
|
+
d = self.matrices[patch.phase]
|
|
349
|
+
if self.physics == "elastic":
|
|
350
|
+
b = strain_operator(gradients)
|
|
351
|
+
measure = b @ u[nodes].ravel()
|
|
352
|
+
flux = measure @ d.T
|
|
353
|
+
names = ("strain", "stress")
|
|
354
|
+
else:
|
|
355
|
+
measure = np.einsum("mak,a->mk", gradients, u[nodes, 0])
|
|
356
|
+
flux = -measure @ d.T
|
|
357
|
+
names = ("gradient", "flux")
|
|
358
|
+
out.append(
|
|
359
|
+
{
|
|
360
|
+
"x": x,
|
|
361
|
+
"u": values @ u[nodes],
|
|
362
|
+
names[0]: measure,
|
|
363
|
+
names[1]: flux,
|
|
364
|
+
"shape": params.shape[:-1],
|
|
365
|
+
"parameters": params.reshape(-1, patch.ndim),
|
|
366
|
+
}
|
|
367
|
+
)
|
|
368
|
+
return out
|
|
369
|
+
|
|
370
|
+
def at(self, u, patch: int, params) -> dict:
|
|
371
|
+
"""The position, the unknown and its measures at parameters of a patch (points x
|
|
372
|
+
ndim), as :meth:`fields`."""
|
|
373
|
+
params = np.atleast_2d(np.asarray(params, dtype=float))
|
|
374
|
+
u = np.asarray(u, dtype=float).reshape(-1, self.nd)
|
|
375
|
+
values, gradients, x = _functions_at(self.model, patch, params)
|
|
376
|
+
nodes = self.model.ids[patch].ravel()
|
|
377
|
+
d = self.matrices[self.model.patches[patch].phase]
|
|
378
|
+
if self.physics == "elastic":
|
|
379
|
+
measure = strain_operator(gradients) @ u[nodes].ravel()
|
|
380
|
+
return {"x": x, "u": values @ u[nodes], "strain": measure, "stress": measure @ d.T}
|
|
381
|
+
measure = np.einsum("mak,a->mk", gradients, u[nodes, 0])
|
|
382
|
+
return {"x": x, "u": values @ u[nodes], "gradient": measure, "flux": -measure @ d.T}
|
|
383
|
+
|
|
384
|
+
def error(self, u, exact: Callable | None = None, exact_stress: Callable | None = None):
|
|
385
|
+
"""The errors of a solution against an exact one: ``l2``, the relative error of
|
|
386
|
+
the unknown in the mean square (``exact(x)``: points x unknowns), and ``energy``,
|
|
387
|
+
that of the stresses in the energy norm (``exact_stress(x)``: points x
|
|
388
|
+
components, Voigt's notation); each for the function given."""
|
|
389
|
+
u = np.asarray(u, dtype=float)
|
|
390
|
+
num = den = num_e = den_e = 0.0
|
|
391
|
+
for pts, b, d, dofs in self.points():
|
|
392
|
+
flat = pts.x.reshape(-1, self.dim)
|
|
393
|
+
if exact is not None:
|
|
394
|
+
ref = np.asarray(exact(flat)).reshape(*pts.x.shape[:2], self.nd)
|
|
395
|
+
ue = u[dofs].reshape(len(dofs), -1, self.nd)
|
|
396
|
+
uh = np.einsum("eqa,eac->eqc", pts.values, ue)
|
|
397
|
+
num += float(np.einsum("eq,eqc,eqc->", pts.weights, uh - ref, uh - ref))
|
|
398
|
+
den += float(np.einsum("eq,eqc,eqc->", pts.weights, ref, ref))
|
|
399
|
+
if exact_stress is not None:
|
|
400
|
+
sigma = np.einsum("st,eqti,ei->eqs", d, b, u[dofs])
|
|
401
|
+
ref_s = np.asarray(exact_stress(flat)).reshape(sigma.shape)
|
|
402
|
+
compliance = np.linalg.inv(d)
|
|
403
|
+
diff = sigma - ref_s
|
|
404
|
+
num_e += float(np.einsum("eq,eqs,st,eqt->", pts.weights, diff, compliance, diff))
|
|
405
|
+
den_e += float(np.einsum("eq,eqs,st,eqt->", pts.weights, ref_s, compliance, ref_s))
|
|
406
|
+
out = {}
|
|
407
|
+
if exact is not None:
|
|
408
|
+
out["l2"] = float(np.sqrt(num / den))
|
|
409
|
+
if exact_stress is not None:
|
|
410
|
+
out["energy"] = float(np.sqrt(num_e / den_e))
|
|
411
|
+
return out
|
|
412
|
+
|
|
413
|
+
|
|
414
|
+
def _grid(patch: Patch, counts) -> np.ndarray:
|
|
415
|
+
"""A grid of parameters of a patch: ``counts`` per element and direction, the ends
|
|
416
|
+
of the elements included (... x ndim)."""
|
|
417
|
+
axes = []
|
|
418
|
+
for knots in patch.knots:
|
|
419
|
+
ends = bs.breakpoints(knots)
|
|
420
|
+
inside = ends[:-1, None] + np.diff(ends)[:, None] * np.arange(counts)[None, :] / counts
|
|
421
|
+
axes.append(np.append(inside.ravel(), ends[-1]))
|
|
422
|
+
return np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1)
|
|
423
|
+
|
|
424
|
+
|
|
425
|
+
def _functions_at(model: Multipatch, k: int, params):
|
|
426
|
+
"""The rational functions of all the control points of patch ``k`` and their
|
|
427
|
+
gradients at parameters (points x functions (x dim)), and the positions."""
|
|
428
|
+
patch = model.patches[k]
|
|
429
|
+
params = np.asarray(params, dtype=float).reshape(-1, patch.ndim)
|
|
430
|
+
letters = "abc"[: patch.ndim]
|
|
431
|
+
spec = ",".join(f"m{c}" for c in letters) + f"->m{letters}"
|
|
432
|
+
weight = patch.weights.ravel()
|
|
433
|
+
|
|
434
|
+
def product(which):
|
|
435
|
+
matrices = [
|
|
436
|
+
bs.collocation(patch.knots[d], patch.degrees[d], params[:, d], int(d == which))
|
|
437
|
+
for d in range(patch.ndim)
|
|
438
|
+
]
|
|
439
|
+
return np.einsum(spec, *matrices).reshape(len(params), -1) * weight[None, :]
|
|
440
|
+
|
|
441
|
+
values = product(None)
|
|
442
|
+
total = values.sum(axis=1)
|
|
443
|
+
values /= total[:, None]
|
|
444
|
+
derived = np.empty((*values.shape, patch.ndim))
|
|
445
|
+
for d in range(patch.ndim):
|
|
446
|
+
dn = product(d)
|
|
447
|
+
derived[..., d] = (dn - values * dn.sum(axis=1)[:, None]) / total[:, None]
|
|
448
|
+
control = model.nodes[model.ids[k].ravel()]
|
|
449
|
+
x = values @ control
|
|
450
|
+
jac = np.einsum("mad,ak->mkd", derived, control)
|
|
451
|
+
gradients = np.einsum("mad,mdk->mak", derived, np.linalg.inv(jac))
|
|
452
|
+
return values, gradients, x
|
|
453
|
+
|
|
454
|
+
|
|
455
|
+
def _side_points(side: Patch, extra: int):
|
|
456
|
+
"""The integration points of a side (a curve or a surface in a space of one more
|
|
457
|
+
dimension): the functions (elements x points x functions), the positions, the
|
|
458
|
+
tangents (elements x points x dim x ndim), the weights of the points, the control
|
|
459
|
+
points of the elements (indices in the raveled side) and the parameters of the
|
|
460
|
+
points (elements x points x ndim)."""
|
|
461
|
+
directions = _directions(side, extra)
|
|
462
|
+
ids = np.arange(side.weights.size).reshape(side.shape)
|
|
463
|
+
parameters = []
|
|
464
|
+
for knots, degree in zip(side.knots, side.degrees, strict=True):
|
|
465
|
+
ends = bs.breakpoints(knots)
|
|
466
|
+
points, _ = bs.gauss(degree + 1 + extra)
|
|
467
|
+
parameters.append(ends[:-1, None] + np.diff(ends)[:, None] * points[None, :])
|
|
468
|
+
if side.ndim == 1:
|
|
469
|
+
n, dn, w, index = directions[0]
|
|
470
|
+
nodes = ids[index]
|
|
471
|
+
values, derived = n.copy(), dn[..., None].copy()
|
|
472
|
+
params = parameters[0][..., None]
|
|
473
|
+
else:
|
|
474
|
+
rows = np.arange(len(directions[0][2]))
|
|
475
|
+
index = [d[3] for d in directions]
|
|
476
|
+
nodes = ids[index[0][:, None, :, None], index[1][None, :, None, :]]
|
|
477
|
+
nodes = nodes.reshape(-1, nodes.shape[2] * nodes.shape[3])
|
|
478
|
+
w = np.einsum("ig,jh->ijgh", directions[0][2], directions[1][2]).reshape(len(nodes), -1)
|
|
479
|
+
values = _tensor(directions, None, rows)
|
|
480
|
+
derived = np.stack([_tensor(directions, d, rows) for d in range(2)], axis=-1)
|
|
481
|
+
first = np.broadcast_to(parameters[0][:, None, :, None],
|
|
482
|
+
(len(parameters[0]), len(parameters[1]),
|
|
483
|
+
parameters[0].shape[1], parameters[1].shape[1])) # fmt: skip
|
|
484
|
+
second = np.broadcast_to(parameters[1][None, :, None, :], first.shape)
|
|
485
|
+
params = np.stack([first, second], axis=-1).reshape(len(nodes), -1, 2)
|
|
486
|
+
weight = side.weights.ravel()[nodes]
|
|
487
|
+
values = values * weight[:, None, :]
|
|
488
|
+
total = values.sum(axis=2)
|
|
489
|
+
values /= total[:, :, None]
|
|
490
|
+
for d in range(side.ndim):
|
|
491
|
+
dn = derived[..., d] * weight[:, None, :]
|
|
492
|
+
derived[..., d] = (dn - values * dn.sum(axis=2)[:, :, None]) / total[:, :, None]
|
|
493
|
+
control = side.points.reshape(-1, side.dim)[nodes]
|
|
494
|
+
x = np.einsum("eqa,eak->eqk", values, control)
|
|
495
|
+
tangents = np.einsum("eqad,eak->eqkd", derived, control)
|
|
496
|
+
return values, x, tangents, w, nodes, params
|
|
497
|
+
|
|
498
|
+
|
|
499
|
+
__all__ = [
|
|
500
|
+
"PHYSICS",
|
|
501
|
+
"PLANES",
|
|
502
|
+
"Analysis",
|
|
503
|
+
"Points",
|
|
504
|
+
"conduction_matrix",
|
|
505
|
+
"elastic_matrix",
|
|
506
|
+
"patch_points",
|
|
507
|
+
"strain_operator",
|
|
508
|
+
]
|