Elaston 0.0.2__tar.gz

elaston-0.0.2/.gitignore

@@ -0,0 +1,12 @@
+*.pyc
+.DS_Store
+.coverage
+nohup.out
+pyiron.log
+.idea/
+inspectionProfiles/
+_build/
+apidoc/
+.ipynb_checkpoints/
+test_times.dat
+core.*

elaston-0.0.2/LICENSE

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

elaston-0.0.2/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: Elaston
+Version: 0.0.2
+Summary: Elaston - linear elasticity toolbox
+Project-URL: Homepage, https://pyiron.org/
+Project-URL: Documentation, https://elaston.readthedocs.io
+Project-URL: Repository, https://github.com/pyiron/elaston
+Author-email: Sam Waseda <waseda@mpie.de>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2024, Max-Planck-Institut für Nachhaltige Materialien GmbH - Computational Materials Design (CM) Department
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Keywords: pyiron
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <3.15,>=3.11
+Requires-Dist: numpy<2.5.0,>=2.4.6
+Requires-Dist: semantikon<1.4.0,>=1.3.2
+Description-Content-Type: text/markdown
+
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pyiron/elaston/HEAD)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/4aaeaca43ca54789ae5b328e17e1d937)](https://app.codacy.com/gh/pyiron/elaston/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![Coverage Status](https://coveralls.io/repos/github/pyiron/elaston/badge.svg?branch=main)](https://coveralls.io/github/pyiron/elaston?branch=main)
+[![Documentation Status](https://readthedocs.org/projects/elaston/badge/?version=latest)](https://elaston.readthedocs.io/en/latest/?badge=latest)
+
+# Elaston
+
+Elaston is a simple and lightweight module for linear elasticity calculations.
+
+## Installation
+
+We will offer pip and conda at some point. For now, you can install the package by cloning the repository and running the following command in the root directory:
+
+```bash
+pip install .
+```
+
+## Features
+
+- Calculation of elastic constants
+- Stress, strain and displacement field around dislocations using anisotropic elasticity
+- Stress, strain and displacement field around point defects
+
+
+## Usage
+
+Examples I: Get bulk modulus from the elastic tensor:
+
+```python
+from elaston import LinearElasticity
+
+medium = LinearElasticity(C_11=211.0, C_12=130.0, C_44=82.0)  # Fe
+medium_voigt = medium.get_voigt_average()
+parameters = medium_voigt.get_elastic_moduli()
+print(parameters['bulk_modulus'])
+```
+
+
+Example II: Get strain field around a point defect:
+
+```python
+import numpy as np
+medium = LinearElasticity(C_11=211.0, C_12=130.0, C_44=82.0)
+random_positions = np.random.random((10, 3)) - 0.5
+dipole_tensor = np.eye(3)
+print(medium.get_point_defect_strain(random_positions, dipole_tensor))
+```
+
+
+Example III: Get stress field around a dislocation:
+
+```python
+import numpy as np
+medium = LinearElasticity(C_11=211.0, C_12=130.0, C_44=82.0)
+random_positions = np.random.random((10, 3)) - 0.5
+# Burgers vector of a screw dislocation in bcc Fe
+burgers_vector = np.array([0, 0, 2.86 * np.sqrt(3) / 2])
+print(medium.get_dislocation_stress(random_positions, burgers_vector))
+```
+
+Example IV: Estimate the distance between partial dislocations:
+
+```python
+medium = LinearElasticity(C_11=110.5, C_12=64.8, C_44=30.9)  # Al
+lattice_constant = 4.05
+partial_one = np.array([-0.5, 0, np.sqrt(3) / 2]) * lattice_constant
+partial_two = np.array([0.5, 0, np.sqrt(3) / 2]) * lattice_constant
+distance = 100
+stress_one = medium.get_dislocation_stress([0, distance, 0], partial_one)
+print('Choose `distance` in the way that the value below corresponds to SFE')
+medium.get_dislocation_force(stress_one, [0, 1, 0], partial_two)
+```

elaston-0.0.2/cached-miniforge/my-env/lib/python3.1/site-packages/elaston/__init__.py

@@ -0,0 +1,13 @@
+import importlib.metadata
+
+try:
+    # Installed package will find its version
+    __version__ = importlib.metadata.version(__name__)
+except importlib.metadata.PackageNotFoundError:
+    # Repository clones will register an unknown version
+    __version__ = "0.0.0+unknown"
+
+
+from elaston.linear_elasticity import LinearElasticity
+
+__all__ = ["LinearElasticity"]

elaston-0.0.2/cached-miniforge/my-env/lib/python3.1/site-packages/elaston/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.2'
+__version_tuple__ = version_tuple = (0, 0, 2)
+
+__commit_id__ = commit_id = None

elaston-0.0.2/cached-miniforge/my-env/lib/python3.1/site-packages/elaston/dislocation.py

@@ -0,0 +1,292 @@
+# coding: utf-8
+# Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
+# Distributed under the terms of "New BSD License", see the LICENSE file.
+
+from functools import cached_property
+from typing import Annotated
+
+import numpy as np
+from semantikon.converter import units
+
+__author__ = "Sam Waseda"
+__copyright__ = (
+    "Copyright 2021, Max-Planck-Institut für Eisenforschung GmbH "
+    "- Computational Materials Design (CM) Department"
+)
+__version__ = "1.0"
+__maintainer__ = "Sam Waseda"
+__email__ = "waseda@mpie.de"
+__status__ = "development"
+__date__ = "Aug 21, 2021"
+
+
+class Dislocation:
+    """
+    Anisotropic elasticity theory for dislocations described by
+    [Eshelby](https://doi.org/10.1016/0001-6160(53)90099-6).
+
+    All notations follow the original paper.
+    """
+
+    def __init__(self, elastic_tensor: np.ndarray, burgers_vector: np.ndarray) -> None:
+        """
+        Args:
+            elastic_tensor ((3,3,3,3)-array): Elastic tensor
+            burgers_vector ((3,)-array): Burgers vector
+        """
+        assert np.shape(elastic_tensor) == (3, 3, 3, 3)
+        assert np.shape(burgers_vector) == (3,)
+        self.elastic_tensor = elastic_tensor
+        self.burgers_vector = burgers_vector
+        self.fit_range = np.linspace(0, 1, 10)
+
+    def _get_pmat(self, x: np.ndarray) -> np.ndarray:
+        return (
+            self.elastic_tensor[:, 0, :, 0]
+            + np.einsum(
+                "...,ij->...ij",
+                x,
+                self.elastic_tensor[:, 0, :, 1] + self.elastic_tensor[:, 1, :, 0],
+            )
+            + np.einsum("...,ij->...ij", x**2, self.elastic_tensor[:, 1, :, 1])
+        )
+
+    @cached_property
+    def p(self) -> np.ndarray:
+        coeff = np.polyfit(
+            self.fit_range, np.linalg.det(self._get_pmat(self.fit_range)), 6
+        )
+        p = np.roots(coeff)
+        p = p[np.imag(p) > 0]
+        return p
+
+    @cached_property
+    def Ak(self) -> np.ndarray:
+        Ak = []
+        for mat in self._get_pmat(self.p):
+            values, vectors = np.linalg.eig(mat.T)
+            Ak.append(vectors.T[np.absolute(values).argmin()])
+        return np.array(Ak)
+
+    @cached_property
+    def D(self) -> np.ndarray:
+        F = np.einsum("n,ij->nij", self.p, self.elastic_tensor[:, 1, :, 1])
+        F += self.elastic_tensor[:, 1, :, 0]
+        F = np.einsum("nik,nk->ni", F, self.Ak)
+        F = np.concatenate((F.T, self.Ak.T), axis=0)
+        F = np.concatenate((np.real(F), -np.imag(F)), axis=-1)
+        D = np.linalg.solve(F, np.concatenate((np.zeros(3), self.burgers_vector)))
+        return D[:3] + 1j * D[3:]
+
+    @property
+    def dzdx(self) -> np.ndarray:
+        return np.stack((np.ones_like(self.p), self.p, np.zeros_like(self.p)), axis=-1)
+
+    def _get_z(self, positions: np.ndarray) -> np.ndarray:
+        z = np.stack((np.ones_like(self.p), self.p), axis=-1)
+        return np.einsum("nk,...k->...n", z, np.asarray(positions)[..., :2])
+
+    def get_displacement(self, positions: np.ndarray) -> np.ndarray:
+        """
+        Displacement vectors
+
+        Args:
+            positions ((n,3)-array): Positions for which the displacements are
+                to be calculated
+
+        Returns:
+            ((n,3)-array): Displacement vectors
+        """
+        return np.imag(
+            np.einsum(
+                "nk,n,...n->...k", self.Ak, self.D, np.log(self._get_z(positions))
+            )
+        ) / (2 * np.pi)
+
+    def get_strain(self, positions: np.ndarray) -> np.ndarray:
+        """
+        Strain tensors
+
+        Args:
+            positions ((n,3)-array): Positions for which the strains are to be
+                calculated
+
+        Returns:
+            ((n,3,3)-array): Strain tensors
+        """
+        strain = np.imag(
+            np.einsum(
+                "ni,n,...n,nj->...ij",
+                self.Ak,
+                self.D,
+                1 / self._get_z(positions),
+                self.dzdx,
+            )
+        )
+        strain = strain + np.einsum("...ij->...ji", strain)
+        return strain / 4 / np.pi
+
+
+@units
+def get_dislocation_displacement(
+    elastic_tensor: Annotated[np.ndarray, {"units": "=e"}],
+    positions: np.ndarray,
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+) -> Annotated[np.ndarray, {"units": "=b"}]:
+    """
+    Displacement field around a dislocation according to anisotropic elasticity theory
+    described by [Eshelby](https://doi.org/10.1016/0001-6160(53)90099-6).
+
+    Args:
+        elastic_tensor ((3,3,3,3)-array): Elastic tensor
+        positions ((n,2) or (n,3)-array): Position around a dislocation. The third axis
+            coincides with the dislocation line.
+        burgers_vector ((3,)-array): Burgers vector
+
+    Returns:
+        ((n, 3)-array): Displacement field (z-axis coincides with the dislocation line)
+    """
+    return Dislocation(elastic_tensor, burgers_vector).get_displacement(positions)
+
+
+@units
+def get_dislocation_strain(
+    elastic_tensor: Annotated[np.ndarray, {"units": "=e"}],
+    positions: Annotated[np.ndarray, {"units": "=p"}],
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+) -> Annotated[np.ndarray, {"units": "=b/p"}]:
+    """
+    Strain field around a dislocation according to anisotropic elasticity theory
+    described by [Eshelby](https://doi.org/10.1016/0001-6160(53)90099-6).
+
+    Args:
+        elastic_tensor ((3,3,3,3)-array): Elastic tensor
+        positions ((n,2) or (n,3)-array): Position around a dislocation. The third axis
+            coincides with the dislocation line.
+        burgers_vector ((3,)-array): Burgers vector
+
+    Returns:
+        ((n, 3, 3)-array): Strain field (z-axis coincides with the dislocation line)
+    """
+    return Dislocation(elastic_tensor, burgers_vector).get_strain(positions)
+
+
+@units
+def get_dislocation_stress(
+    elastic_tensor: Annotated[np.ndarray, {"units": "=e"}],
+    positions: Annotated[np.ndarray, {"units": "=p"}],
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+) -> Annotated[np.ndarray, {"units": "=e*b/p"}]:
+    """
+    Stress field around a dislocation according to anisotropic elasticity theory
+    described by [Eshelby](https://doi.org/10.1016/0001-6160(53)90099-6).
+
+    Args:
+        elastic_tensor ((3,3,3,3)-array): Elastic tensor
+        positions ((n,2) or (n,3)-array): Position around a dislocation. The third axis
+            coincides with the dislocation line.
+        burgers_vector ((3,)-array): Burgers vector
+
+    Returns:
+        ((n, 3, 3)-array): Stress field (z-axis coincides with the dislocation line)
+    """
+    strain = get_dislocation_strain(elastic_tensor, positions, burgers_vector)
+    return np.einsum("ijkl,...kl->...ij", elastic_tensor, strain)
+
+
+@units
+def get_dislocation_energy_density(
+    elastic_tensor: Annotated[np.ndarray, {"units": "=e"}],
+    positions: Annotated[np.ndarray, {"units": "=p"}],
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+) -> Annotated[np.ndarray, {"units": "=e*b**2/p**2"}]:
+    """
+    Energy density field around a dislocation (product of stress and strain, cf. corresponding
+    methods)
+
+    Args:
+        elastic_tensor ((3,3,3,3)-array): Elastic tensor
+        positions ((n,2) or (n,3)-array): Position around a dislocation. The third axis
+            coincides with the dislocation line.
+        burgers_vector ((3,)-array): Burgers vector
+
+    Returns:
+        ((n,)-array): Energy density field
+    """
+    strain = get_dislocation_strain(elastic_tensor, positions, burgers_vector)
+    return np.einsum("ijkl,...kl,...ij->...", elastic_tensor, strain, strain)
+
+
+@units
+def get_dislocation_energy(
+    elastic_tensor: Annotated[np.ndarray, {"units": "=e"}],
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+    r_min: Annotated[float, {"units": "=r"}],
+    r_max: Annotated[float, {"units": "=r"}],
+    mesh: int = 100,
+) -> Annotated[float, {"units": "=e*b**2"}]:
+    """
+    Energy per unit length along the dislocation line.
+
+    Args:
+        elastic_tensor ((3,3,3,3)-array): Elastic tensor
+        burgers_vector ((3,)-array): Burgers vector
+        r_min (float): Minimum distance from the dislocation core
+        r_max (float): Maximum distance from the dislocation core
+        mesh (int): Number of grid points for the numerical integration along the angle
+
+    Returns:
+        (float): Energy of dislocation per unit length
+
+    The energy is defined by the product of the stress and strain (i.e. energy density),
+    which is integrated over the plane vertical to the dislocation line. The energy density
+    :math:`w` according to the linear elasticity is given by:
+
+    .. math:
+        w(r, \\theta) = A(\\theta)/r^2
+
+    Therefore, the energy per unit length :math:`U` is given by:
+
+    .. math:
+        U = \\log(r_max/r_min)\\int A(\\theta)\\mathrm d\\theta
+
+    This implies :math:`r_min` cannot be 0 as well as :math:`r_max` cannot be infinity. This
+    is the consequence of the fact that the linear elasticity cannot describe the core
+    structure properly, and a real medium is not infinitely large. While :math:`r_max` can
+    be defined based on the real dislocation density, the choice of :math:`r_min` should be
+    done carefully.
+    """
+    if r_min <= 0:
+        raise ValueError("r_min must be a positive float")
+    theta_range = np.linspace(0, 2 * np.pi, 100, endpoint=False)
+    r = np.stack((np.cos(theta_range), np.sin(theta_range)), axis=-1) * r_min
+    strain = get_dislocation_strain(elastic_tensor, r, burgers_vector=burgers_vector)
+    return (
+        np.einsum("ijkl,nkl,nij->", elastic_tensor, strain, strain)
+        * np.diff(theta_range)[0]
+        * r_min**2
+        * np.log(r_max / r_min)
+    )
+
+
+@units
+def get_dislocation_force(
+    stress: Annotated[np.ndarray, {"units": "=s"}],
+    glide_plane: np.ndarray,
+    burgers_vector: Annotated[np.ndarray, {"units": "=b"}],
+) -> Annotated[np.ndarray, {"units": "=s*b"}]:
+    """
+    Force per unit length along the dislocation line.
+
+    Args:
+        stress ((n, 3, 3)-array): External stress field at the dislocation line
+        glide_plane ((3,)-array): Glide plane
+        burgers_vector ((3,)-array): Burgers vector
+
+    Returns:
+        ((3,)-array): Force per unit length acting on the dislocation.
+    """
+    g = np.asarray(glide_plane) / np.linalg.norm(glide_plane)
+    return np.einsum(
+        "i,...ij,j,k->...k", g, stress, burgers_vector, np.cross(g, [0, 0, 1])
+    )