Beispiel #1
0
    def _get_properties(self):
        """
        Loads all properties to object's attributes.
        """

        self._ab_initio_program = self.getProperty("AbInitioProgram").value
        self._vibrational_or_phonon_data_file = self.getProperty(
            "VibrationalOrPhononFile").value
        self._experimental_file = self.getProperty("ExperimentalFile").value
        self._temperature = self.getProperty("TemperatureInKelvin").value
        self._bin_width = self.getProperty("BinWidthInWavenumber").value
        self._scale = self.getProperty("Scale").value
        self._sample_form = self.getProperty("SampleForm").value

        instrument_name = self.getProperty("Instrument").value
        if instrument_name in AbinsModules.AbinsConstants.ALL_INSTRUMENTS:
            self._instrument_name = instrument_name
            instrument_producer = AbinsModules.InstrumentProducer()
            self._instrument = instrument_producer.produce_instrument(
                name=self._instrument_name)
        else:
            raise ValueError("Unknown instrument %s" % instrument_name)

        self._atoms = self.getProperty("Atoms").value
        self._sum_contributions = self.getProperty("SumContributions").value

        # conversion from str to int
        self._num_quantum_order_events = int(
            self.getProperty("QuantumOrderEventsNumber").value)

        self._scale_by_cross_section = self.getPropertyValue(
            'ScaleByCrossSection')
        self._out_ws_name = self.getPropertyValue('OutputWorkspace')
        self._calc_partial = (len(self._atoms) > 0)

        # user defined interval is exclusive with respect to
        # AbinsModules.AbinsParameters.min_wavenumber
        # AbinsModules.AbinsParameters.max_wavenumber
        # with bin width AbinsModules.AbinsParameters.bin_width
        step = self._bin_width
        start = AbinsModules.AbinsParameters.min_wavenumber + step / 2.0
        stop = AbinsModules.AbinsParameters.max_wavenumber + step / 2.0
        self._bins = np.arange(start=start,
                               stop=stop,
                               step=step,
                               dtype=AbinsModules.AbinsConstants.FLOAT_TYPE)
class AbinsCalculateSPowderTest(unittest.TestCase):
    """
    Test of  CalculateS for the Powder scenario.
    """

    _temperature = 10  # 10 K,  temperature for the benchmark
    _sample_form = "Powder"
    _instrument = AbinsModules.InstrumentProducer().produce_instrument("TOSCA")
    _order_event = AbinsModules.AbinsConstants.FUNDAMENTALS
    _si2 = "Si2-sc_CalculateSPowder"

    def setUp(self):
        AbinsModules.AbinsParameters.atoms_threads = 1

    def tearDown(self):
        AbinsModules.AbinsTestHelpers.remove_output_files(list_of_names=["CalculateSPowder"])

    #     test input
    def test_wrong_input(self):
        full_path_filename = AbinsModules.AbinsTestHelpers.find_file(filename=self._si2 + ".phonon")

        castep_reader = AbinsModules.LoadCASTEP(input_ab_initio_filename=full_path_filename)
        good_data = castep_reader.read_vibrational_or_phonon_data()

        # wrong filename
        with self.assertRaises(ValueError):
            AbinsModules.CalculateS.init(filename=1, temperature=self._temperature, sample_form=self._sample_form,
                                         abins_data=good_data, instrument=self._instrument,
                                         quantum_order_num=self._order_event)

        # wrong temperature
        with self.assertRaises(ValueError):
            AbinsModules.CalculateS.init(filename=full_path_filename, temperature=-1, sample_form=self._sample_form,
                                         abins_data=good_data, instrument=self._instrument,
                                         quantum_order_num=self._order_event)

        # wrong sample
        with self.assertRaises(ValueError):
            AbinsModules.CalculateS.init(filename=full_path_filename, temperature=self._temperature,
                                         sample_form="SOLID", abins_data=good_data, instrument=self._instrument,
                                         quantum_order_num=self._order_event)

        # wrong abins data: content of abins data instead of object abins_data
        with self.assertRaises(ValueError):
            AbinsModules.CalculateS.init(filename=full_path_filename, temperature=self._temperature,
                                         sample_form=self._sample_form, abins_data=good_data.extract(),
                                         instrument=self._instrument, quantum_order_num=self._order_event)

        # wrong instrument
        with self.assertRaises(ValueError):

            # noinspection PyUnusedLocal
            AbinsModules.CalculateS.init(filename=full_path_filename, temperature=self._temperature,
                                         sample_form=self._sample_form, abins_data=good_data.extract(),
                                         instrument=self._instrument, quantum_order_num=self._order_event)

    #  main test
    def test_good_case(self):
        self._good_case(name=self._si2)

    # helper functions
    def _good_case(self, name=None):
        # calculation of powder data
        good_data = self._get_good_data(filename=name)
        good_tester = AbinsModules.CalculateS.init(
            filename=AbinsModules.AbinsTestHelpers.find_file(filename=name + ".phonon"), temperature=self._temperature,
            sample_form=self._sample_form, abins_data=good_data["DFT"], instrument=self._instrument,
            quantum_order_num=self._order_event)
        calculated_data = good_tester.get_formatted_data()

        self._check_data(good_data=good_data["S"], data=calculated_data.extract())

        # check if loading powder data is correct
        new_tester = AbinsModules.CalculateS.init(
            filename=AbinsModules.AbinsTestHelpers.find_file(filename=name + ".phonon"), temperature=self._temperature,
            sample_form=self._sample_form, abins_data=good_data["DFT"], instrument=self._instrument,
            quantum_order_num=self._order_event)
        loaded_data = new_tester.load_formatted_data()

        self._check_data(good_data=good_data["S"], data=loaded_data.extract())

    def _get_good_data(self, filename=None):

        castep_reader = AbinsModules.LoadCASTEP(
            input_ab_initio_filename=AbinsModules.AbinsTestHelpers.find_file(filename=filename + ".phonon"))
        s_data = self._prepare_data(filename=AbinsModules.AbinsTestHelpers.find_file(filename=filename + "_S.txt"))

        return {"DFT": castep_reader.read_vibrational_or_phonon_data(), "S": s_data}

    # noinspection PyMethodMayBeStatic
    def _prepare_data(self, filename=None):
        """Reads a correct values from ASCII file."""
        with open(filename) as data_file:
            # noinspection PyPep8
            correct_data = json.loads(data_file.read().replace("\\n", " ").
                                      replace("array",    "").
                                      replace("([",  "[").
                                      replace("])",  "]").
                                      replace("'",  '"').
                                      replace("0. ", "0.0"))

        temp = np.asarray(correct_data["frequencies"])
        correct_data["frequencies"] = temp

        # we need to - 1 because one entry is "frequencies"
        for el in range(len(correct_data) - 1):

            temp = np.asarray(correct_data["atom_%s" % el]["s"]["order_%s" % AbinsModules.AbinsConstants.FUNDAMENTALS])
            correct_data["atom_%s" % el]["s"]["order_%s" % AbinsModules.AbinsConstants.FUNDAMENTALS] = temp

        return correct_data

    def _check_data(self, good_data=None, data=None):

        good_temp = good_data["frequencies"]
        data_temp = data["frequencies"]
        self.assertEqual(True, np.allclose(good_temp, data_temp))

        # we need to - 1 because one entry is "frequencies"
        for el in range(len(good_data) - 1):

            good_temp = good_data["atom_%s" % el]["s"]["order_%s" % AbinsModules.AbinsConstants.FUNDAMENTALS]
            data_temp = data["atom_%s" % el]["s"]["order_%s" % AbinsModules.AbinsConstants.FUNDAMENTALS]
            self.assertEqual(True, np.allclose(good_temp, data_temp))