conftest.py 7.05 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Copyright 2018 Markus Scheidgen
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an"AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import pytest

17
18
from ase import Atoms

19
from nomad.parsing.legacy import Backend
20
21
22
23
24
25
from nomad.normalizing import normalizers

from tests.test_parsing import parsed_vasp_example  # pylint: disable=unused-import
from tests.test_parsing import parsed_template_example  # pylint: disable=unused-import
from tests.test_parsing import parsed_example  # pylint: disable=unused-import
from tests.test_parsing import parse_file
26
from tests.test_parsing import parsed_template_no_system  # pylint: disable=unused-import
27
28


29
def run_normalize(backend: Backend) -> Backend:
30
31
32
33
34
35
36
37
38
39
40
    status, _ = backend.status

    assert status == 'ParseSuccess'

    for normalizer_class in normalizers:
        normalizer = normalizer_class(backend)
        normalizer.normalize()
    return backend


@pytest.fixture
41
42
def normalized_vasp_example(parsed_vasp_example: Backend) -> Backend:
    return run_normalize(parsed_vasp_example)
43
44
45


@pytest.fixture
46
47
def normalized_example(parsed_example: Backend) -> Backend:
    return run_normalize(parsed_example)
48
49
50


@pytest.fixture
51
52
def normalized_template_example(parsed_template_example) -> Backend:
    return run_normalize(parsed_template_example)
53
54


55
def run_normalize_for_structure(atoms: Atoms) -> Backend:
56
57
58
59
60
61
62
63
64
65
    template = parsed_template_no_system()

    # Fill structural information
    gid = template.openSection("section_system")
    template.addArrayValues("atom_positions", atoms.get_positions() * 1E-10)
    template.addArrayValues("atom_labels", atoms.get_chemical_symbols())
    template.addArrayValues("simulation_cell", atoms.get_cell() * 1E-10)
    template.addArrayValues("configuration_periodic_dimensions", atoms.get_pbc())
    template.closeSection("section_system", gid)

66
    return run_normalize(template)
67
68


Lauri Himanen's avatar
Lauri Himanen committed
69
@pytest.fixture(scope='session')
70
def single_point(two_d) -> Backend:
Lauri Himanen's avatar
Lauri Himanen committed
71
72
73
    return two_d


74
@pytest.fixture(scope='session')
75
def gw(two_d) -> Backend:
76
77
78
79
    parser_name = "parsers/template"
    filepath = "tests/data/normalizers/gw.json"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
80
    return backend
81
82


83
@pytest.fixture(scope='session')
84
def geometry_optimization() -> Backend:
85
86
87
88
    parser_name = "parsers/template"
    filepath = "tests/data/normalizers/fcc_crystal_structure.json"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
89
    return backend
90
91


92
@pytest.fixture(scope='session')
93
def molecular_dynamics(bulk) -> Backend:
94
    return bulk
95
96


97
@pytest.fixture(scope='session')
98
def phonon() -> Backend:
99
    parser_name = "parsers/phonopy"
100
    filepath = "tests/data/parsers/phonopy/phonopy-FHI-aims-displacement-01/control.in"
101
102
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
103
    return backend
Lauri Himanen's avatar
Lauri Himanen committed
104
105


106
@pytest.fixture(scope='session')
107
def bulk() -> Backend:
108
109
    parser_name = "parsers/cp2k"
    filepath = "tests/data/normalizers/cp2k_bulk_md/si_md.out"
110
111
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
112
    return backend
113
114
115


@pytest.fixture(scope='session')
116
def two_d() -> Backend:
Lauri Himanen's avatar
Lauri Himanen committed
117
    parser_name = "parsers/fhi-aims"
118
    filepath = "tests/data/normalizers/fhiaims_2d_singlepoint/aims.out"
Lauri Himanen's avatar
Lauri Himanen committed
119
120
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
121
    return backend
Lauri Himanen's avatar
Lauri Himanen committed
122
123
124


@pytest.fixture(scope='session')
125
def surface() -> Backend:
Lauri Himanen's avatar
Lauri Himanen committed
126
    parser_name = "parsers/fhi-aims"
127
128
129
    filepath = "tests/data/normalizers/fhiaims_surface_singlepoint/PBE-light+tight-rho2.out"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
130
    return backend
131
132
133


@pytest.fixture(scope='session')
134
def molecule() -> Backend:
135
136
137
138
    parser_name = "parsers/fhi-aims"
    filepath = "tests/data/normalizers/fhiaims_molecule_singlepoint/aims.out"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
139
    return backend
140
141
142


@pytest.fixture(scope='session')
143
def atom() -> Backend:
144
145
146
147
    parser_name = "parsers/gaussian"
    filepath = "tests/data/normalizers/gaussian_atom_singlepoint/m9b7.out"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
148
    return backend
149
150
151


@pytest.fixture(scope='session')
152
def one_d() -> Backend:
153
154
    parser_name = "parsers/exciting"
    filepath = "tests/data/normalizers/exciting_1d_singlepoint/INFO.OUT"
Lauri Himanen's avatar
Lauri Himanen committed
155
156
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
157
    return backend
158
159
160


@pytest.fixture(scope='session')
161
def bands_unpolarized_gap_indirect() -> Backend:
162
    parser_name = "parsers/vasp"
163
    filepath = "tests/data/normalizers/band_structure/unpolarized_gap/vasprun.xml.bands.xz"
164
165
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
166
    return backend
167
168
169


@pytest.fixture(scope='session')
170
def bands_polarized_no_gap() -> Backend:
171
    parser_name = "parsers/vasp"
172
    filepath = "tests/data/normalizers/band_structure/polarized_no_gap/vasprun.xml.bands.xz"
173
174
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
175
    return backend
176
177
178


@pytest.fixture(scope='session')
179
def bands_unpolarized_no_gap() -> Backend:
180
    parser_name = "parsers/vasp"
181
    filepath = "tests/data/normalizers/band_structure/unpolarized_no_gap/vasprun.xml.bands.xz"
182
183
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
184
    return backend
185
186
187


@pytest.fixture(scope='session')
188
def bands_polarized_gap_indirect() -> Backend:
189
    parser_name = "parsers/vasp"
190
    filepath = "tests/data/normalizers/band_structure/polarized_gap/vasprun.xml.bands.xz"
191
192
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
193
    return backend
194
195
196


@pytest.fixture(scope='session')
197
def dos_polarized_vasp() -> Backend:
198
199
200
201
    parser_name = "parsers/vasp"
    filepath = "tests/data/normalizers/dos/polarized_vasp/vasprun.xml.relax2.xz"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
202
    return backend
203
204
205


@pytest.fixture(scope='session')
206
def dos_unpolarized_vasp() -> Backend:
207
208
209
210
    parser_name = "parsers/vasp"
    filepath = "tests/data/normalizers/dos/unpolarized_vasp/vasprun.xml.xz"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
211
    return backend
212
213
214


@pytest.fixture(scope='session')
215
def hash_exciting() -> Backend:
216
217
218
219
    parser_name = "parsers/exciting"
    filepath = "tests/data/normalizers/hashes/exciting/INFO.OUT"
    backend = parse_file((parser_name, filepath))
    backend = run_normalize(backend)
220
    return backend
221
222
223


@pytest.fixture(scope='session')
224
def hash_vasp(bands_unpolarized_gap_indirect) -> Backend:
225
    return bands_unpolarized_gap_indirect