Chimie Théorique » scripts_chimie4psmn » DockOnSurf

import sys

import unittest

import numpy as np

from modules.dos_input import *

sys.path.extend(['../', '../modules', '../examples'])

class TestStr2Lst(unittest.TestCase):

    def test_norm_behav(self):

        self.assertEqual(str2lst('45'), [45])

        self.assertEqual(str2lst('(78, 9)'), [[78, 9]])

        self.assertEqual(str2lst('128,(135 138;141) 87 {45 68}'),

                         [128, 87, [135, 138, 141], [45, 68]])

        self.assertEqual(str2lst('3 4.5', float), [3.0, 4.5])

    def test_exceptions(self):

        self.assertRaises(AttributeError, str2lst, 6)

        self.assertRaises(ValueError, str2lst, 'hola')

        self.assertRaises(ValueError, str2lst, '3 ((6 7) 8) 4')

        self.assertRaises(ValueError, str2lst, '3 4.5')

class TestCheckInpFile(unittest.TestCase):

    def test_good(self):

        self.assertEqual(check_inp_file('cp2k.inp', 'cp2k'), None)

    def test_bad(self):

        self.assertRaises(UnboundLocalError, check_inp_file, 'cp2k.sub', 'cp2k')

class TestGoodInput(unittest.TestCase):

    read_input('good.inp')

    def test_all_good(self):

        exp_dict = {'project_name': 'example',

                    'isolated': True,

                    'screening': True,

                    'refinement': True,

                    'code': 'cp2k',

                    'batch_q_sys': 'sge',

                    'subm_script': 'cp2k.sub',

                    'relaunch_err': 'geo_not_conv',

                    'max_qw': 5,

                    'special_atoms': [('Fe1', 'Fe'), ('Fe2', 'Fe'),

                                      ('O1', 'O')],

                    'isol_inp_file': 'cp2k.inp',

                    'molec_file': 'acetic.xyz',

                    'cluster_magns': ['energy', 'moi'],

                    'num_conformers': 100,

                    'min_confs': False,

                    'screen_inp_file': 'screen.inp',

                    'surf_file': 'hematite.xyz',

                    'sites': [128, [135, 138, 141]],

                    'molec_ads_ctrs': [178, [185, 187]],

                    'molec_neigh_ctrs': [145, 45],

                    'surf_norm_vect': np.array([1.0, 0.0, 0.0]),

                    'try_disso': True,

                    'sample_points_per_angle': 4,

                    'collision_threshold': 0.9,

                    'min_coll_height': 5.2,

                    'refine_inp_file': 'refine.inp',

                    'energy_cutoff': 1.0

                    }

        self.assertEqual(read_input('good.inp'), exp_dict)

    def test_run_type(self):

        self.assertEqual(get_run_type(), (True, True, True))

    def test_code(self):

        self.assertEqual(get_code(), 'cp2k')

    def test_batch_q_sys(self):

        self.assertEqual(get_batch_q_sys(), 'sge')

    def test_subm_script(self):

        self.assertEqual(get_subm_script(), 'cp2k.sub')

    def test_project_name(self):

        self.assertEqual(get_project_name(), 'example')

    def test_relaunch_err(self):

        self.assertEqual(get_relaunch_err(), 'geo_not_conv')

    def test_max_qw(self):

        self.assertEqual(get_max_qw(), 5)

    def test_special_atoms(self):

        self.assertEqual(get_special_atoms(), [('Fe1', 'Fe'), ('Fe2', 'Fe'),

                                               ('O1', 'O')])

    def test_isol_inp_file(self):

        self.assertEqual(get_isol_inp_file(), 'cp2k.inp')

    def test_molec_file(self):

        self.assertEqual(get_molec_file(), 'acetic.xyz')

    def test_cluster_magns(self):

        self.assertEqual(get_cluster_magns(), ['energy', 'moi'])

    def test_num_conformers(self):

        self.assertEqual(get_num_conformers(), 100)

    def test_min_confs(self):

        self.assertEqual(get_min_confs(), False)

    def test_screen_inp_file(self):

        self.assertEqual(get_screen_inp_file(), 'screen.inp')

    def test_surf_file(self):

        self.assertEqual(get_surf_file(), 'hematite.xyz')

    def test_sites(self):

        self.assertEqual(get_sites(), [128, [135, 138, 141]])

    def test_molec_ads_ctrs(self):

        self.assertEqual(get_molec_ads_ctrs(), [178, [185, 187]])

    def test_molec_neigh_ctrs(self):

        self.assertEqual(get_molec_neigh_ctrs(), [145, 45])

    def test_surf_norm_vect(self):

        self.assertEqual(get_surf_norm_vect(), np.array([1.0, 0.0, 0.0]))

    def test_try_disso(self):

        self.assertEqual(get_try_disso(), True)

    def test_pts_per_angle(self):

        self.assertEqual(get_pts_per_angle(), 4)

    def test_coll_thrsld(self):

        self.assertEqual(get_coll_thrsld(), 0.9)

    def test_coll_bottom(self):

        self.assertEqual(get_min_coll_height(), 5.2)

    def test_refine_inp_file(self):

        self.assertEqual(get_refine_inp_file(), 'refine.inp')

    def test_energy_cutoff(self):

        self.assertEqual(get_energy_cutoff(), 1.0)

class TestBadInput(unittest.TestCase):

    dos_inp.read('wrong.inp')

    def test_run_type(self):

        self.assertRaises(ValueError, get_run_type)

    def test_code(self):

        self.assertRaises(ValueError, get_code)

    def test_batch_q_sys(self):

        self.assertRaises(ValueError, get_batch_q_sys)

    def test_subm_script(self):

        self.assertRaises(FileNotFoundError, get_subm_script)

    def test_relaunch_err(self):

        self.assertRaises(ValueError, get_relaunch_err)

    def test_max_qw(self):

        self.assertRaises(ValueError, get_max_qw)

    def test_special_atoms(self):

        self.assertRaises(ValueError, get_special_atoms)

    def test_isol_inp_file(self):

        self.assertRaises(FileNotFoundError, get_isol_inp_file)

    def test_cluster_magns(self):

        self.assertRaises(ValueError, get_cluster_magns)

    def test_num_conformers(self):

        self.assertRaises(ValueError, get_num_conformers)

    def test_min_confs(self):

        self.assertRaises(ValueError, get_min_confs)

    def test_screen_inp_file(self):

        self.assertRaises(FileNotFoundError, get_screen_inp_file)

    def test_surf_file(self):

        self.assertRaises(FileNotFoundError, get_surf_file)

    def test_sites(self):

        self.assertRaises(ValueError, get_sites)

    def test_molec_ads_ctrs(self):

        self.assertRaises(ValueError, get_molec_ads_ctrs)

    def test_molec_neigh_ctrs(self):

        self.assertRaises(ValueError, get_molec_neigh_ctrs)

    def test_surf_norm_vect(self):

        self.assertRaises(ValueError, get_surf_norm_vect)

    def test_try_disso(self):

        self.assertRaises(ValueError, get_try_disso)

    def test_pts_per_angle(self):

        self.assertRaises(ValueError, get_pts_per_angle)

    def test_coll_thrsld(self):

        self.assertRaises(ValueError, get_coll_thrsld)

    def test_coll_bottom(self):

        self.assertRaises(ValueError, get_min_coll_height)

    def test_refine_inp_file(self):

        self.assertRaises(FileNotFoundError, get_refine_inp_file)

    def test_energy_cutoff(self):

        self.assertRaises(ValueError, get_energy_cutoff)

if __name__ == '__main__':

    unittest.main()