AMELI 1.2.0__tar.gz

ameli-1.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Reinhard Caspary <r.caspary@posteo.de>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ameli-1.2.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: AMELI
+Version: 1.2.0
+Summary: Python 3 package to calculate angular matrix elements of lanthanide ions.
+Author-email: Reinhard Caspary <reinhard.caspary@phoenixd.uni-hannover.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/reincas/AMELI
+Project-URL: Issues, https://github.com/reincas/AMELI/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: h5py==3.15.1
+Requires-Dist: numpy==2.4.2
+Requires-Dist: scidatacontainer==1.2.0
+Requires-Dist: sympy==1.14.0
+Dynamic: license-file
+
+# AMELI 1.2.0 (Angular Matrix Elements of Lanthanide Ions)
+
+This is a Python 3 package to calculate the angular matrix elements of spherical tensor operators of lanthanide ions
+in exact arithmetic using SymPy.
+Each matrix element is stored as signed square root of a rational number.
+The basic functions support any many-electron configuration, but the implementation of most high-level operators is
+specific for single-shell systems like the lanthanide ions. 
+
+The main purpose of this software is the preparation of the comprehensive matrix datasets in the
+[AMELI repository](https://zenodo.org/communities/ameli) on Zenodo.
+Each lanthanide dataset for the configurations $f^1$ to $f^{13}$ contains unit tensor operators, angular momentum
+operators and perturbation Hamiltonians.
+All relevant perturbation operators are provided in first order (Coulomb, spin-orbit, spin-spin, spin-other-orbit) and
+in second order (Coulomb, electrostatic spin-orbit).
+
+The AMELI matrix datasets are intended as replacements for the printed and incomplete tables published mainly by
+B. R. Judd, W. T. Carnall, C. W. Nielson, and G. F. Koster on the 1960s and 1970s.
+In particular they are intended to replace all tables of reduced unit tensor matrix elements in intermediate coupling
+still used for Judd-Ofelt calculations.
+Such calculations should instead be based on a set of radial integrals serving as linear expansion coefficients for the
+operator matrices.
+
+## Documentation
+
+A paper on the mathematical background of AMELI, its workflow, and a detailed comparison of the resulting tensor
+matrices to the literature is ready and will be submitted to arXiv and a scientific journal very soon.  
+
+## General Remarks
+
+All angular matrices of a given electron configuration are constants and need to be calculated only once. 
+This software package therefore is intended mainly as reference.
+Instead of integrating AMELI code into your own project, you should use the matrices from the AMELI repository on
+Zenodo.
+A reference implementation will be provided by the [Lanthanide](https://github.com/reincas/Lanthanide) package,
+which will soon be switching from self-generated matrices to AMELI.
+
+AMELI calculates operator matrices in the product state space together with a transformation matrix to $LS$-coupling
+in exact arithmetic.
+All characteristic eigenvalues and irreducible representations for each state are provided.
+Global signs are synchronized for states inside each $J$-multiplet.
+This allows to use reduced matrices for intermediate coupling in amorphous materials.
+
+All matrices and other intermediate calculation results are stored as
+[SciDataContainer](https://scidatacontainer.readthedocs.io) files enriched with plenty of meta data and descriptions.
+Following the [FAIR data principles](https://en.wikipedia.org/wiki/FAIR_data) of research data management the container
+content is easily accessible to humans and machines.
+A Python implementation is available, but not necessary, because a SciDataContainer file is just a ZIP folder.
+AMELI containers consist only of JSON files for the meta data and HDF5 files for the numerical data.
+
+## Application 1: Energy Levels of Lanthanides
+
+The matrices can be used for the fit of lanthanide energy levels to measured absorption spectra resulting in radial
+integrals and the coefficients of all states in intermediate coupling.
+For crystalline materials these calculations can take full advantage of all spectral lines using the even-rank unit
+tensor operators for modelling the crystal-field splitting.
+This includes the mixing of states with different $J$ quantum number.
+For amorphous materials the calculations can take advantage of the effective rotational site symmetry which allows to
+perform them in a reduced $SLJ$ space with much smaller matrices.
+
+## Application 2: Transition Intensities of Lanthanides
+
+Based on radial integrals from the literature or own energy-level fits, the coefficients of all states in intermediate
+coupling can be determined as linear combination of $LS$-states.
+This makes the generation of all reduced matrix elements for Judd-Ofelt calculations a simple task.
+While the Judd-Ofelt theory is standard to predict the radiative intensities of every emission and absorption
+transition from measured absorption spectra in amorphous hosts, it is not intended for crystalline hosts.
+The AMELI repository contains all matrices for the Crystal Field Intensity (CFI) method instead, which uses the same
+mathematical procedure as Judd-Ofelt, but with a larger set of parameters reflecting the richer structure of 
+crystalline spectra.
+Based on odd-rank unit tensor operators the electric dipole operators for any site-symmetry can be modelled in
+addition to the magnetic dipole operator, which is the same for amorphous and crystalline materials.
+
+## Package Structure
+
+The main code of the AMELI package is contained in the folder `ameli`.
+The script `generate.py` in the folder `generate` is used to calculate the full set of matrices for all lanthanide
+configurations.
+Due to the exact arithmetic this is a time-consuming process.
+Even though the script builds a dependency graph and schedules the computation tasks to all available CPU cores, it
+takes several days to finish.
+The folder `test`contains a set of test scripts orchestrated by the main script `test.py` which perform a large number
+of mathematical tests and comparisons to values published in printed literature.
+Its subfolder `results` contains the results from a test run and the subfolder `tables` contains the script used to
+extract the comparison tables in the AMELI paper from the test results.
+The folder `upload` is for documentation only.
+It contains the scripts used to upload and update the matrix datasets on the Zenodo repository.

ameli-1.2.0/README.md

@@ -0,0 +1,86 @@
+# AMELI 1.2.0 (Angular Matrix Elements of Lanthanide Ions)
+
+This is a Python 3 package to calculate the angular matrix elements of spherical tensor operators of lanthanide ions
+in exact arithmetic using SymPy.
+Each matrix element is stored as signed square root of a rational number.
+The basic functions support any many-electron configuration, but the implementation of most high-level operators is
+specific for single-shell systems like the lanthanide ions. 
+
+The main purpose of this software is the preparation of the comprehensive matrix datasets in the
+[AMELI repository](https://zenodo.org/communities/ameli) on Zenodo.
+Each lanthanide dataset for the configurations $f^1$ to $f^{13}$ contains unit tensor operators, angular momentum
+operators and perturbation Hamiltonians.
+All relevant perturbation operators are provided in first order (Coulomb, spin-orbit, spin-spin, spin-other-orbit) and
+in second order (Coulomb, electrostatic spin-orbit).
+
+The AMELI matrix datasets are intended as replacements for the printed and incomplete tables published mainly by
+B. R. Judd, W. T. Carnall, C. W. Nielson, and G. F. Koster on the 1960s and 1970s.
+In particular they are intended to replace all tables of reduced unit tensor matrix elements in intermediate coupling
+still used for Judd-Ofelt calculations.
+Such calculations should instead be based on a set of radial integrals serving as linear expansion coefficients for the
+operator matrices.
+
+## Documentation
+
+A paper on the mathematical background of AMELI, its workflow, and a detailed comparison of the resulting tensor
+matrices to the literature is ready and will be submitted to arXiv and a scientific journal very soon.  
+
+## General Remarks
+
+All angular matrices of a given electron configuration are constants and need to be calculated only once. 
+This software package therefore is intended mainly as reference.
+Instead of integrating AMELI code into your own project, you should use the matrices from the AMELI repository on
+Zenodo.
+A reference implementation will be provided by the [Lanthanide](https://github.com/reincas/Lanthanide) package,
+which will soon be switching from self-generated matrices to AMELI.
+
+AMELI calculates operator matrices in the product state space together with a transformation matrix to $LS$-coupling
+in exact arithmetic.
+All characteristic eigenvalues and irreducible representations for each state are provided.
+Global signs are synchronized for states inside each $J$-multiplet.
+This allows to use reduced matrices for intermediate coupling in amorphous materials.
+
+All matrices and other intermediate calculation results are stored as
+[SciDataContainer](https://scidatacontainer.readthedocs.io) files enriched with plenty of meta data and descriptions.
+Following the [FAIR data principles](https://en.wikipedia.org/wiki/FAIR_data) of research data management the container
+content is easily accessible to humans and machines.
+A Python implementation is available, but not necessary, because a SciDataContainer file is just a ZIP folder.
+AMELI containers consist only of JSON files for the meta data and HDF5 files for the numerical data.
+
+## Application 1: Energy Levels of Lanthanides
+
+The matrices can be used for the fit of lanthanide energy levels to measured absorption spectra resulting in radial
+integrals and the coefficients of all states in intermediate coupling.
+For crystalline materials these calculations can take full advantage of all spectral lines using the even-rank unit
+tensor operators for modelling the crystal-field splitting.
+This includes the mixing of states with different $J$ quantum number.
+For amorphous materials the calculations can take advantage of the effective rotational site symmetry which allows to
+perform them in a reduced $SLJ$ space with much smaller matrices.
+
+## Application 2: Transition Intensities of Lanthanides
+
+Based on radial integrals from the literature or own energy-level fits, the coefficients of all states in intermediate
+coupling can be determined as linear combination of $LS$-states.
+This makes the generation of all reduced matrix elements for Judd-Ofelt calculations a simple task.
+While the Judd-Ofelt theory is standard to predict the radiative intensities of every emission and absorption
+transition from measured absorption spectra in amorphous hosts, it is not intended for crystalline hosts.
+The AMELI repository contains all matrices for the Crystal Field Intensity (CFI) method instead, which uses the same
+mathematical procedure as Judd-Ofelt, but with a larger set of parameters reflecting the richer structure of 
+crystalline spectra.
+Based on odd-rank unit tensor operators the electric dipole operators for any site-symmetry can be modelled in
+addition to the magnetic dipole operator, which is the same for amorphous and crystalline materials.
+
+## Package Structure
+
+The main code of the AMELI package is contained in the folder `ameli`.
+The script `generate.py` in the folder `generate` is used to calculate the full set of matrices for all lanthanide
+configurations.
+Due to the exact arithmetic this is a time-consuming process.
+Even though the script builds a dependency graph and schedules the computation tasks to all available CPU cores, it
+takes several days to finish.
+The folder `test`contains a set of test scripts orchestrated by the main script `test.py` which perform a large number
+of mathematical tests and comparisons to values published in printed literature.
+Its subfolder `results` contains the results from a test run and the subfolder `tables` contains the script used to
+extract the comparison tables in the AMELI paper from the test results.
+The folder `upload` is for documentation only.
+It contains the scripts used to upload and update the matrix datasets on the Zenodo repository.

ameli-1.2.0/pyproject.toml

@@ -0,0 +1,41 @@
+# pyproject.toml
+[build-system]
+requires = [
+    "setuptools",
+    "wheel",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "AMELI"
+version = "1.2.0"
+authors = [
+    { name = "Reinhard Caspary", email = "reinhard.caspary@phoenixd.uni-hannover.de"},
+]
+description = "Python 3 package to calculate angular matrix elements of lanthanide ions."
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+	"h5py == 3.15.1",
+    "numpy == 2.4.2",
+    "scidatacontainer == 1.2.0",
+    "sympy == 1.14.0",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+
+[project.urls]
+Homepage = "https://github.com/reincas/AMELI"
+Issues = "https://github.com/reincas/AMELI/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

ameli-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ameli-1.2.0/setup.py

@@ -0,0 +1,3 @@
+import setuptools
+
+setuptools.setup()

ameli-1.2.0/src/AMELI.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: AMELI
+Version: 1.2.0
+Summary: Python 3 package to calculate angular matrix elements of lanthanide ions.
+Author-email: Reinhard Caspary <reinhard.caspary@phoenixd.uni-hannover.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/reincas/AMELI
+Project-URL: Issues, https://github.com/reincas/AMELI/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: h5py==3.15.1
+Requires-Dist: numpy==2.4.2
+Requires-Dist: scidatacontainer==1.2.0
+Requires-Dist: sympy==1.14.0
+Dynamic: license-file
+
+# AMELI 1.2.0 (Angular Matrix Elements of Lanthanide Ions)
+
+This is a Python 3 package to calculate the angular matrix elements of spherical tensor operators of lanthanide ions
+in exact arithmetic using SymPy.
+Each matrix element is stored as signed square root of a rational number.
+The basic functions support any many-electron configuration, but the implementation of most high-level operators is
+specific for single-shell systems like the lanthanide ions. 
+
+The main purpose of this software is the preparation of the comprehensive matrix datasets in the
+[AMELI repository](https://zenodo.org/communities/ameli) on Zenodo.
+Each lanthanide dataset for the configurations $f^1$ to $f^{13}$ contains unit tensor operators, angular momentum
+operators and perturbation Hamiltonians.
+All relevant perturbation operators are provided in first order (Coulomb, spin-orbit, spin-spin, spin-other-orbit) and
+in second order (Coulomb, electrostatic spin-orbit).
+
+The AMELI matrix datasets are intended as replacements for the printed and incomplete tables published mainly by
+B. R. Judd, W. T. Carnall, C. W. Nielson, and G. F. Koster on the 1960s and 1970s.
+In particular they are intended to replace all tables of reduced unit tensor matrix elements in intermediate coupling
+still used for Judd-Ofelt calculations.
+Such calculations should instead be based on a set of radial integrals serving as linear expansion coefficients for the
+operator matrices.
+
+## Documentation
+
+A paper on the mathematical background of AMELI, its workflow, and a detailed comparison of the resulting tensor
+matrices to the literature is ready and will be submitted to arXiv and a scientific journal very soon.  
+
+## General Remarks
+
+All angular matrices of a given electron configuration are constants and need to be calculated only once. 
+This software package therefore is intended mainly as reference.
+Instead of integrating AMELI code into your own project, you should use the matrices from the AMELI repository on
+Zenodo.
+A reference implementation will be provided by the [Lanthanide](https://github.com/reincas/Lanthanide) package,
+which will soon be switching from self-generated matrices to AMELI.
+
+AMELI calculates operator matrices in the product state space together with a transformation matrix to $LS$-coupling
+in exact arithmetic.
+All characteristic eigenvalues and irreducible representations for each state are provided.
+Global signs are synchronized for states inside each $J$-multiplet.
+This allows to use reduced matrices for intermediate coupling in amorphous materials.
+
+All matrices and other intermediate calculation results are stored as
+[SciDataContainer](https://scidatacontainer.readthedocs.io) files enriched with plenty of meta data and descriptions.
+Following the [FAIR data principles](https://en.wikipedia.org/wiki/FAIR_data) of research data management the container
+content is easily accessible to humans and machines.
+A Python implementation is available, but not necessary, because a SciDataContainer file is just a ZIP folder.
+AMELI containers consist only of JSON files for the meta data and HDF5 files for the numerical data.
+
+## Application 1: Energy Levels of Lanthanides
+
+The matrices can be used for the fit of lanthanide energy levels to measured absorption spectra resulting in radial
+integrals and the coefficients of all states in intermediate coupling.
+For crystalline materials these calculations can take full advantage of all spectral lines using the even-rank unit
+tensor operators for modelling the crystal-field splitting.
+This includes the mixing of states with different $J$ quantum number.
+For amorphous materials the calculations can take advantage of the effective rotational site symmetry which allows to
+perform them in a reduced $SLJ$ space with much smaller matrices.
+
+## Application 2: Transition Intensities of Lanthanides
+
+Based on radial integrals from the literature or own energy-level fits, the coefficients of all states in intermediate
+coupling can be determined as linear combination of $LS$-states.
+This makes the generation of all reduced matrix elements for Judd-Ofelt calculations a simple task.
+While the Judd-Ofelt theory is standard to predict the radiative intensities of every emission and absorption
+transition from measured absorption spectra in amorphous hosts, it is not intended for crystalline hosts.
+The AMELI repository contains all matrices for the Crystal Field Intensity (CFI) method instead, which uses the same
+mathematical procedure as Judd-Ofelt, but with a larger set of parameters reflecting the richer structure of 
+crystalline spectra.
+Based on odd-rank unit tensor operators the electric dipole operators for any site-symmetry can be modelled in
+addition to the magnetic dipole operator, which is the same for amorphous and crystalline materials.
+
+## Package Structure
+
+The main code of the AMELI package is contained in the folder `ameli`.
+The script `generate.py` in the folder `generate` is used to calculate the full set of matrices for all lanthanide
+configurations.
+Due to the exact arithmetic this is a time-consuming process.
+Even though the script builds a dependency graph and schedules the computation tasks to all available CPU cores, it
+takes several days to finish.
+The folder `test`contains a set of test scripts orchestrated by the main script `test.py` which perform a large number
+of mathematical tests and comparisons to values published in printed literature.
+Its subfolder `results` contains the results from a test run and the subfolder `tables` contains the script used to
+extract the comparison tables in the AMELI paper from the test results.
+The folder `upload` is for documentation only.
+It contains the scripts used to upload and update the matrix datasets on the Zenodo repository.

ameli-1.2.0/src/AMELI.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/AMELI.egg-info/PKG-INFO
+src/AMELI.egg-info/SOURCES.txt
+src/AMELI.egg-info/dependency_links.txt
+src/AMELI.egg-info/requires.txt
+src/AMELI.egg-info/top_level.txt
+src/ameli/__init__.py
+src/ameli/casimir.py
+src/ameli/config.py
+src/ameli/matrix.py
+src/ameli/product.py
+src/ameli/sparse.py
+src/ameli/states.py
+src/ameli/transform.py
+src/ameli/uintarray.py
+src/ameli/unit.py
+src/ameli/vault.py
+test/test.py
+test/test_01_orthonormal.py
+test/test_02_transform.py
+test/test_03_states.py
+test/test_04_screen.py
+test/test_05_triple.py
+test/test_06_magnetic.py
+test/test_07_energy.py

ameli-1.2.0/src/AMELI.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ameli-1.2.0/src/AMELI.egg-info/requires.txt

@@ -0,0 +1,4 @@
+h5py==3.15.1
+numpy==2.4.2
+scidatacontainer==1.2.0
+sympy==1.14.0

ameli-1.2.0/src/AMELI.egg-info/top_level.txt

@@ -0,0 +1 @@
+ameli

ameli-1.2.0/src/ameli/__init__.py

@@ -0,0 +1,35 @@
+##########################################################################
+# Copyright (c) 2025-2026 Reinhard Caspary                               #
+# <reinhard.caspary@phoenixd.uni-hannover.de>                            #
+# This program is free software under the terms of the MIT license.      #
+##########################################################################
+
+import re
+from functools import lru_cache
+from sympy.physics.wigner import wigner_3j
+
+
+def desc_format(description, kwargs):
+    """ Basic transformation for metadata description strings. """
+
+    desc = str(description)
+    desc = re.sub(r"\s*\n\s*", " ", desc)
+    desc = re.sub(r"\s*<br>\s*", "\n", desc)
+    desc = desc.strip()
+    desc = desc.format(**kwargs)
+    return desc
+
+
+@lru_cache(maxsize=100000)
+def sym3j(j1, j2, j3, m1, m2, m3):
+    """ Return the exact symbolic value of the Wigner 3j-symbol. The given arguments of the 3j-symbol must be integers
+    or SymPy half-integer expressions. The results of this method are cached. """
+
+    return wigner_3j(j1, j2, j3, m1, m2, m3)
+
+
+from .config import SPECTRAL, Electron, Config
+from .product import Product
+from .unit import Unit
+from .matrix import Matrix
+from .transform import Transform

ameli-1.2.0/src/ameli/casimir.py

@@ -0,0 +1,119 @@
+##########################################################################
+# Copyright (c) 2025-2026 Reinhard Caspary                               #
+# <reinhard.caspary@phoenixd.uni-hannover.de>                            #
+# This program is free software under the terms of the MIT license.      #
+##########################################################################
+#
+# This internal module provides the static dictionary CASIMIR, with three
+# Casimir objects storing eigenvalues and irreducible representations
+# of the Casimir operators for the special orthogonal (rotational)
+# groups SO(5) and SO(7) and the special group G_2. Each Casimir object
+# translates between SymPy eigenvalues and irreducible representation
+# strings of the respective operators.
+#
+##########################################################################
+
+import sympy as sp
+
+
+class Casimir:
+    """ Translation class for a Casimir operator. """
+
+    # Dictionary with irreducible representations as keys and eigenvalues as values
+    values = {}
+
+    # Dictionary with eigenvalues as keys and irreducible representations as values
+    keys = {}
+
+    def key(self, value: sp.Expr) -> str:
+        """ Return the irreducible representation string of the given SymPy eigenvalue. """
+
+        if value not in self.keys:
+            raise ValueError(f"Unknown value {value}!")
+        return self.keys[value]
+
+    def value(self, key: str) -> sp.Expr:
+        """ Return the SymPy eigenvalue of the given irreducible representation string. """
+        if key not in self.values:
+            raise ValueError(f"Unknown key {key}!")
+        return self.values[key]
+
+
+class CasimirRot(Casimir):
+    """ Translation class for the Casimir operator of the special orthogonal (rotational) group SO(2l+1)
+    in 2l+1 dimensions, with l = 1, 2, or 3. """
+
+    def __init__(self, l):
+        """ Calculate the SymPy eigenvalues of all irreducible representation strings of the Casimir operator. """
+
+        self.l = l
+        assert 1 <= l <= 3
+
+        self.values = {}
+        self.keys = {}
+        for key in self.elements():
+            value = self.evaluate(key)
+            self.values[key] = value
+            self.keys[value] = key
+
+    def evaluate(self, w: str) -> sp.Expr:
+        """ Return the SymPy eigenvalue of the given irreducible representation string. """
+
+        assert w.startswith("(") and w.endswith(")")
+        w = tuple(map(int, w[1:-1]))
+        assert self.l == len(w)
+        value = 0
+        for i, wi in enumerate(w):
+            value += wi * (wi + 2 * self.l - 1 - 2 * i)
+        return sp.S(value) / (2 * (2 * self.l - 1))
+
+    def elements(self, values=None):
+        """ Recursive generator of all irreducible representation strings of the Casimir operator. """
+
+        if values is None:
+            values = []
+            max_num = self.l
+        else:
+            max_num = values[-1] + 1
+        for num in range(max_num):
+            result = values + [num]
+            if len(values) < self.l - 1:
+                yield from self.elements(result)
+            else:
+                yield "(" + "".join(map(str, result)) + ")"
+
+
+class CasimirSpecial(Casimir):
+    """ Translation class for the Casimir operator of the special orthogonal (rotational) group G_2. """
+
+    def __init__(self):
+        """ Calculate the SymPy eigenvalues of all irreducible representation strings of the Casimir operator. """
+
+        self.values = {}
+        self.keys = {}
+        for key in self.elements():
+            value = self.evaluate(key)
+            self.values[key] = value
+            self.keys[value] = key
+
+    def evaluate(self, u: str) -> sp.Expr:
+        """ Return the SymPy eigenvalue of the given irreducible representation string. """
+
+        assert u.startswith("(") and u.endswith(")")
+        u = tuple(map(int, u[1:-1]))
+        assert len(u) == 2
+        value = u[0] * u[0] + u[1] * u[1] + u[0] * u[1] + 5 * u[0] + 4 * u[1]
+        return sp.S(value) / 12
+
+    def elements(self):
+        """ Recursive generator of all irreducible representation strings of the Casimir operator. """
+
+        for i in range(5):
+            for j in range(i + 1):
+                u = (i, j)
+                yield "(" + "".join(map(str, u)) + ")"
+
+
+# Export three Casimir translator objects for the Casimir operators for the special orthogonal rotational groups
+# SO(5) and SO(7) and the special group G_2
+CASIMIR = {"SO7": CasimirRot(l=3), "SO5": CasimirRot(l=2), "G2": CasimirSpecial()}