pyNIBS 0.2024.8__py3-none-any.whl

pynibs/tests/test_coil.py

@@ -0,0 +1,474 @@
+import os
+import h5py
+import pynibs
+import unittest
+import tempfile
+import numpy as np
+from xml.sax import make_parser
+from xml.sax.handler import ContentHandler
+try:
+    import simnibs
+except ImportError:
+    raise unittest.SkipTest("Cannot import SimNIBS - skipping test_coil.py")
+
+
+def check_xml(xml_fn):
+    """Check well-formedness of xml"""
+    parser = make_parser()
+    parser.setContentHandler(ContentHandler())
+    parser.parse(xml_fn)
+
+
+class TestCreateStimsiteFromTmslist(unittest.TestCase):
+    """
+    Test pynibs.coil.create_stimsite_from_tmslist()
+    """
+    folder = tempfile.TemporaryDirectory()
+    pos1 = np.array(([11, 12, 13, 14],
+                     [21, 22, 23, 24],
+                     [31, 32, 33, 34],
+                     [41, 42, 43, 44]))
+    pos1 = pos1.transpose()
+    pos2 = np.array(([110, 120, 130, 140],
+                     [210, 220, 230, 240],
+                     [310, 320, 330, 340],
+                     [410, 420, 430, 440]))
+    pos2 = pos2.transpose()
+
+    def test_create_stimsite_from_tmslist1_pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos1)
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_tmslist1_overwrite(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos1)
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+
+            # raise error if overwrite=False
+            with self.assertRaises(OSError):
+                pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=None, overwrite=False)
+
+            # let's write a different file to make sure the correct one is written
+            pos2 = simnibs.sim_struct.POSITION()
+            pos2.matsimnibs = self.pos2
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos2)
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=None, overwrite=True)
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_tmslist_2pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            pos2 = simnibs.sim_struct.POSITION()
+            pos2.matsimnibs = self.pos2
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos1)
+            tmslist.add_position(pos2)
+
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=None, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_tmslist1_datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos1)
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            datanames = 'somedata'
+            data = np.array(1)
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=['1', '2'], data=data,
+                                                    overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=None, data=data, overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=datanames, data=None, overwrite=False)
+
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=datanames, data=data, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+            datanames = ['somedata']
+            data = 1
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=datanames, data=data, overwrite=True)
+            data = np.array(1)
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=datanames, data=data, overwrite=True)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_tmslist_2pos_2datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            pos2 = simnibs.sim_struct.POSITION()
+            pos2.matsimnibs = self.pos2
+            tmslist = simnibs.sim_struct.TMSLIST()
+            tmslist.add_position(pos1)
+            tmslist.add_position(pos2)
+            datanames = ['somedata1', 'somedata2']
+            data = np.array(([1, 2], [3, 4])).transpose()
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_tmslist(fn_hdf, tmslist, datanames=datanames, data=data, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs','data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        h[k].keys()
+                        assert (h[f"{k}/somedata1"][:] == np.array([1,2])).all()
+                        assert (h[f"{k}/somedata2"][:] == np.array([3,4])).all()
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+
+class TestCreateStimsiteFromMatsimnibs(unittest.TestCase):
+    """
+    Test pynibs.coil.create_stimsite_from_matsimnibs()
+    """
+    folder = tempfile.TemporaryDirectory()
+    pos1 = np.array(([11, 12, 13, 14],
+                     [21, 22, 23, 24],
+                     [31, 32, 33, 34],
+                     [41, 42, 43, 44]))
+    pos1 = pos1.transpose()
+    pos2 = np.array(([110, 120, 130, 140],
+                     [210, 220, 230, 240],
+                     [310, 320, 330, 340],
+                     [410, 420, 430, 440]))
+    pos2 = pos2.transpose()
+
+    def test_create_stimsite_from_matsimnibs_1pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_matsimnibs_overwrite(self):
+        with tempfile.TemporaryDirectory() as folder:
+
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+
+            # raise error if overwrite=False
+            with self.assertRaises(OSError):
+                pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=None, data=None, overwrite=False)
+
+            # let's write a different file to make sure the correct one is written
+
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos2, datanames=None, data=None, overwrite=True)
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_matsimnibs_2pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+
+            matsimnibs = np.dstack((self.pos1, self.pos2))
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, matsimnibs, datanames=None, data=None, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_matsimnibs_datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            datanames = 'somedata'
+            data = np.array(1)
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=['1', '2'], data=data,
+                                                    overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=None, data=data, overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=datanames, data=None, overwrite=False)
+
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=datanames, data=data, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+            datanames = ['somedata']
+            data = 1
+
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=datanames, data=data, overwrite=True)
+
+            data = np.array(1)
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, self.pos1, datanames=datanames, data=data, overwrite=True)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_matsimnibs_2pos_2datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            matsimnibs = np.dstack((self.pos1, self.pos2))
+            datanames = ['somedata1', 'somedata2']
+            data = np.array(([1, 2], [3, 4])).transpose()
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_matsimnibs(fn_hdf, matsimnibs, datanames=datanames, data=data, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs','data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        h[k].keys()
+                        assert (h[f"{k}/somedata1"][:] == np.array([1,2])).all()
+                        assert (h[f"{k}/somedata2"][:] == np.array([3,4])).all()
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+
+class TestCreateStimsiteFromList(unittest.TestCase):
+    """
+    Test pynibs.coil.create_stimsite_from_list()
+    """
+    folder = tempfile.TemporaryDirectory()
+    pos1 = np.array(([11, 12, 13, 14],
+                     [21, 22, 23, 24],
+                     [31, 32, 33, 34],
+                     [41, 42, 43, 44]))
+    pos1 = pos1.transpose()
+    pos2 = np.array(([110, 120, 130, 140],
+                     [210, 220, 230, 240],
+                     [310, 320, 330, 340],
+                     [410, 420, 430, 440]))
+    pos2 = pos2.transpose()
+
+    def test_create_stimsite_from_list_1pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pos1 = simnibs.sim_struct.POSITION()
+            pos1.matsimnibs = self.pos1
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_list_overwrite(self):
+        with tempfile.TemporaryDirectory() as folder:
+
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=None, data=None, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+
+            # raise error if overwrite=False
+            with self.assertRaises(OSError):
+                pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=None, data=None, overwrite=False)
+
+            # let's write a different file to make sure the correct one is written
+
+            pynibs.create_stimsite_from_list(fn_hdf, [self.pos2], datanames=None, data=None, overwrite=True)
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_list_2pos(self):
+        with tempfile.TemporaryDirectory() as folder:
+
+            matsimnibs = [self.pos1, self.pos2]
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_list(fn_hdf, matsimnibs, datanames=None, data=None, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_list_datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            datanames = 'somedata'
+            data = np.array(1)
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=['1', '2'], data=data,
+                                                    overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=None, data=data, overwrite=False)
+            with self.assertRaises(ValueError):
+                pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=datanames, data=None, overwrite=False)
+
+            pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=datanames, data=data, overwrite=False)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+            datanames = ['somedata']
+            data = 1
+
+            with self.assertRaises(AssertionError):
+                pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=datanames, data=data, overwrite=True)
+            data = np.array(1)
+            pynibs.create_stimsite_from_list(fn_hdf, [self.pos1], datanames=datanames, data=data, overwrite=True)
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs', 'data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        assert h[f"{k}/somedata"][:] == np.array([1])
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (1, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+    def test_create_stimsite_from_list_2pos_2datanames(self):
+        with tempfile.TemporaryDirectory() as folder:
+            matsimnibs = [self.pos1, self.pos2]
+            datanames = ['somedata1', 'somedata2']
+            data = np.array(([1, 2], [3, 4])).transpose()
+            fn_hdf = os.path.join(folder, "stimsite_from_list.hdf5")
+            pynibs.create_stimsite_from_list(fn_hdf, matsimnibs, datanames=datanames, data=data, overwrite=False)
+
+            assert os.path.exists(fn_hdf)
+            assert os.path.exists(fn_hdf.replace('.hdf5', '.xdmf'))
+            check_xml(fn_hdf.replace('.hdf5', '.xdmf'))
+            with h5py.File(fn_hdf, 'r')as h:
+                for idx, k in enumerate(['m0', 'm1', 'm2', 'centers', 'matsimnibs','data']):
+                    assert k in h.keys(), f"{k} missing in {fn_hdf}"
+                    if k == 'data':
+                        h[k].keys()
+                        assert (h[f"{k}/somedata1"][:] == np.array([1,2])).all()
+                        assert (h[f"{k}/somedata2"][:] == np.array([3,4])).all()
+                    elif k != 'matsimnibs':
+                        assert h[k][:].shape == (2, 3), f"Wrong shape for {k}: {h[k][:].shape}"
+                        assert (h[k][:][0, :] == self.pos1[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+                        assert (h[k][:][1, :] == self.pos2[:3, idx]).all(), f"Wrong values for {k}: {h[k][:]}"
+
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tests/test_elements2nodes.py

@@ -0,0 +1,100 @@
+import warnings
+import pynibs
+import numpy as np
+import unittest
+
+
+class TestDataElements2Nodes(unittest.TestCase):
+    """
+    Test pynibs.data_elements2nodes()
+    """
+    np.random.seed(1)
+    n_elm_small = 100
+    n_elm_large = 100000
+    con_small_tri = np.random.choice(n_elm_small, n_elm_small * 3)
+    con_small_tri = np.reshape(con_small_tri, (n_elm_small, 3))
+    con_small_tet = np.random.choice(n_elm_small, n_elm_small * 4)
+    con_small_tet = np.reshape(con_small_tet, (n_elm_small, 4))
+
+    data_small = np.random.rand(n_elm_small) * 1000
+    data_small_zero = np.zeros(n_elm_small)
+    data_small_nan = data_small.copy()
+    data_small_nan[np.random.choice(n_elm_small,20,replace=False)] = np.nan
+    datas_small = [np.random.rand(n_elm_small), np.random.rand(n_elm_small), np.random.rand(n_elm_small)]
+
+    data_large = np.random.rand(n_elm_large) * 1000
+    con_large_tri = np.random.choice(n_elm_large, n_elm_large * 3)
+    con_large_tri = np.reshape(con_large_tri, (n_elm_large, 3))
+
+    ret_small_tri = np.array([[3.81717394e+03, -3.44380754e+03, -1.04068361e+02,
+                               -3.03672180e+03, 1.69162931e-11, 3.28735690e+02,
+                               -1.90366377e+03, -1.75718804e+03, -1.01526253e+03,
+                               1.04089987e+03, 2.77992727e+03, 1.09061487e+04,
+                               5.38944819e+03, -3.79793187e+02, 9.39673305e+02,
+                               1.98831328e+03, 1.58734484e+03, -1.13042037e+03,
+                               -2.09536935e+03, 2.26513015e+03, 4.73078124e+03,
+                               3.39876074e+03, -7.55140605e+02, -2.97782279e+02,
+                               -1.40251390e+03, 2.05253645e+03, -5.02309550e+02,
+                               2.96740726e+03, -3.00838583e+03, -5.50986205e+03,
+                               1.48806206e+03, 4.16278309e+03, 2.62938829e+03,
+                               1.93231842e+02, -4.61159330e+03, 2.59423044e+02,
+                               -4.60235252e+03, -7.24318305e+03, 2.66801622e+03,
+                               5.76236046e+03, 2.97453723e+03, 3.08128171e+02,
+                               5.27098593e+02, 1.15281629e+03, -1.54514947e+03,
+                               3.34553994e+03, 3.41534538e+03, -1.55617593e+03,
+                               -4.47155698e+03, 1.36873183e+02, 2.63697251e+03,
+                               1.90110815e-11, 1.91430775e+03, -2.15570486e+02,
+                               3.79785433e+03, 6.35365607e+03, -7.24051657e+02,
+                               5.20753754e+03, 3.19122804e-12, -5.82332417e+02,
+                               2.01945775e+03, -2.75572686e+03, -1.19368661e+03,
+                               1.65623497e+03, 1.09343732e+03, -6.13390936e+03,
+                               1.14957878e+03, 1.37436400e+03, -7.85602469e+02,
+                               -2.49699644e+03, -6.00553990e+02, 3.23686455e+03,
+                               3.70927556e+03, 2.29986338e-13, 5.10659728e+02,
+                               -1.22064351e+03, 5.40601193e+02, 1.08103027e+03,
+                               -2.15922656e+03, -8.83769660e+02, -8.91707692e+02,
+                               4.99875852e+03, -2.02433759e+03, 9.20401644e+02,
+                               8.07942131e+01, 2.80601545e+03, 1.49195685e+03,
+                               -2.74571524e+02, -1.13395172e+03, -1.41719240e+02,
+                               -3.90122898e-14, -1.84344533e+02, -3.97735225e+03,
+                               1.93231842e+02, 4.02650694e+02, 0.00000000e+00,
+                               -6.16506432e+02, 2.20263338e+03, 2.65351685e+03,
+                               1.54040912e+03]])
+
+    def test_e2n_single_data_tri(self):
+        ret = pynibs.data_elements2nodes(self.data_small, self.con_small_tri)
+        assert ret.shape == (1, self.n_elm_small)
+        assert np.all(np.isclose(ret, self.ret_small_tri))
+
+    def test_e2n_single_data_tri_zero(self):
+        ret = pynibs.data_elements2nodes(self.data_small_zero, self.con_small_tri, precise=True)
+
+        assert ret.shape == (1, self.n_elm_small)
+        assert np.nanmax(ret[0]) == 0
+        assert np.isnan(ret[0][4])
+
+    def test_e2n_single_data_tri_nan(self):
+        ret = pynibs.data_elements2nodes(self.data_small_nan, self.con_small_tri)
+        assert ret.shape == (1, self.n_elm_small)
+
+    def test_e2n_single_data_tet(self):
+        ret = pynibs.data_elements2nodes(self.data_small, self.con_small_tet)
+        assert ret.shape == (1, self.n_elm_small)
+
+    def test_e2n_mult_data(self):
+        ret = pynibs.data_elements2nodes(self.datas_small, self.con_small_tri)
+        assert len(ret) == 3
+        assert ret[0].shape == (self.n_elm_small,)
+
+    '''
+    def test_e2n_single_data_tri_large(self):
+        """
+        This tests for the OOM catch. Results are not checked, due to long compuation time.
+        """
+        warnings.filterwarnings("error", "Cannot allocate enough RAM")
+        with self.assertRaises(Exception):
+            pynibs.data_elements2nodes(self.data_large, self.con_large_tri)
+    '''
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tests/test_hdf5_io/test_xdmf.py

@@ -0,0 +1,61 @@
+import os
+import shutil
+import tempfile
+
+import pynibs
+import unittest
+from xml.sax import make_parser
+from xml.sax.handler import ContentHandler
+
+
+def check_xml(xml_fn):
+    """Check well-formedness of xml"""
+    parser = make_parser()
+    parser.setContentHandler(ContentHandler())
+    parser.parse(xml_fn)
+
+
+class TestWriteXdmf(unittest.TestCase):
+    """This tests pynibs.write_xdmf()"""
+
+    data_fn = os.path.join(pynibs.__testdatadir__, "data.hdf5")
+    geo_fn = os.path.join(pynibs.__testdatadir__, "geo.hdf5")
+    xml_scheme_fn = os.path.join(pynibs.__testdatadir__, "vtk-unstructured.xsd")
+    xdmf_geo_fn = os.path.join(pynibs.__testdatadir__, "geo.xdmf")
+    xdmf_data_fn = os.path.join(pynibs.__testdatadir__, "data.xdmf")
+
+    for fn in [xdmf_geo_fn, xdmf_data_fn]:
+        try:
+            os.remove(fn)
+        except OSError:
+            pass
+
+    def test_1_write_geo_only(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            geo_fn = shutil.copy(self.geo_fn, tempdir)
+            fn_xml = pynibs.write_xdmf(geo_fn)
+            check_xml(fn_xml)
+
+    def test_2_write_xdmf_exists(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            geo_fn = shutil.copy(self.geo_fn, tempdir)
+            pynibs.write_xdmf(geo_fn)
+            self.assertRaises(FileExistsError, pynibs.write_xdmf, geo_fn)
+
+    def test_3_write_xdmf_overwrite(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            geo_fn = shutil.copy(self.geo_fn, tempdir)
+            pynibs.write_xdmf(geo_fn)
+            pynibs.write_xdmf(geo_fn, overwrite_xdmf=True)
+
+    def test_4_write_datageo(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            geo_fn = shutil.copy(self.geo_fn, tempdir)
+            data_fn = shutil.copy(self.data_fn, tempdir)
+            pynibs.write_xdmf(geo_fn)
+            xdmf_data_fn = pynibs.write_xdmf(data_fn, geo_fn, overwrite_xdmf=True)
+            check_xml(xdmf_data_fn)
+
+
+if __name__ == '__main__':
+    unittest.main()