diff --git a/parser/parser-cp2k/cp2kparser/generic/utils.py b/parser/parser-cp2k/cp2kparser/generic/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b4f8c488c713e3192e1149b3e643163cb071530
--- /dev/null
+++ b/parser/parser-cp2k/cp2kparser/generic/utils.py
@@ -0,0 +1,12 @@
+#===============================================================================
+def try_to_add_value(backend, section, source_name, destination_name):
+ original = section[source_name]
+ if original is not None:
+ backend.addValue(destination_name, original[0])
+
+
+#===============================================================================
+def try_to_add_array_values(backend, section, source_name, destination_name, unit=None):
+ original = section[source_name]
+ if original is not None:
+ backend.addArrayValues(destination_name, original[0])
diff --git a/parser/parser-cp2k/cp2kparser/versions/cp2k262/commonmatcher.py b/parser/parser-cp2k/cp2kparser/versions/cp2k262/commonmatcher.py
index ed96e37899e48aaea614f250a5018f7407dfdd60..b4a0533ae59989928070933499d422278a46aeea 100644
--- a/parser/parser-cp2k/cp2kparser/versions/cp2k262/commonmatcher.py
+++ b/parser/parser-cp2k/cp2kparser/versions/cp2k262/commonmatcher.py
@@ -19,6 +19,7 @@ class CommonMatcher(object):
# Repeating regex definitions
self.parser_context = parser_context
+ self.backend = parser_context.caching_backend
self.file_service = parser_context.file_service
self.cache_service = parser_context.cache_service
self.regex_f = "-?\d+\.\d+(?:E(?:\+|-)\d+)?" # Regex for a floating point value
@@ -26,7 +27,6 @@ class CommonMatcher(object):
self.regex_word = "[^\s]+" # Regex for a single word. Can contain anything else but whitespace
self.section_method_index = None
self.section_system_index = None
- self.forces = None
#=======================================================================
# Cache levels
@@ -34,15 +34,6 @@ class CommonMatcher(object):
'x_cp2k_atoms': CachingLevel.ForwardAndCache,
'section_XC_functionals': CachingLevel.ForwardAndCache,
'self_interaction_correction_method': CachingLevel.Cache,
- 'x_cp2k_section_md_coordinates': CachingLevel.Cache,
- 'x_cp2k_section_md_coordinate_atom': CachingLevel.Cache,
- 'x_cp2k_md_coordinate_atom_string': CachingLevel.Cache,
- 'x_cp2k_md_coordinate_atom_float': CachingLevel.Cache,
-
- 'x_cp2k_section_md_forces': CachingLevel.Cache,
- 'x_cp2k_section_md_force_atom': CachingLevel.Cache,
- 'x_cp2k_md_force_atom_string': CachingLevel.Cache,
- 'x_cp2k_md_force_atom_float': CachingLevel.Cache,
}
#=======================================================================
@@ -135,15 +126,16 @@ class CommonMatcher(object):
)
# SimpleMatcher for an SCF wavefunction optimization
- def scf(self):
+ def quickstep_calculation(self):
return SM( " SCF WAVEFUNCTION OPTIMIZATION",
+ sections=["x_cp2k_section_quickstep_calculation"],
subMatchers=[
SM( r" Trace\(PS\):",
- sections=["section_scf_iteration"],
+ sections=["x_cp2k_section_scf_iteration"],
repeats=True,
subMatchers=[
- SM( r" Exchange-correlation energy:\s+(?P<energy_XC_scf_iteration__hartree>{})".format(self.regex_f)),
- SM( r"\s+\d+\s+\S+\s+{0}\s+{0}\s+{0}\s+(?P<energy_total_scf_iteration__hartree>{0})\s+(?P<energy_change_scf_iteration__hartree>{0})".format(self.regex_f)),
+ SM( r" Exchange-correlation energy:\s+(?P<x_cp2k_energy_XC_scf_iteration__hartree>{})".format(self.regex_f)),
+ SM( r"\s+\d+\s+\S+\s+{0}\s+{0}\s+{0}\s+(?P<x_cp2k_energy_total_scf_iteration__hartree>{0})\s+(?P<x_cp2k_energy_change_scf_iteration__hartree>{0})".format(self.regex_f)),
]
),
SM( r" \*\*\* SCF run converged in\s+(\d+) steps \*\*\*",
@@ -154,22 +146,25 @@ class CommonMatcher(object):
otherMetaInfo=["single_configuration_calculation_converged"],
adHoc=self.adHoc_single_point_not_converged()
),
- SM( r" Electronic kinetic energy:\s+(?P<electronic_kinetic_energy__hartree>{})".format(self.regex_f)),
+ SM( r" Electronic kinetic energy:\s+(?P<x_cp2k_electronic_kinetic_energy__hartree>{})".format(self.regex_f)),
SM( r" **************************** NUMERICAL STRESS ********************************".replace("*", "\*"),
+ # endReStr=" **************************** NUMERICAL STRESS END *****************************".replace("*", "\*"),
adHoc=self.adHoc_stress_calculation(),
),
- SM( r" ENERGY\| Total FORCE_EVAL \( \w+ \) energy \(a\.u\.\):\s+(?P<energy_total__hartree>{0})".format(self.regex_f)),
+ SM( r" ENERGY\| Total FORCE_EVAL \( \w+ \) energy \(a\.u\.\):\s+(?P<x_cp2k_energy_total__hartree>{0})".format(self.regex_f),
+ otherMetaInfo=["energy_total"],
+ ),
SM( r" ATOMIC FORCES in \[a\.u\.\]"),
SM( r" # Atom Kind Element X Y Z",
adHoc=self.adHoc_atom_forces(),
- otherMetaInfo=["atom_forces"],
+ otherMetaInfo=["atom_forces", "x_cp2k_atom_forces"],
),
SM( r" (?:NUMERICAL )?STRESS TENSOR \[GPa\]",
- sections=["section_stress_tensor"],
- otherMetaInfo=["stress_tensor"],
+ sections=["x_cp2k_section_stress_tensor"],
subMatchers=[
SM( r"\s+X\s+Y\s+Z",
- adHoc=self.adHoc_stress_tensor()
+ adHoc=self.adHoc_stress_tensor(),
+ otherMetaInfo=["stress_tensor", "section_stress_tensor"],
),
SM( " 1/3 Trace\(stress tensor\):\s+(?P<x_cp2k_stress_tensor_one_third_of_trace__GPa>{})".format(self.regex_f)),
SM( " Det\(stress tensor\)\s+:\s+(?P<x_cp2k_stress_tensor_determinant__GPa3>{})".format(self.regex_f)),
@@ -181,7 +176,7 @@ class CommonMatcher(object):
)
# SimpleMatcher for an SCF wavefunction optimization
- def quickstep(self):
+ def quickstep_header(self):
return SM(
" MODULE QUICKSTEP: ATOMIC COORDINATES IN angstrom",
forwardMatch=True,
@@ -195,10 +190,6 @@ class CommonMatcher(object):
#===========================================================================
# onClose triggers
- def onClose_section_scf_iteration(self, backend, gIndex, section):
- """Keep track of how many SCF iteration are made."""
- self.cache_service["number_of_scf_iterations"] += 1
-
def onClose_x_cp2k_section_total_numbers(self, backend, gIndex, section):
"""Keep track of how many SCF iteration are made."""
number_of_atoms = section["x_cp2k_atoms"][0]
@@ -254,13 +245,14 @@ class CommonMatcher(object):
let's get it dynamically just in case there's something wrong.
"""
self.section_system_index = gIndex
- if self.forces is not None:
- backend.addArrayValues("atom_forces", self.forces, unit="forceAu")
- self.forces = None
+ # if self.forces is not None:
+ # backend.addArrayValues("atom_forces", self.forces, unit="forceAu")
+ # self.forces = None
self.cache_service.push_value("number_of_atoms")
self.cache_service.push_array_values("simulation_cell", unit="angstrom")
self.cache_service.push_array_values("configuration_periodic_dimensions")
self.cache_service.push_array_values("atom_positions", unit="angstrom")
+ # self.cache_service.push_array_values("atom_forces", unit="forceAu")
self.cache_service.push_array_values("atom_labels")
def onClose_section_single_configuration_calculation(self, backend, gIndex, section):
@@ -321,7 +313,8 @@ class CommonMatcher(object):
# If anything found, push the results to the correct section
if len(force_array) != 0:
- self.forces = force_array
+ # self.cache_service["atom_forces"] = force_array
+ self.backend.addArrayValues("x_cp2k_atom_forces", force_array, unit="forceAu")
return wrapper
@@ -334,7 +327,7 @@ class CommonMatcher(object):
row2 = [float(x) for x in parser.fIn.readline().split()[-3:]]
row3 = [float(x) for x in parser.fIn.readline().split()[-3:]]
stress_array = np.array([row1, row2, row3])
- parser.backend.addArrayValues("stress_tensor", stress_array, unit="GPa")
+ parser.backend.addArrayValues("x_cp2k_stress_tensor", stress_array, unit="GPa")
return wrapper
@@ -369,14 +362,14 @@ class CommonMatcher(object):
"""Called when the SCF cycle of a single point calculation has converged.
"""
def wrapper(parser):
- parser.backend.addValue("single_configuration_calculation_converged", True)
+ parser.backend.addValue("x_cp2k_quickstep_converged", True)
return wrapper
def adHoc_single_point_not_converged(self):
"""Called when the SCF cycle of a single point calculation did not converge.
"""
def wrapper(parser):
- parser.backend.addValue("single_configuration_calculation_converged", False)
+ parser.backend.addValue("x_cp2k_quickstep_converged", False)
return wrapper
def adHoc_x_cp2k_section_quickstep_atom_information(self):
@@ -420,6 +413,11 @@ class CommonMatcher(object):
return wrapper
+ def debug(self):
+ def wrapper(parser):
+ print "FOUND"
+ return wrapper
+
#===========================================================================
def getOnCloseTriggers(self):
"""
diff --git a/parser/parser-cp2k/cp2kparser/versions/cp2k262/geooptparser.py b/parser/parser-cp2k/cp2kparser/versions/cp2k262/geooptparser.py
index e9b2d8e189b158c31ce602a925a878b09bb59674..c3a49e883645b82ed1f6e62c1ce462ac5917401d 100644
--- a/parser/parser-cp2k/cp2kparser/versions/cp2k262/geooptparser.py
+++ b/parser/parser-cp2k/cp2kparser/versions/cp2k262/geooptparser.py
@@ -6,6 +6,8 @@ import cp2kparser.generic.csvparsing
from nomadcore.caching_backend import CachingLevel
import logging
import ase.io
+import numpy as np
+import math
logger = logging.getLogger("nomad")
@@ -30,80 +32,83 @@ class CP2KGeoOptParser(MainHierarchicalParser):
# Cache levels
self.caching_level_for_metaname.update({
'x_cp2k_optimization_energy': CachingLevel.ForwardAndCache,
- 'x_cp2k_optimization_step_size_convergence_limit': CachingLevel.ForwardAndCache,
- 'x_cp2k_section_geometry_optimization_information': CachingLevel.ForwardAndCache,
+ 'x_cp2k_section_geometry_optimization_step': CachingLevel.ForwardAndCache,
+ 'x_cp2k_section_quickstep_calculation': CachingLevel.ForwardAndCache,
+ 'x_cp2k_section_geometry_optimization': CachingLevel.ForwardAndCache,
+ 'x_cp2k_section_geometry_optimization_energy_reevaluation': CachingLevel.ForwardAndCache,
})
#=======================================================================
# SimpleMatchers
self.geo_opt = SM(
" *** STARTING GEOMETRY OPTIMIZATION ***".replace("*", "\*"),
- sections=["section_frame_sequence"],
+ sections=["section_frame_sequence", "x_cp2k_section_geometry_optimization"],
subMatchers=[
SM( " *** CONJUGATE GRADIENTS ***".replace("*", "\*"),
adHoc=self.adHoc_conjugate_gradient(),
- otherMetaInfo=["geometry_optimization_method"]
+ otherMetaInfo=["geometry_optimization_method"],
),
SM( " *** BFGS ***".replace("*", "\*"),
adHoc=self.adHoc_bfgs(),
- otherMetaInfo=["geometry_optimization_method"]
+ otherMetaInfo=["geometry_optimization_method"],
),
SM( " *** L-BFGS ***".replace("*", "\*"),
adHoc=self.adHoc_bfgs(),
- otherMetaInfo=["geometry_optimization_method"]
- ),
- SM( "",
- forwardMatch=True,
- sections=["section_single_configuration_calculation", "section_system", "x_cp2k_section_geometry_optimization_information"],
- subMatchers=[
- self.cm.scf(),
- SM( " -------- Informations at step"),
- SM( " Optimization Method =\s+(?P<x_cp2k_optimization_method>{})".format(self.cm.regex_word)),
- SM( " Total Energy =\s+(?P<x_cp2k_optimization_energy__hartree>{})".format(self.cm.regex_f),
- otherMetaInfo=["frame_sequence_potential_energy"]
- ),
- ],
- adHoc=self.adHoc_step()
+ otherMetaInfo=["geometry_optimization_method"],
),
+ # SM( "",
+ # forwardMatch=True,
+ # sections=["section_single_configuration_calculation", "section_system", "x_cp2k_section_geometry_optimization_step"],
+ # subMatchers=[
+ # self.cm.quickstep_calculation(),
+ # SM( " -------- Informations at step"),
+ # SM( " Optimization Method =\s+(?P<x_cp2k_optimization_method>{})".format(self.cm.regex_word)),
+ # SM( " Total Energy =\s+(?P<x_cp2k_optimization_energy__hartree>{})".format(self.cm.regex_f),
+ # otherMetaInfo=["frame_sequence_potential_energy"]
+ # ),
+ # ],
+ # otherMetaInfo=["atom_positions"],
+ # adHoc=self.adHoc_step(),
+ # ),
SM( " OPTIMIZATION STEP:",
+ endReStr=" Conv. in RMS gradients =",
name="geooptstep",
repeats=True,
- sections=["section_single_configuration_calculation", "section_system"],
+ sections=["section_system"],
subMatchers=[
SM( "",
forwardMatch=True,
- sections=["x_cp2k_section_geometry_optimization_information"],
+ sections=["x_cp2k_section_geometry_optimization_step"],
otherMetaInfo=[
"atom_positions",
],
subMatchers=[
- SM( "",
- forwardMatch=True,
- endReStr=" *** MNBRACK - NUMBER OF ENERGY EVALUATIONS :\s+{}\s+***".replace("*", "\*").format(self.cm.regex_i),
- subMatchers=[
- SM(" SCF WAVEFUNCTION OPTIMIZATION",
- forwardMatch=True,
- adHoc=self.debug(),
- repeats=True,
- subMatchers=[
- self.cm.scf(),
- ]
- )
- ]
- ),
- SM( "",
- forwardMatch=True,
- endReStr=" *** BRENT - NUMBER OF ENERGY EVALUATIONS :\s+{}\s+***".replace("*", "\*").format(self.cm.regex_i),
- subMatchers=[
- SM(" SCF WAVEFUNCTION OPTIMIZATION",
- forwardMatch=True,
- repeats=True,
- subMatchers=[
- self.cm.scf(),
- ]
- )
- ]
- ),
+ # SM( "",
+ # forwardMatch=True,
+ # endReStr=" *** MNBRACK - NUMBER OF ENERGY EVALUATIONS :\s+{}\s+***".replace("*", "\*").format(self.cm.regex_i),
+ # subMatchers=[
+ # SM(" SCF WAVEFUNCTION OPTIMIZATION",
+ # forwardMatch=True,
+ # repeats=True,
+ # subMatchers=[
+ # self.cm.quickstep_calculation(),
+ # ]
+ # )
+ # ]
+ # ),
+ # SM( "",
+ # forwardMatch=True,
+ # endReStr=" *** BRENT - NUMBER OF ENERGY EVALUATIONS :\s+{}\s+***".replace("*", "\*").format(self.cm.regex_i),
+ # subMatchers=[
+ # SM(" SCF WAVEFUNCTION OPTIMIZATION",
+ # forwardMatch=True,
+ # repeats=True,
+ # subMatchers=[
+ # self.cm.quickstep_calculation(),
+ # ]
+ # )
+ # ]
+ # ),
SM( " -------- Informations at step"),
SM( " Optimization Method =\s+(?P<x_cp2k_optimization_method>{})".format(self.cm.regex_word)),
SM( " Total Energy =\s+(?P<x_cp2k_optimization_energy__hartree>{})".format(self.cm.regex_f),
@@ -135,6 +140,13 @@ class CP2KGeoOptParser(MainHierarchicalParser):
adHoc=self.adHoc_geo_opt_converged(),
otherMetaInfo=["geometry_optimization_converged"]
),
+ SM( " Reevaluating energy at the minimum",
+ sections=["x_cp2k_section_geometry_optimization_energy_reevaluation", "section_system"],
+ subMatchers=[
+ self.cm.quickstep_calculation(),
+ ],
+ adHoc=self.adHoc_step()
+ ),
],
)
@@ -150,7 +162,7 @@ class CP2KGeoOptParser(MainHierarchicalParser):
sections=["section_method"],
subMatchers=[
self.cm.header(),
- self.cm.quickstep(),
+ self.cm.quickstep_header(),
],
),
self.geo_opt
@@ -159,11 +171,18 @@ class CP2KGeoOptParser(MainHierarchicalParser):
#===========================================================================
# onClose triggers
- def onClose_section_frame_sequence(self, backend, gIndex, section):
+ def onClose_x_cp2k_section_geometry_optimization(self, backend, gIndex, section):
+
+ # Get the re-evaluated energy and add it to frame_sequence_potential_energy
+ reeval = section["x_cp2k_section_geometry_optimization_energy_reevaluation"][0]
+ quickstep = reeval["x_cp2k_section_quickstep_calculation"][0]
+ energy = quickstep["x_cp2k_energy_total"]
+ self.cache_service["frame_sequence_potential_energy"].append(energy[0])
+
self.cache_service.push_value("number_of_frames_in_sequence")
self.cache_service.push_array_values("frame_sequence_potential_energy")
- opt_section = section["x_cp2k_section_geometry_optimization_information"]
+ opt_section = section["x_cp2k_section_geometry_optimization_step"]
if opt_section is not None:
opt_section = opt_section[-1]
geo_limit = opt_section["x_cp2k_optimization_step_size_convergence_limit"]
@@ -176,10 +195,10 @@ class CP2KGeoOptParser(MainHierarchicalParser):
def onClose_section_sampling_method(self, backend, gIndex, section):
self.backend.addValue("sampling_method", "geometry_optimization")
- def onClose_x_cp2k_section_geometry_optimization_information(self, backend, gIndex, section):
- energy = section["x_cp2k_optimization_energy"][0]
- # backend.addValue("energy_total", energy)
- self.cache_service["frame_sequence_potential_energy"].append(energy)
+ def onClose_x_cp2k_section_geometry_optimization_step(self, backend, gIndex, section):
+ energy = section["x_cp2k_optimization_energy"]
+ if energy is not None:
+ self.cache_service["frame_sequence_potential_energy"].append(energy[0])
def onClose_section_method(self, backend, gIndex, section):
traj_file = self.file_service.get_file_by_id("trajectory")
@@ -230,7 +249,6 @@ class CP2KGeoOptParser(MainHierarchicalParser):
output file. Here further information is gathered from external files.
"""
def wrapper(parser):
- # print "STEP"
self.cache_service["number_of_frames_in_sequence"] += 1
# Get the next position from the trajectory file
diff --git a/parser/parser-cp2k/cp2kparser/versions/cp2k262/singlepointparser.py b/parser/parser-cp2k/cp2kparser/versions/cp2k262/singlepointparser.py
index 709210e77d52d4ddc35ec909c422d225dd619e44..44dfb53473559bf1ffb9df41b7b8ad1be1926d77 100644
--- a/parser/parser-cp2k/cp2kparser/versions/cp2k262/singlepointparser.py
+++ b/parser/parser-cp2k/cp2kparser/versions/cp2k262/singlepointparser.py
@@ -1,7 +1,9 @@
from nomadcore.simple_parser import SimpleMatcher as SM
from nomadcore.baseclasses import MainHierarchicalParser
from singlepointforceparser import CP2KSinglePointForceParser
+from nomadcore.caching_backend import CachingLevel
from commonmatcher import CommonMatcher
+from cp2kparser.generic.utils import try_to_add_value, try_to_add_array_values
import logging
logger = logging.getLogger("nomad")
@@ -18,6 +20,16 @@ class CP2KSinglePointParser(MainHierarchicalParser):
super(CP2KSinglePointParser, self).__init__(file_path, parser_context)
self.setup_common_matcher(CommonMatcher(parser_context))
+ #=======================================================================
+ # Cache levels
+ self.caching_level_for_metaname.update({
+ 'x_cp2k_energy_total_scf_iteration': CachingLevel.ForwardAndCache,
+ 'x_cp2k_energy_XC_scf_iteration': CachingLevel.ForwardAndCache,
+ 'x_cp2k_energy_change_scf_iteration': CachingLevel.ForwardAndCache,
+ 'x_cp2k_stress_tensor': CachingLevel.ForwardAndCache,
+ 'x_cp2k_section_stress_tensor': CachingLevel.ForwardAndCache,
+ })
+
#=======================================================================
# SimpleMatchers
self.root_matcher = SM("",
@@ -26,8 +38,8 @@ class CP2KSinglePointParser(MainHierarchicalParser):
otherMetaInfo=["atom_forces"],
subMatchers=[
self.cm.header(),
- self.cm.quickstep(),
- self.cm.scf()
+ self.cm.quickstep_header(),
+ self.cm.quickstep_calculation(),
]
)
@@ -51,7 +63,28 @@ class CP2KSinglePointParser(MainHierarchicalParser):
# iterations is given. E.g. in geometry optimization there are multiple
# scf calculations so this loses it's meaning sort of.
self.cache_service.push_value("number_of_scf_iterations")
- self.cache_service["number_of_scf_iterations"] = 0
+
+ def onClose_x_cp2k_section_scf_iteration(self, backend, gIndex, section):
+ """Keep track of how many SCF iteration are made."""
+ self.cache_service["number_of_scf_iterations"] += 1
+ gId = backend.openSection("section_scf_iteration")
+ try_to_add_value(backend, section, "x_cp2k_energy_total_scf_iteration", "energy_total_scf_iteration")
+ try_to_add_value(backend, section, "x_cp2k_energy_XC_scf_iteration", "energy_XC_scf_iteration")
+ try_to_add_value(backend, section, "x_cp2k_energy_change_scf_iteration", "energy_change_scf_iteration")
+ backend.closeSection("section_scf_iteration", gId)
+
+ def onClose_x_cp2k_section_quickstep_calculation(self, backend, gIndex, section):
+ """"""
+ try_to_add_value(backend, section, "x_cp2k_energy_total", "energy_total")
+ try_to_add_value(backend, section, "x_cp2k_electronic_kinetic_energy", "electronic_kinetic_energy")
+ try_to_add_value(backend, section, "x_cp2k_quickstep_converged", "single_configuration_calculation_converged")
+ try_to_add_array_values(backend, section, "x_cp2k_atom_forces", "atom_forces")
+
+ def onClose_x_cp2k_section_stress_tensor(self, backend, gIndex, section):
+ """"""
+ gId = backend.openSection("section_stress_tensor")
+ try_to_add_array_values(backend, section, "x_cp2k_stress_tensor", "stress_tensor")
+ backend.closeSection("section_stress_tensor", gId)
#===========================================================================
# adHoc functions
diff --git a/src/main/scala/eu/nomad_lab/parsers/Cp2kParser.scala b/src/main/scala/eu/nomad_lab/parsers/Cp2kParser.scala
index 7ae2929b8ca7252e651ea611c441cbae4cfbeefa..3b5361dc1f2dda7b2c11063742adab169b8dfd5f 100644
--- a/src/main/scala/eu/nomad_lab/parsers/Cp2kParser.scala
+++ b/src/main/scala/eu/nomad_lab/parsers/Cp2kParser.scala
@@ -42,6 +42,7 @@ object Cp2kParser extends SimpleExternalParserGenerator(
"parser-cp2k/cp2kparser/generic/inputparsing.py",
"parser-cp2k/cp2kparser/generic/configurationreading.py",
"parser-cp2k/cp2kparser/generic/csvparsing.py",
+ "parser-cp2k/cp2kparser/generic/utils.py",
"parser-cp2k/cp2kparser/versions/__init__.py",
"parser-cp2k/cp2kparser/versions/versionsetup.py",
"parser-cp2k/cp2kparser/versions/cp2k262/__init__.py",
diff --git a/test/unittests/cp2k_2.6.2/run_tests.py b/test/unittests/cp2k_2.6.2/run_tests.py
index eac9b2f0da1e9ad8a75d99b433f460e5fd142be7..28d467a831b7591b409dd89a535ac382ed696767 100644
--- a/test/unittests/cp2k_2.6.2/run_tests.py
+++ b/test/unittests/cp2k_2.6.2/run_tests.py
@@ -18,15 +18,19 @@ from cp2kparser import CP2KParser
from nomadcore.unit_conversion.unit_conversion import convert_unit
# Setup the logger so that it doesn't spam messages during tests
-logging.basicConfig(level=logging.DEBUG,
- format=('%(filename)s: '
- '%(levelname)s: '
- '%(funcName)s(): '
- '%(lineno)d:\t'
- '%(message)s')
- )
+logging.basicConfig(
+ level=logging.DEBUG,
+ format=(
+ '%(filename)s: '
+ '%(levelname)s: '
+ '%(funcName)s(): '
+ '%(lineno)d:\t'
+ '%(message)s'
+ )
+)
logger = logging.getLogger("nomad")
logger.setLevel(logging.CRITICAL)
+logging.getLogger("nomadcore.caching_backend").setLevel(logging.CRITICAL)
#===============================================================================
@@ -42,7 +46,7 @@ def get_results(folder, metainfo_to_keep=None):
"""
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, folder, "unittest.out")
- parser = CP2KParser(filename, metainfo_to_keep)
+ parser = CP2KParser(filename, None)
results = parser.parse()
return results
@@ -50,7 +54,7 @@ def get_results(folder, metainfo_to_keep=None):
#===============================================================================
def get_result(folder, metaname, optimize=True):
if optimize:
- results = get_results(folder, metaname)
+ results = get_results(folder, None)
else:
results = get_results(folder)
result = results[metaname]
@@ -298,7 +302,7 @@ class TestEnergyForce(unittest.TestCase):
self.assertTrue(np.array_equal(result, expected_result))
def test_atom_forces(self):
- atomic_forces = self.results["atom_forces"]
+ result = self.results["atom_forces"]
expected_result = convert_unit(
np.array([
[0.00000000, 0.00000000, 0.00000000],
@@ -312,7 +316,7 @@ class TestEnergyForce(unittest.TestCase):
]),
"forceAu"
)
- self.assertTrue(np.array_equal(atomic_forces, expected_result))
+ self.assertTrue(np.array_equal(result, expected_result))
def test_atom_label(self):
atom_labels = self.results["atom_labels"]
@@ -486,13 +490,13 @@ class TestGeoOpt(unittest.TestCase):
result = self.results["frame_sequence_potential_energy"]
expected_result = convert_unit(
np.array([
- -17.1488237635,
-17.1534159246,
-17.1941015290,
-17.2092321965,
-17.2097667733,
-17.2097743028,
-17.2097743229,
+ -17.20977820662248,
]),
"hartree"
)
@@ -527,9 +531,8 @@ class TestGeoOpt(unittest.TestCase):
class TestGeoOptTrajFormats(unittest.TestCase):
def test_xyz(self):
+
result = get_result("geo_opt/geometry_formats/xyz", "atom_positions", optimize=True)
- # print "XYZ"
- # print result
expected_start = convert_unit(
np.array([
[12.2353220000, 1.3766420000, 10.8698800000],
@@ -597,17 +600,17 @@ if __name__ == '__main__':
logger.setLevel(logging.ERROR)
suites = []
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestErrors))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestXCFunctional))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestEnergyForce))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestStressTensorMethods))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestSelfInteractionCorrectionMethod))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestConfigurationPeriodicDimensions))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestSCFConvergence))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestForceFiles))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestPreprocessor))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestGeoOpt))
- # suites.append(unittest.TestLoader().loadTestsFromTestCase(TestGeoOptTrajFormats))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestErrors))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestXCFunctional))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestEnergyForce))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestStressTensorMethods))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestSelfInteractionCorrectionMethod))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestConfigurationPeriodicDimensions))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestSCFConvergence))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestForceFiles))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestPreprocessor))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestGeoOpt))
+ suites.append(unittest.TestLoader().loadTestsFromTestCase(TestGeoOptTrajFormats))
suites.append(unittest.TestLoader().loadTestsFromTestCase(TestGeoOptOptimizers))
alltests = unittest.TestSuite(suites)
unittest.TextTestRunner(verbosity=0).run(alltests)