Commit c8fbaf28 authored by Lauri Himanen's avatar Lauri Himanen
Browse files

Created new cp2k specific metainfo for the quickstep calculation which required some modifications.

parent f4e2a529
#===============================================================================
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])
......@@ -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):
"""
......
......@@ -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
......
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
......@@ -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",
......
......@@ -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)
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment