Extend unit tests

MDANSE/Src/MDANSE/Framework/Configurators/InstrumentResolutionConfigurator.py

@@ -93,12 +93,9 @@ def configure(self, value):
         resolution.set_kernel(self["omega"], self["time_step"])
         self["omega_window"] = resolution.omegaWindow
         self["time_window"] = resolution.timeWindow.real
-
-        rresolution = IInstrumentResolution.create(kernel)
-        rresolution.setup(parameters)
-        rresolution.set_kernel(self["romega"], self["time_step"], fft="rfft")
-        self["romega_window"] = rresolution.omegaWindow
-        self["rtime_window"] = rresolution.timeWindow.real
+        self["time_window_positive"] = np.fft.ifftshift(self["time_window"])[
+            : len(time)
+        ]
 
     def get_information(self):
         """

MDANSE/Src/MDANSE/Framework/Configurators/RunningModeConfigurator.py

@@ -28,7 +28,7 @@ class RunningModeConfigurator(IConfigurator):
     """
     This configurator allows to choose the mode used to run the calculation.
 
-    MDANSE currently support single-core or multicore (SMP) running modes. In the laster case, you have to
+    MDANSE currently support single-core or multicore (SMP) running modes. In the latter case, you have to
     specify the number of slots used for running the analysis.
     """
 
@@ -59,17 +59,20 @@ def configure(self, value):
 
         else:
             slots = int(value[1])
+            maxSlots = multiprocessing.cpu_count()
 
-            if mode == "multicore":
-                maxSlots = multiprocessing.cpu_count()
+            if slots == 0:
+                self.error_status = "invalid number of allocated slots."
+                return
+            elif slots < 0:
+                slots = abs(slots)
+                if slots > maxSlots:
+                    slots = maxSlots
+            else:
                 if slots > maxSlots:
                     self.error_status = "invalid number of allocated slots."
                     return
 
-            if slots <= 0:
-                self.error_status = "invalid number of allocated slots."
-                return
-
         self["mode"] = mode
 
         self["slots"] = slots

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/Gaussian.py

@@ -31,11 +31,11 @@ class Gaussian(IInstrumentResolution):
     settings["mu"] = ("FloatConfigurator", {"default": 0.0})
     settings["sigma"] = ("FloatConfigurator", {"default": 1.0})
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         mu = self._configuration["mu"]["value"]
         sigma = self._configuration["sigma"]["value"]
 
         self._omegaWindow = (np.sqrt(2.0 * np.pi) / sigma) * np.exp(
             -0.5 * ((omegas - mu) / sigma) ** 2
         )
-        self._timeWindow = self.apply_fft(self._omegaWindow, dt, fft)
+        self._timeWindow = self.apply_fft(self._omegaWindow, dt)

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/IInstrumentResolution.py

@@ -37,18 +37,11 @@ def __init__(self):
         self._timeWindow = None
 
     @abc.abstractmethod
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         pass
 
-    def apply_fft(self, omegaWindow, dt, fft="fft"):
-        if fft == "fft":
-            timeWindow = np.fft.fftshift(
-                np.fft.ifft(np.fft.ifftshift(omegaWindow)) / dt
-            )
-        elif fft == "rfft":
-            timeWindow = np.fft.irfft(np.fft.ifftshift(omegaWindow)) / dt
-        else:
-            raise ValueError("fft variable should be fft or rfft.")
+    def apply_fft(self, omegaWindow, dt):
+        timeWindow = np.fft.fftshift(np.fft.ifft(np.fft.ifftshift(omegaWindow)) / dt)
         return timeWindow
 
     @property

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/Ideal.py

@@ -29,7 +29,7 @@ class Ideal(IInstrumentResolution):
 
     settings = collections.OrderedDict()
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         nOmegas = len(omegas)
         self._omegaWindow = np.zeros(nOmegas, dtype=np.float64)
         self._omegaWindow[int(nOmegas / 2)] = 1.0

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/Lorentzian.py

@@ -33,9 +33,9 @@ class Lorentzian(IInstrumentResolution):
     settings["mu"] = ("FloatConfigurator", {"default": 0.0})
     settings["sigma"] = ("FloatConfigurator", {"default": 1.0})
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         mu = self._configuration["mu"]["value"]
         sigma = self._configuration["sigma"]["value"]
 
         self._omegaWindow = (2.0 * sigma) / ((omegas - mu) ** 2 + sigma**2)
-        self._timeWindow = self.apply_fft(self._omegaWindow, dt, fft)
+        self._timeWindow = self.apply_fft(self._omegaWindow, dt)

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/PseudoVoigt.py

@@ -34,7 +34,7 @@ class PseudoVoigt(IInstrumentResolution):
     settings["mu_gaussian"] = ("FloatConfigurator", {"default": 0.0})
     settings["sigma_gaussian"] = ("FloatConfigurator", {"default": 1.0})
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         eta = self._configuration["eta"]["value"]
         muL = self._configuration["mu_lorentzian"]["value"]
         sigmaL = self._configuration["sigma_lorentzian"]["value"]
@@ -48,4 +48,4 @@ def set_kernel(self, omegas, dt, fft="fft"):
         lorentzian = (2.0 * sigmaL) / ((omegas - muL) ** 2 + sigmaL**2)
 
         self._omegaWindow = eta * lorentzian + (1.0 - eta) * gaussian
-        self._timeWindow = self.apply_fft(self._omegaWindow, dt, fft)
+        self._timeWindow = self.apply_fft(self._omegaWindow, dt)

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/Square.py

@@ -31,7 +31,7 @@ class Square(IInstrumentResolution):
     settings["mu"] = ("FloatConfigurator", {"default": 0.0})
     settings["sigma"] = ("FloatConfigurator", {"default": 1.0})
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         mu = self._configuration["mu"]["value"]
         sigma = self._configuration["sigma"]["value"]
 
@@ -41,4 +41,4 @@ def set_kernel(self, omegas, dt, fft="fft"):
             * np.where((np.abs(omegas - mu) - sigma) > 0, 0.0, 1.0 / (2.0 * sigma))
         )
 
-        self._timeWindow = self.apply_fft(self._omegaWindow, dt, fft)
+        self._timeWindow = self.apply_fft(self._omegaWindow, dt)

MDANSE/Src/MDANSE/Framework/InstrumentResolutions/Triangular.py

@@ -31,12 +31,12 @@ class Triangular(IInstrumentResolution):
     settings["mu"] = ("FloatConfigurator", {"default": 0.0})
     settings["sigma"] = ("FloatConfigurator", {"default": 1.0})
 
-    def set_kernel(self, omegas, dt, fft="fft"):
+    def set_kernel(self, omegas, dt):
         mu = self._configuration["mu"]["value"]
         sigma = self._configuration["sigma"]["value"]
 
         val = np.abs(omegas - mu) - sigma
 
         self._omegaWindow = 2.0 * np.pi * np.where(val >= 0, 0.0, -val / sigma**2)
 
-        self._timeWindow = self.apply_fft(self._omegaWindow, dt, fft)
+        self._timeWindow = self.apply_fft(self._omegaWindow, dt)

MDANSE/Src/MDANSE/Framework/Jobs/DensityOfStates.py

@@ -102,18 +102,21 @@ def initialize(self):
         self._outputData.add(
             "time_window",
             "LineOutputVariable",
-            instrResolution["rtime_window"],
+            instrResolution["time_window_positive"],
             axis="time",
             units="au",
         )
 
         self._outputData.add(
-            "omega", "LineOutputVariable", instrResolution["romega"], units="rad/ps"
+            "omega", "LineOutputVariable", instrResolution["omega"], units="rad/ps"
+        )
+        self._outputData.add(
+            "romega", "LineOutputVariable", instrResolution["romega"], units="rad/ps"
         )
         self._outputData.add(
             "omega_window",
             "LineOutputVariable",
-            instrResolution["romega_window"],
+            instrResolution["omega_window"],
             axis="omega",
             units="au",
         )
@@ -130,7 +133,7 @@ def initialize(self):
                 "dos_%s" % element,
                 "LineOutputVariable",
                 (instrResolution["n_romegas"],),
-                axis="omega",
+                axis="romega",
                 units="au",
             )
         self._outputData.add(
@@ -144,7 +147,7 @@ def initialize(self):
             "dos_total",
             "LineOutputVariable",
             (instrResolution["n_romegas"],),
-            axis="omega",
+            axis="romega",
             units="au",
         )
 

MDANSE/Src/MDANSE/Framework/Jobs/StructureFactorFromScatteringFunction.py

@@ -72,7 +72,7 @@ def initialize(self):
         self._outputData.add(
             "time_window",
             "LineOutputVariable",
-            inputFile["time_window"][:],
+            resolution["time_window_positive"],
             axis="time",
             units="au",
         )

MDANSE/Tests/UnitTests/Analysis/test_dynamics.py

@@ -61,7 +61,7 @@ def parameters():
     # parameters['atom_transmutation'] = None
     # parameters['frames'] = (0, 1000, 1)
     parameters["trajectory"] = short_traj
-    parameters["running_mode"] = ("threadpool", 4)
+    parameters["running_mode"] = ("threadpool", -4)
     parameters["q_vectors"] = (
         "SphericalLatticeQVectors",
         {
@@ -84,23 +84,34 @@ def parameters():
     return parameters
 
 
-@pytest.mark.parametrize(
-    "job_type",
-    [
-        # "AngularCorrelation",
-        # "GeneralAutoCorrelationFunction",
-        "DensityOfStates",
-        "MeanSquareDisplacement",
-        "VelocityAutoCorrelationFunction",
-        # "OrderParameter",
-        "PositionAutoCorrelationFunction",
-    ],
-)
-def test_dynamics_analysis(parameters, job_type):
+total_list = []
+
+for jt in [
+    # "AngularCorrelation",
+    # "GeneralAutoCorrelationFunction",
+    "DensityOfStates",
+    "MeanSquareDisplacement",
+    "VelocityAutoCorrelationFunction",
+    # "OrderParameter",
+    "PositionAutoCorrelationFunction",
+]:
+    for rm in [("single-core", 1), ("multicore", -4)]:
+        for of in ["MDAFormat", "TextFormat"]:
+            total_list.append((jt, rm, of))
+
+
+@pytest.mark.parametrize("job_type,running_mode,output_format", total_list)
+def test_dynamics_analysis(parameters, job_type, running_mode, output_format):
     temp_name = tempfile.mktemp()
-    parameters["output_files"] = (temp_name, ("MDAFormat",))
+    parameters["running_mode"] = running_mode
+    parameters["output_files"] = (temp_name, (output_format,))
     job = IJob.create(job_type)
     job.run(parameters, status=True)
-    assert path.exists(temp_name + ".mda")
-    assert path.isfile(temp_name + ".mda")
-    os.remove(temp_name + ".mda")
+    if output_format == "MDAFormat":
+        assert path.exists(temp_name + ".mda")
+        assert path.isfile(temp_name + ".mda")
+        os.remove(temp_name + ".mda")
+    elif output_format == "TextFormat":
+        assert path.exists(temp_name + "_text.tar")
+        assert path.isfile(temp_name + "_text.tar")
+        os.remove(temp_name + "_text.tar")

MDANSE/Tests/UnitTests/Analysis/test_infrared.py

@@ -28,7 +28,7 @@ def parameters():
     # parameters['atom_transmutation'] = None
     # parameters['frames'] = (0, 1000, 1)
     parameters["trajectory"] = short_traj
-    parameters["running_mode"] = ("threadpool", 4)
+    parameters["running_mode"] = ("threadpool", -4)
     parameters["q_vectors"] = (
         "SphericalLatticeQVectors",
         {

MDANSE/Tests/UnitTests/Analysis/test_mcstas.py

@@ -28,7 +28,7 @@ def parameters():
     # parameters['atom_transmutation'] = None
     # parameters['frames'] = (0, 1000, 1)
     parameters["trajectory"] = short_traj
-    parameters["running_mode"] = ("threadpool", 4)
+    parameters["running_mode"] = ("threadpool", -4)
     parameters["q_vectors"] = (
         "SphericalLatticeQVectors",
         {

MDANSE/Tests/UnitTests/Analysis/test_meansquare.py

@@ -57,7 +57,7 @@ def test_parallel_meansquare():
     parameters = {}
     parameters["frames"] = (0, 10, 1)
     parameters["output_files"] = (temp_name2, ("MDAFormat",))
-    parameters["running_mode"] = ("threadpool", 4)
+    parameters["running_mode"] = ("multicore", -4)
     parameters["trajectory"] = short_traj
     msd_par = IJob.create("MeanSquareDisplacement")
     msd_par.run(parameters, status=True)

MDANSE/Tests/UnitTests/Analysis/test_molecule_names.py

@@ -28,7 +28,7 @@ def parameters():
     # parameters['atom_transmutation'] = None
     # parameters['frames'] = (0, 1000, 1)
     parameters["trajectory"] = short_traj
-    parameters["running_mode"] = ("threadpool", 4)
+    parameters["running_mode"] = ("threadpool", -4)
     parameters["q_vectors"] = (
         "SphericalLatticeQVectors",
         {

MDANSE/Tests/UnitTests/Analysis/test_resolutions.py

@@ -58,3 +58,39 @@ def test_disf(trajectory):
         assert path.exists(temp_name + ".mda")
         assert path.isfile(temp_name + ".mda")
         os.remove(temp_name + ".mda")
+
+
+list_of_resolutions = IInstrumentResolution.subclasses()
+
+
+@pytest.mark.parametrize("resolution_generator", list_of_resolutions)
+def test_dos_text(trajectory, resolution_generator):
+    parameters = {}
+    parameters["atom_selection"] = None
+    parameters["atom_transmutation"] = None
+    parameters["frames"] = (0, 10, 1)
+    parameters["instrument_resolution"] = ("Ideal", {})
+    parameters["q_vectors"] = (
+        "SphericalLatticeQVectors",
+        {"seed": 0, "shells": (5.0, 36, 10.0), "n_vectors": 10, "width": 9.0},
+    )
+    parameters["running_mode"] = ("single-core",)
+    parameters["trajectory"] = short_traj
+    parameters["weights"] = "b_incoherent2"
+    temp_name = tempfile.mktemp()
+    parameters["output_files"] = (temp_name, ("TextFormat",))
+    instance = IInstrumentResolution.create(resolution_generator)
+    resolution_defaults = {
+        name: value[1]["default"] for name, value in instance.settings.items()
+    }
+    print(resolution_generator)
+    print(resolution_defaults)
+    parameters["instrument_resolution"] = (
+        resolution_generator,
+        resolution_defaults,
+    )
+    disf = IJob.create("DensityOfStates")
+    disf.run(parameters, status=True)
+    assert path.exists(temp_name + "_text.tar")
+    assert path.isfile(temp_name + "_text.tar")
+    os.remove(temp_name + "_text.tar")