TB2J 0.9.9rc5__tar.gz → 0.9.9rc7__tar.gz

tb2j-0.9.9rc7/.github/workflows/pylint.yml.bak

@@ -0,0 +1,23 @@
+name: Pylint
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pylint
+    - name: Analysing the code with pylint
+      run: |
+        pylint $(git ls-files '*.py')

tb2j-0.9.9rc7/.github/workflows/python-app.yml

@@ -0,0 +1,44 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python application
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        #pytest
+        #  - pwd
+        python -m pip install . 
+        cd examples/abinit-w90/SrMnO3
+        ls -lah
+        sh get_J.sh
+        cd TB2J_results/Multibinit
+        TB2J_magnon.py --figfname magnon.png

tb2j-0.9.9rc7/.gitignore

@@ -0,0 +1,131 @@
+doc/refs/*.pdf
+
+
+*.swp
+
+# Latex 
+*.aux
+
+# xyz files
+
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# numpy results
+*.npy
+
+# png files
+
+# C extensions
+*.so
+*.a
+
+# Fortran extensions
+*.fpp
+*.mod
+*.o
+
+# F90wrap files
+*.plist
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+*.egg-info/*
+.installed.cfg
+*.egg
+
+# temporary files
+temp/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/

tb2j-0.9.9rc7/.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+repos:
+-   repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.3.5
+    hooks:
+      # Run the linter.
+      - id: ruff
+        # --select I sorts imports
+        args: [ --fix, --extend-select, I  ]
+      # Run the formatter.
+      - id: ruff-format

tb2j-0.9.9rc7/.readthedocs.yml

@@ -0,0 +1,28 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+build:
+  os: "ubuntu-22.04"
+  tools:
+    python: "3.11"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+# Build documentation with MkDocs
+#mkdocs:
+#  configuration: mkdocs.yml
+
+# Optionally build your docs in additional formats such as PDF
+formats:
+  - pdf
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  install:
+    - requirements: requirements.txt
+    - requirements: docs/requirements.txt

tb2j-0.9.9rc7/.ruff.toml

@@ -0,0 +1,78 @@
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 88
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py38"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F"]
+ignore = ["E741"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+

tb2j-0.9.9rc7/.travis.yml

@@ -0,0 +1,33 @@
+language: python
+python:
+  - "3.7"
+  - "3.8"
+  - "3.9"
+  - "3.10"
+  - "3.11"
+cache: pip
+
+addons:
+  apt:
+    packages: &common_packages
+      - gfortran
+      - libatlas-base-dev
+      - liblapack-dev
+      - libnetcdf-dev
+      - libnetcdff-dev
+      - eatmydata
+      - ccache
+before_install:
+ - if [[ $TRAVIS_PYTHON_VERSION == 3.7 ]]; then pip install -U importlib_metadata; fi
+
+install:
+  - pip install -r requirements.txt
+  - pip install sisl
+  - pip install -e .
+script:
+  - pwd
+  - cd examples/abinit-w90/SrMnO3
+  - ls -lah
+  - sh get_J.sh
+  - cd TB2J_results/Multibinit
+  - TB2J_magnon.py --figfname magnon.png

{tb2j-0.9.9rc5 → tb2j-0.9.9rc7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc5
+Version: 0.9.9rc7
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -24,5 +24,14 @@ Requires-Dist: packaging>=20.0
 Requires-Dist: HamiltonIO>=0.1.9
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 TB2J is a Python package aimed to compute automatically the magnetic interactions (superexchange  and Dzyaloshinskii-Moriya) between atoms of magnetic crystals from DFT Hamiltonian based on Wannier functions or Linear combination of atomic orbitals. It uses the Green's function method and take the local rigid spin rotation as a perturbation. The package can take the output from Wannier90, which is interfaced with many density functional theory codes or from codes based on localised orbitals. A minimal user input is needed, which allows for an easily integration into a high-throughput workflows. 

tb2j-0.9.9rc7/TB2J/.gitignore

@@ -0,0 +1,5 @@
+*.o
+*.x
+*.mod
+exchanges.sublime-project
+exchanges.sublime-workspace

{tb2j-0.9.9rc5 → tb2j-0.9.9rc7}/TB2J/Jdownfolder.py

@@ -1,7 +1,9 @@
 import os
 from collections import defaultdict
+
 import numpy as np
 from ase.dft.kpoints import monkhorst_pack
+
 from TB2J.io_exchange import SpinIO
 from TB2J.Jtensor import decompose_J_tensor
 
@@ -73,8 +75,8 @@ class JDownfolder:
 class PWFDownfolder:
     def __init__(self, JR, Rlist, iM, iL, qmesh, atoms=None, iso_only=False, **kwargs):
         from lawaf.interfaces.magnon.magnon_downfolder import (
-            MagnonWrapper,
             MagnonDownfolder,
+            MagnonWrapper,
         )
 
         model = MagnonWrapper(JR, Rlist, atoms)
@@ -92,13 +94,13 @@ class PWFDownfolder:
             # anchors={(0, 0, 0): (-1, -2, -3, -4)},
             # anchors={(0, 0, 0): ()},
             # use_proj=True,
-            enhance_Amn=2.0,
+            enhance_Amn=0.0,
         )
         params.update(kwargs)
         wann.set_parameters(**params)
         print("begin downfold")
         ewf = wann.downfold()
-        ewf.save_hr_pickle("downfolded_JR.pickle")
+        # ewf.save_hr_pickle("downfolded_JR.pickle")
 
         # Plot the band structure.
         wann.plot_band_fitting(
@@ -135,7 +137,7 @@ class JDownfolder_pickle:
         qmesh=[7, 7, 7],
         iso_only=False,
         method="pwf",
-        **kwargs
+        **kwargs,
     ):
         self.exc = SpinIO.load_pickle(path=inpath, fname="TB2J.pickle")
 
@@ -193,7 +195,7 @@ class JDownfolder_pickle:
                 qmesh=self.qmesh,
                 atoms=self.atoms,
                 iso_only=self.iso_only,
-                **kwargs
+                **kwargs,
             )
             Jd, Rlist = d.get_JR()
         return Jd, Rlist
@@ -274,10 +276,10 @@ class JDownfolder_pickle:
 def test():
     # pass
     # inpath = "/home/hexu/projects/NiCl2/vasp_inputs/TB2J_results"
-    # inpath = "/home/hexu/projects/TB2J_example/CrI3/TB2J_results"
-    inpath = "/home/hexu/projects/TB2J_projects/NiCl2/TB2J_NiCl/TB2J_results"
-    fname = os.path.join(inpath, "TB2J.pickle")
-    p = JDownfolder_pickle(
+    inpath = "/home/hexu/projects/TB2J_example/CrI3/TB2J_results"
+    # inpath = "/home/hexu/projects/TB2J_projects/NiCl2/TB2J_NiCl/TB2J_results"
+    _fname = os.path.join(inpath, "TB2J.pickle")
+    _p = JDownfolder_pickle(
         inpath=inpath, metals=["Ni"], ligands=["Cl"], outpath="TB2J_results_downfolded"
     )
 

{tb2j-0.9.9rc5 → tb2j-0.9.9rc7}/TB2J/MAEGreen.py

@@ -1,12 +1,17 @@
+import gc
 from pathlib import Path
 
+import matplotlib.pyplot as plt
 import numpy as np
 import tqdm
 from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
 from HamiltonIO.model.occupations import GaussOccupations
 from typing_extensions import DefaultDict
 
+from TB2J.anisotropy import Anisotropy
 from TB2J.exchange import ExchangeNCL
+from TB2J.external import p_map
+from TB2J.mathutils.fibonacci_sphere import fibonacci_semisphere
 
 # from HamiltonIO.model.rotate_spin import rotate_Matrix_from_z_to_axis, rotate_Matrix_from_z_to_sperical
 # from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
@@ -22,12 +27,21 @@ def get_occupation(evals, kweights, nel, width=0.1):
 
 class MAEGreen(ExchangeNCL):
     def __init__(self, angles=None, **kwargs):
+        """
+        angles are defined as theta, phi pairs, where theta is the angle between the z-axis and the magnetization direction, and phi is the angle between the x-axis and the projection of the magnetization direction on the x-y plane.
+        """
         super().__init__(**kwargs)
         self.natoms = len(self.atoms)
         if angles is None or angles == "axis":
             self.set_angles_axis()
         elif angles == "scan":
             self.set_angles_scan()
+        elif angles == "fib":
+            self.set_angles_fib()
+        elif angles == "random":
+            self.set_angles_random()
+        elif angles == "miller":
+            self.set_angles_miller()
         else:
             self.thetas = angles[0]
             self.phis = angles[1]
@@ -38,9 +52,32 @@ class MAEGreen(ExchangeNCL):
         self.es_atom_orb = DefaultDict(lambda: 0)
 
     def set_angles_axis(self):
-        """theta and phi are defined as the x, y, z, axis."""
-        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2, np.pi]
-        self.phis = [0, 0, np.pi / 2, np.pi / 4, 0]
+        """theta and phi are defined as the x, y, z, xy, yz, xz, xyz, x-yz, -xyz, -x-yz axis."""
+        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2, np.pi, 0, np.pi / 2, 0, 0, 0]
+        self.phis = [0, 0, np.pi / 2, np.pi / 4, 0, 0, 0, np.pi]
+
+    def set_angles_miller(self, nmax=2):
+        """theta and angles corresponding to the miller index. remove duplicates.
+        e.g. 002 and 001 are the same.
+        """
+        thetas = []
+        phis = []
+        for k in range(0, nmax + 1):
+            for j in range(-nmax, nmax + 1):
+                for i in range(-nmax, nmax + 1):
+                    if i == 0 and j == 0 and k == 0:
+                        continue
+                    thetas.append(np.arccos(k / np.sqrt(i**2 + j**2 + k**2)))
+                    if i == 0 and j == 0:
+                        phis.append(0)
+                    else:
+                        phis.append(np.arctan2(j, i))
+        self.thetas = thetas
+        self.phis = phis
+        self.angle_pairs = list(zip(thetas, phis))
+        # remove duplicates of angles using sets.
+        self.angle_pairs = list(set(self.angle_pairs))
+        self.thetas, self.phis = zip(*self.angle_pairs)
 
     def set_angles_scan(self, step=15):
         self.thetas = []
@@ -50,6 +87,21 @@ class MAEGreen(ExchangeNCL):
                 self.thetas.append(i * np.pi / 180)
                 self.phis.append(j * np.pi / 180)
 
+    def set_angles_random(self, n=16):
+        # n random pairs of theta, phi
+        self.thetas = np.random.random(n) * np.pi
+        self.phis = np.random.random(n) * 2 * np.pi
+
+    def set_angles_fib(self, n=35):
+        self.thetas, self.phis = fibonacci_semisphere(n)
+        # thetas and phis are np.array
+        # add (theta, phi): (pi/2, pi/2) and (pi/2, pi/4)
+        # self.thetas += [np.pi / 2, np.pi / 2]
+        # self.phis += [np.pi / 2, np.pi / 4]
+        for i in range(8):
+            self.thetas = np.concatenate([self.thetas, [np.pi / 2]])
+            self.phis = np.concatenate([self.phis, [np.pi * i / 8]])
+
     def get_band_energy_vs_angles_from_eigen(
         self,
         thetas,
@@ -78,6 +130,13 @@ class MAEGreen(ExchangeNCL):
 
     def get_perturbed(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
+        # maxsoc = self.tbmodel.get_max_Hsoc_abs()
+        # maxH0 = self.tbmodel.get_max_H0_spin_abs()
+        # if maxsoc > maxH0 * 0.01:
+        #    print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+        #          comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+        #          The SOC is too strong, the perturbation theory may not be valid.""")
+
         G0K = self.G.get_Gk_all(e)
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
         na = len(thetas)
@@ -92,12 +151,12 @@ class MAEGreen(ExchangeNCL):
                 GdH = G0K[ik] @ dHi
                 # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
                 # diagonal of second order perturbation.
-                dG2diag = np.diag(GdH @ GdH)
+                # dG2diag = np.diag(GdH @ GdH)
                 # dG2 = np.einsum("ij,ji->ij", GdH,   GdH)
                 dG2 = GdH * GdH.T
                 dG2sum = np.sum(dG2)
                 # print(f"dG2sum-sum: {dG2sum}")
-                dG2sum = np.sum(dG2diag)
+                # dG2sum = np.sum(dG2diag)
 
                 # dG2sum = np.trace(GdH @ GdH)
                 # print(f"dG2sum-Tr: {dG2sum}")
@@ -118,13 +177,11 @@ class MAEGreen(ExchangeNCL):
                         + dE_atom_orb[1::2, ::2]
                         + dE_atom_orb[::2, 1::2]
                     )
+                    dE_atom = np.sum(dE_atom_orb)
                     mmat = self.mmats[iatom]
                     dE_atom_orb = mmat.T @ dE_atom_orb @ mmat
-
                     dE_angle_atom_orb[(iangle, iatom)] += dE_atom_orb
-
-                    dE_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
-                    # dE_atom = np.sum(dE_atom_orb)
+                    # dE_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
                     dE_angle_atom[iangle, iatom] += dE_atom
         return dE_angle, dE_angle_atom, dE_angle_atom_orb
 
@@ -143,15 +200,33 @@ class MAEGreen(ExchangeNCL):
         if with_eigen:
             self.es2 = self.get_band_energy_vs_angles_from_eigen(thetas, phis)
 
-        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
-            dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
-                e, thetas, phis
-            )
-            self.es += dE_angle * self.contour.weights[ie]
-            self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        # for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
+        #    dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
+        #        e, thetas, phis
+        #    )
+        #    self.es += dE_angle * self.contour.weights[ie]
+        #    self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        #    for key, value in dE_angle_atom_orb.items():
+        #        self.es_atom_orb[key] += (
+        #            dE_angle_atom_orb[key] * self.contour.weights[ie]
+        #        )
+
+        # rewrite the for loop above to use p_map
+        def func(e):
+            return self.get_perturbed(e, thetas, phis)
+
+        if self.nproc > 1:
+            results = p_map(func, self.contour.path, num_cpus=self.nproc)
+        else:
+            npole = len(self.contour.path)
+            results = map(func, tqdm.tqdm(self.contour.path, total=npole))
+        for i, result in enumerate(results):
+            dE_angle, dE_angle_atom, dE_angle_atom_orb = result
+            self.es += dE_angle * self.contour.weights[i]
+            self.es_atom += dE_angle_atom * self.contour.weights[i]
             for key, value in dE_angle_atom_orb.items():
                 self.es_atom_orb[key] += (
-                    dE_angle_atom_orb[key] * self.contour.weights[ie]
+                    dE_angle_atom_orb[key] * self.contour.weights[i]
                 )
 
         self.es = -np.imag(self.es) / (2 * np.pi)
@@ -159,10 +234,25 @@ class MAEGreen(ExchangeNCL):
         for key, value in self.es_atom_orb.items():
             self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
-    def output(self, output_path="TB2J_anisotropy", with_eigen=True):
+    def fit_anisotropy_tensor(self):
+        self.ani = Anisotropy.fit_from_data(self.thetas, self.phis, self.es)
+        return self.ani
+
+    def output(
+        self,
+        output_path="TB2J_anisotropy",
+        with_eigen=True,
+        figure3d="MAE_3d.png",
+        figure_contourf="MAE_contourf.png",
+    ):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
+        fname_tensor = f"{output_path}/MAE_tensor.dat"
+        if figure3d is not None:
+            fname_fig3d = f"{output_path}/{figure3d}"
+        if figure_contourf is not None:
+            fname_figcontourf = f"{output_path}/{figure_contourf}"
 
         # ouput with eigenvalues.
         if with_eigen:
@@ -178,15 +268,29 @@ class MAEGreen(ExchangeNCL):
                     f.write("\n")
 
         with open(fname, "w") as f:
-            f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
+            f.write("# theta (rad), phi(rad), MAE(total), MAE(atom-wise) Unit: meV\n")
             for i, (theta, phi, e, es) in enumerate(
                 zip(self.thetas, self.phis, self.es, self.es_atom)
             ):
-                f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f} ")
+                f.write(f"{theta%np.pi:.5f} {phi%(2*np.pi):.5f} {e*1e3:.8f} ")
                 for ea in es:
                     f.write(f"{ea*1e3:.8f} ")
                 f.write("\n")
 
+        self.ani = self.fit_anisotropy_tensor()
+        with open(fname_tensor, "w") as f:
+            f.write("# Anisotropy tensor in meV\n")
+            f.write(f"{self.ani.tensor_strings(include_isotropic=False)}\n")
+
+        if figure3d is not None:
+            self.ani.plot_3d(figname=fname_fig3d, show=False)
+
+        if figure_contourf is not None:
+            self.ani.plot_contourf(figname=fname_figcontourf, show=False)
+
+        plt.close()
+        gc.collect()
+
         with open(fname_orb, "w") as f:
             f.write("=" * 80 + "\n")
             f.write("Orbitals for each atom: \n")