qupled 1.0.0__tar.gz → 1.0.1__tar.gz

qupled-1.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: qupled
+Version: 1.0.1
+Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
+Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown

{qupled-1.0.0 → qupled-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qupled"
-version = "1.0.0"
+version = "1.0.1"
 description = "qupled: a package to investigate quantum plasmas via the dielectric formalism"
 readme = "README.md"
 requires-python = ">=3.10, <3.13"

qupled-1.0.1/src/qupled.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: qupled
+Version: 1.0.1
+Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
+Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown

qupled-1.0.1/src/qupled.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+pyproject.toml
+src/qupled.egg-info/PKG-INFO
+src/qupled.egg-info/SOURCES.txt
+src/qupled.egg-info/dependency_links.txt
+src/qupled.egg-info/top_level.txt
+tests/test_esa.py
+tests/test_esa_native.py
+tests/test_examples.py
+tests/test_hdf.py
+tests/test_plot.py
+tests/test_qstls.py
+tests/test_qstls_iet.py
+tests/test_qstls_input.py
+tests/test_qstls_native.py
+tests/test_qvs.py
+tests/test_qvs_input.py
+tests/test_qvs_native.py
+tests/test_rpa.py
+tests/test_rpa_input.py
+tests/test_rpa_native.py
+tests/test_stls.py
+tests/test_stls_iet.py
+tests/test_stls_input.py
+tests/test_stls_native.py
+tests/test_vsstls.py
+tests/test_vsstls_input.py
+tests/test_vsstls_native.py

qupled-1.0.1/src/qupled.egg-info/top_level.txt

@@ -0,0 +1 @@
+CMakeFiles

qupled-1.0.1/tests/test_esa.py

@@ -0,0 +1,31 @@
+import os
+import pytest
+from qupled.classic import ESA
+
+
+@pytest.fixture
+def esa():
+    return ESA()
+
+
+@pytest.fixture
+def esa_input():
+    return ESA.Input(1.0, 1.0)
+
+
+def test_default(esa):
+    assert esa.hdfFileName == None
+
+
+def test_compute(esa, esa_input, mocker):
+    mockMPITime = mocker.patch("qupled.util.MPI.timer", return_value=0)
+    mockMPIBarrier = mocker.patch("qupled.util.MPI.barrier")
+    mockCompute = mocker.patch("qupled.qupled.ESA.compute")
+    mockCheckStatusAndClean = mocker.patch("qupled.classic.ESA._checkStatusAndClean")
+    mockSave = mocker.patch("qupled.classic.ESA._save")
+    esa.compute(esa_input)
+    assert mockMPITime.call_count == 2
+    assert mockMPIBarrier.call_count == 1
+    assert mockCompute.call_count == 1
+    assert mockCheckStatusAndClean.call_count == 1
+    assert mockSave.call_count == 1

qupled-1.0.1/tests/test_esa_native.py

@@ -0,0 +1,43 @@
+import os
+import pytest
+import qupled.qupled as qp
+
+
+def test_esa_properties():
+    assert issubclass(qp.ESA, qp.Rpa)
+    scheme = qp.ESA(qp.RpaInput())
+    assert hasattr(scheme, "idr")
+    assert hasattr(scheme, "sdr")
+    assert hasattr(scheme, "slfc")
+    assert hasattr(scheme, "ssf")
+    assert hasattr(scheme, "ssfHF")
+    with pytest.raises(RuntimeError) as excinfo:
+        hasattr(scheme, "uInt")
+    assert excinfo.value.args[0] == "No data to compute the internal energy"
+    assert hasattr(scheme, "wvg")
+    assert hasattr(scheme, "recovery")
+
+
+def test_esa_compute():
+    inputs = qp.RpaInput()
+    inputs.coupling = 1.0
+    inputs.degeneracy = 1.0
+    inputs.theory = "RPA"
+    inputs.chemicalPotential = [-10, 10]
+    inputs.cutoff = 10.0
+    inputs.matsubara = 128
+    inputs.resolution = 0.1
+    inputs.intError = 1.0e-5
+    inputs.threads = 1
+    scheme = qp.ESA(inputs)
+    scheme.compute()
+    nx = scheme.wvg.size
+    assert nx >= 3
+    assert scheme.idr.shape[0] == nx
+    assert scheme.idr.shape[1] == inputs.matsubara
+    assert scheme.sdr.size == nx
+    assert scheme.slfc.size == nx
+    assert scheme.ssf.size == nx
+    assert scheme.ssfHF.size == nx
+    assert scheme.recovery == ""
+    assert scheme.rdf(scheme.wvg).size == nx

qupled-1.0.1/tests/test_examples.py

@@ -0,0 +1,79 @@
+import os
+import glob
+import importlib
+import pytest
+
+
+def cleanExampleFiles():
+    for fileExtension in ["h5", "bin", "zip"]:
+        fileNames = glob.glob("*." + fileExtension)
+        for fileName in fileNames:
+            os.remove(fileName)
+
+
+def runExample(exampleName, mocker):
+    try:
+        mockPlotShow = mocker.patch("matplotlib.pyplot.show")
+        importlib.import_module(exampleName)
+    finally:
+        cleanExampleFiles()
+
+
+def runExampleWithError(exampleName, mocker, expectedErrorMessage):
+    try:
+        mockPlotShow = mocker.patch("matplotlib.pyplot.show")
+        with pytest.raises(SystemExit) as excinfo:
+            importlib.import_module(exampleName)
+        assert excinfo.value.code == expectedErrorMessage
+    finally:
+        cleanExampleFiles()
+
+
+def test_fixedAdrQstls(mocker):
+    runExampleWithError(
+        "fixedAdrQstls", mocker, "Error while solving the dielectric theory"
+    )
+
+
+def test_fixedAdrQstlsIet(mocker):
+    runExample("fixedAdrQstlsIet", mocker)
+
+
+def test_fixedAdrQVSStls(mocker):
+    runExample("fixedAdrQVSStls", mocker)
+
+
+def test_initialGuessQstls(mocker):
+    runExample("initialGuessQstls", mocker)
+
+
+def test_initialGuessQstlsIet(mocker):
+    runExample("initialGuessQstlsIet", mocker)
+
+
+def test_initialGuessStls(mocker):
+    runExample("initialGuessStls", mocker)
+
+
+def test_solveQuantumSchemes(mocker):
+    runExample("solveQuantumSchemes", mocker)
+
+
+def test_solveQVSStls(mocker):
+    runExample("solveQVSStls", mocker)
+
+
+def test_solveRpaAndESA(mocker):
+    runExample("solveRpaAndESA", mocker)
+
+
+def test_solveStls(mocker):
+    runExample("solveStls", mocker)
+
+
+def test_solveStlsIet(mocker):
+    runExample("solveStlsIet", mocker)
+
+
+def test_solveVSStls(mocker):
+    runExample("solveVSStls", mocker)

qupled-1.0.1/tests/test_hdf.py

@@ -0,0 +1,172 @@
+import os
+import pytest
+import numpy as np
+import pandas as pd
+from qupled.util import Hdf
+
+
+@pytest.fixture
+def hdf_instance():
+    return Hdf()
+
+
+def mockOutput(hdfFileName):
+    data1D = np.zeros(2)
+    data2D = np.zeros((2, 2))
+    pd.DataFrame(
+        {
+            "coupling": 0.0,
+            "degeneracy": 0.0,
+            "error": 0.0,
+            "theory": "theory",
+            "resolution": 0.0,
+            "cutoff": 0,
+            "matsubara": 0,
+        },
+        index=["info"],
+    ).to_hdf(hdfFileName, key="info", mode="w")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="alpha")
+    pd.DataFrame(data2D).to_hdf(hdfFileName, key="adr")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="bf")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="fxcGrid")
+    pd.DataFrame(data2D).to_hdf(hdfFileName, key="fxci")
+    pd.DataFrame(data2D).to_hdf(hdfFileName, key="idr")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="rdf")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="rdfGrid")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="sdr")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="slfc")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="ssf")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="ssfHF")
+    pd.DataFrame(data1D).to_hdf(hdfFileName, key="wvg")
+
+
+def mockRdfOutput(hdfFileName):
+    wvgData = np.arange(0, 5, 0.1)
+    ssfData = np.ones(len(wvgData))
+    pd.DataFrame(
+        {
+            "coupling": 1.0,
+            "degeneracy": 1.0,
+            "error": 0.0,
+            "theory": "theory",
+            "resolution": 0.0,
+            "cutoff": 0,
+            "matsubara": 0,
+        },
+        index=["info"],
+    ).to_hdf(hdfFileName, key="info", mode="w")
+    pd.DataFrame(ssfData).to_hdf(hdfFileName, key="ssf")
+    pd.DataFrame(wvgData).to_hdf(hdfFileName, key="wvg")
+
+
+def test_set_entries(hdf_instance):
+    for key, entry in hdf_instance.entries.items():
+        if entry.entryType == "numpy":
+            value = np.array([1, 2, 3, 4])
+        elif entry.entryType == "numpy2D":
+            value = np.array([1, 2, 3, 4]).reshape((2, 2))
+        elif entry.entryType == "number":
+            value = 42
+        elif entry.entryType == "string":
+            value = "test_value"
+        else:
+            assert False
+
+        # Set value
+        hdf_instance.entries[key] = value
+
+
+def test_read(hdf_instance):
+    hdfFileName = "testOutput.h5"
+    mockOutput(hdfFileName)
+    allHdfEntries = hdf_instance.entries.keys()
+    readData = hdf_instance.read(hdfFileName, allHdfEntries)
+    try:
+        for entry in allHdfEntries:
+            if entry in [
+                "coupling",
+                "degeneracy",
+                "error",
+                "resolution",
+                "cutoff",
+                "matsubara",
+            ]:
+                assert readData[entry] == 0.0
+            elif entry in [
+                "bf",
+                "fxcGrid",
+                "rdf",
+                "rdfGrid",
+                "sdr",
+                "slfc",
+                "ssf",
+                "ssfHF",
+                "wvg",
+                "alpha",
+            ]:
+                assert np.array_equal(readData[entry], np.zeros(2))
+            elif entry in ["adr", "fxci", "idr"]:
+                assert np.array_equal(readData[entry], np.zeros((2, 2)))
+            elif entry in ["theory"]:
+                assert readData[entry] == "theory"
+            else:
+                assert False
+        with pytest.raises(SystemExit) as excinfo:
+            hdf_instance.read(hdfFileName, "dummyEntry")
+        assert excinfo.value.code == "Unknown entry"
+    finally:
+        os.remove(hdfFileName)
+
+
+def test_inspect(hdf_instance):
+    hdfFileName = "testOutput.h5"
+    mockOutput(hdfFileName)
+    allHdfEntries = hdf_instance.entries.keys()
+    inspectData = hdf_instance.inspect(hdfFileName)
+    try:
+        for entry in allHdfEntries:
+            assert entry in list(inspectData.keys())
+            assert inspectData[entry] == hdf_instance.entries[entry].description
+    finally:
+        os.remove(hdfFileName)
+
+
+def test_plot(hdf_instance, mocker):
+    hdfFileName = "testOutput.h5"
+    mockPlotShow = mocker.patch("matplotlib.pyplot.show")
+    mockOutput(hdfFileName)
+    toPlot = ["rdf", "adr", "idr", "fxci", "bf", "sdr", "slfc", "ssf", "ssfHF", "alpha"]
+    try:
+        hdf_instance.plot(hdfFileName, toPlot)
+        assert mockPlotShow.call_count == len(toPlot)
+        with pytest.raises(SystemExit) as excinfo:
+            hdf_instance.plot(hdfFileName, "dummyQuantityToPlot")
+        assert excinfo.value.code == "Unknown quantity to plot"
+    finally:
+        os.remove(hdfFileName)
+
+
+def test_computeRdf(hdf_instance):
+    hdfFileName = "testOutput.h5"
+    mockRdfOutput(hdfFileName)
+    try:
+        hdf_instance.computeRdf(hdfFileName, np.arange(0, 10, 0.1), False)
+        inspectData = hdf_instance.inspect(hdfFileName)
+        assert "rdf" not in list(inspectData.keys())
+        assert "rdfGrid" not in list(inspectData.keys())
+        hdf_instance.computeRdf(hdfFileName, np.arange(0, 10, 0.1), True)
+        inspectData = hdf_instance.inspect(hdfFileName)
+        assert "rdf" in list(inspectData.keys())
+        assert "rdfGrid" in list(inspectData.keys())
+    finally:
+        os.remove(hdfFileName)
+
+
+def test_computeInternalEnergy(hdf_instance):
+    hdfFileName = "testOutput.h5"
+    mockRdfOutput(hdfFileName)
+    try:
+        uint = hdf_instance.computeInternalEnergy(hdfFileName)
+        assert uint == 0.0
+    finally:
+        os.remove(hdfFileName)

qupled-1.0.1/tests/test_plot.py

@@ -0,0 +1,32 @@
+import os
+import pytest
+import numpy as np
+from qupled.util import Plot
+
+
+@pytest.fixture
+def plot_instance():
+    return Plot
+
+
+def test_plot1D(plot_instance, mocker):
+    mockPlotShow = mocker.patch("matplotlib.pyplot.show")
+    x = np.arange(0, 10, 0.1)
+    y = np.zeros(len(x))
+    plot_instance.plot1D(x, y, "x", "y")
+    assert mockPlotShow.call_count == 1
+
+
+def test_plot1DParametric(plot_instance, mocker):
+    mockPlotShow = mocker.patch("matplotlib.pyplot.show")
+    x = np.arange(0, 10, 0.1)
+    y = np.zeros((len(x), 2))
+    parameter = np.array([0, 1])
+    plot_instance.plot1DParametric(x, y, "x", "y", parameter)
+    assert mockPlotShow.call_count == 1
+    try:
+        parameter = np.array([1, 2])
+        plot_instance.plot1DParametric(x, y, "x", "y", parameter)
+        assert False
+    except:
+        assert mockPlotShow.call_count == 1

qupled-1.0.1/tests/test_qstls.py

@@ -0,0 +1,78 @@
+import os
+import pytest
+import numpy as np
+from qupled.qupled import Qstls as QstlsNative
+from qupled.util import Hdf
+from qupled.quantum import Qstls
+
+
+@pytest.fixture
+def qstls():
+    return Qstls()
+
+
+@pytest.fixture
+def qstls_input():
+    return Qstls.Input(1.0, 1.0)
+
+
+def test_default(qstls):
+    assert qstls.hdfFileName is None
+
+
+def test_compute(qstls, qstls_input, mocker):
+    mockMPITime = mocker.patch("qupled.util.MPI.timer", return_value=0)
+    mockMPIBarrier = mocker.patch("qupled.util.MPI.barrier")
+    mockCompute = mocker.patch("qupled.qupled.Qstls.compute")
+    mockCheckStatusAndClean = mocker.patch("qupled.quantum.Qstls._checkStatusAndClean")
+    mockSave = mocker.patch("qupled.quantum.Qstls._save")
+    qstls.compute(qstls_input)
+    assert mockMPITime.call_count == 2
+    assert mockMPIBarrier.call_count == 1
+    assert mockCompute.call_count == 1
+    assert mockCheckStatusAndClean.call_count == 1
+    assert mockSave.call_count == 1
+
+
+def test_save(qstls, qstls_input, mocker):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    try:
+        scheme = QstlsNative(qstls_input.toNative())
+        qstls.hdfFileName = qstls._getHdfFile(scheme.inputs)
+        qstls._save(scheme)
+        assert mockMPIIsRoot.call_count == 3
+        assert os.path.isfile(qstls.hdfFileName)
+        inspectData = Hdf().inspect(qstls.hdfFileName)
+        expectedEntries = [
+            "coupling",
+            "degeneracy",
+            "theory",
+            "error",
+            "resolution",
+            "cutoff",
+            "matsubara",
+            "adr",
+            "idr",
+            "sdr",
+            "slfc",
+            "ssf",
+            "ssfHF",
+            "wvg",
+        ]
+        for entry in expectedEntries:
+            assert entry in inspectData
+    finally:
+        os.remove(qstls.hdfFileName)
+
+
+def test_getInitialGuess(mocker):
+    arr = np.ones(10)
+    mockHdfRead = mocker.patch(
+        "qupled.util.Hdf.read",
+        return_value={"wvg": arr, "ssf": arr, "adr": arr, "matsubara": 10},
+    )
+    guess = Qstls.getInitialGuess("dummyFileName")
+    assert np.array_equal(guess.wvg, arr)
+    assert np.array_equal(guess.ssf, arr)
+    assert np.array_equal(guess.adr, arr)
+    assert np.array_equal(guess.matsubara, 10)

qupled-1.0.1/tests/test_qstls_iet.py

@@ -0,0 +1,124 @@
+import os
+import pytest
+import numpy as np
+from qupled.qupled import Qstls as QstlsNative
+from qupled.util import Hdf
+from qupled.quantum import QstlsIet
+
+
+@pytest.fixture
+def qstls_iet():
+    return QstlsIet()
+
+
+@pytest.fixture
+def qstls_iet_input():
+    return QstlsIet.Input(1.0, 1.0, "QSTLS-HNC")
+
+
+def test_default(qstls_iet):
+    assert qstls_iet.hdfFileName is None
+
+
+def test_compute(qstls_iet, qstls_iet_input, mocker):
+    mockMPITime = mocker.patch("qupled.util.MPI.timer", return_value=0)
+    mockMPIBarrier = mocker.patch("qupled.util.MPI.barrier")
+    mockUnpack = mocker.patch("qupled.quantum.QstlsIet._unpackFixedAdrFiles")
+    mockCompute = mocker.patch("qupled.quantum.QstlsIet._compute")
+    mockSave = mocker.patch("qupled.quantum.QstlsIet._save")
+    mockZip = mocker.patch("qupled.quantum.QstlsIet._zipFixedAdrFiles")
+    mockClean = mocker.patch("qupled.quantum.QstlsIet._cleanFixedAdrFiles")
+    qstls_iet.compute(qstls_iet_input)
+    assert mockMPITime.call_count == 2
+    assert mockMPIBarrier.call_count == 1
+    assert mockUnpack.call_count == 1
+    assert mockCompute.call_count == 1
+    assert mockSave.call_count == 1
+    assert mockZip.call_count == 1
+    assert mockClean.call_count == 1
+
+
+def test_unpackFixedAdrFiles_no_files(qstls_iet, qstls_iet_input, mocker):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    mockZip = mocker.patch("qupled.quantum.zf.ZipFile.__init__", return_value=None)
+    mockExtractAll = mocker.patch("qupled.quantum.zf.ZipFile.extractall")
+    qstls_iet._unpackFixedAdrFiles(qstls_iet_input)
+    assert mockMPIIsRoot.call_count == 1
+    assert mockZip.call_count == 0
+    assert mockExtractAll.call_count == 0
+
+
+def test_unpackFixedAdrFiles_with_files(qstls_iet, qstls_iet_input, mocker):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    mockZip = mocker.patch("qupled.quantum.zf.ZipFile.__init__", return_value=None)
+    mockExtractAll = mocker.patch("qupled.quantum.zf.ZipFile.extractall")
+    qstls_iet_input.fixediet = "testFile.zip"
+    qstls_iet._unpackFixedAdrFiles(qstls_iet_input)
+    assert mockMPIIsRoot.call_count == 1
+    assert mockZip.call_count == 1
+    assert mockExtractAll.call_count == 1
+
+
+def test_zipFixedAdrFiles_no_file(qstls_iet, qstls_iet_input, mocker, capsys):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    mockZip = mocker.patch("qupled.quantum.zf.ZipFile.__init__", return_value=None)
+    mockGlob = mocker.patch(
+        "qupled.quantum.glob", return_value={"binFile1", "binFile2"}
+    )
+    mockRemove = mocker.patch("os.remove")
+    mockWrite = mocker.patch("qupled.quantum.zf.ZipFile.write")
+    qstls_iet._zipFixedAdrFiles(qstls_iet_input)
+    assert mockMPIIsRoot.call_count == 1
+    assert mockZip.call_count == 1
+    assert mockGlob.call_count == 1
+    assert mockRemove.call_count == 2
+    assert mockWrite.call_count == 2
+
+
+def test_cleanFixedAdrFiles_no_files(qstls_iet, qstls_iet_input, mocker, capsys):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    mockRemove = mocker.patch("qupled.quantum.rmtree")
+    qstls_iet._cleanFixedAdrFiles(qstls_iet_input)
+    assert mockMPIIsRoot.call_count == 1
+    assert mockRemove.call_count == 0
+
+
+def test_cleanFixedAdrFiles_with_files(qstls_iet, qstls_iet_input, mocker, capsys):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    mockIsDir = mocker.patch("os.path.isdir", return_value=True)
+    mockRemove = mocker.patch("qupled.quantum.rmtree")
+    qstls_iet._cleanFixedAdrFiles(qstls_iet_input)
+    assert mockMPIIsRoot.call_count == 1
+    assert mockRemove.call_count == 1
+
+
+def test_save(qstls_iet, qstls_iet_input, mocker):
+    mockMPIIsRoot = mocker.patch("qupled.util.MPI.isRoot")
+    try:
+        scheme = QstlsNative(qstls_iet_input.toNative())
+        qstls_iet.hdfFileName = qstls_iet._getHdfFile(scheme.inputs)
+        qstls_iet._save(scheme)
+        assert mockMPIIsRoot.call_count == 4
+        assert os.path.isfile(qstls_iet.hdfFileName)
+        inspectData = Hdf().inspect(qstls_iet.hdfFileName)
+        expectedEntries = [
+            "coupling",
+            "degeneracy",
+            "theory",
+            "error",
+            "resolution",
+            "cutoff",
+            "matsubara",
+            "adr",
+            "idr",
+            "sdr",
+            "slfc",
+            "bf",
+            "ssf",
+            "ssfHF",
+            "wvg",
+        ]
+        for entry in expectedEntries:
+            assert entry in inspectData
+    finally:
+        os.remove(qstls_iet.hdfFileName)