def test_generate_sqs_from_supercells(self):
"""Test generation of SQS structure from list of supercells"""
target_conc = {'Au': 0.5, 'Pd': 0.5}
kwargs = dict(cluster_space=self.cs,
target_concentrations=target_conc,
n_steps=500,
random_seed=42,
optimality_weight=0.0)
supercells = [self.prim.repeat((2, 2, 1)), self.prim.repeat((2, 1, 1))]
structure = generate_sqs_from_supercells(supercells=supercells,
**kwargs)
target_cv = [1., 0., 0., -1., 0., 1., 0., 0., 0., 0., 0., 0., 0.]
self.assertTrue(
np.allclose(self.cs.get_cluster_vector(structure), target_cv))
# Log output to StringIO stream
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
# Test with supercell that does not match
supercells = [self.prim]
logfile = NamedTemporaryFile(mode='w+', encoding='utf-8')
set_log_config(filename=logfile.name)
with self.assertRaises(ValueError) as cm:
generate_sqs_from_supercells(supercells=supercells, **kwargs)
logfile.seek(0)
lines = logfile.readlines()
logfile.close()
self.assertEqual(len(lines), 1)
self.assertIn('At least one supercell was not commensurate', lines[0])
self.assertIn('No supercells that may host the specified',
str(cm.exception))
def test_generate_target_from_supercells(self):
"""Test generation of a structure based on a target cluster vector and a list
of supercells"""
target_cv = [1., 0., 0., -1., 0., 1., 0., 0., 0., 0., 0., 0., 0.]
target_conc = {'Au': 0.5, 'Pd': 0.5}
kwargs = dict(cluster_space=self.cs,
target_concentrations=target_conc,
target_cluster_vector=target_cv,
n_steps=500,
random_seed=42,
optimality_weight=0.3)
supercells = [self.prim.repeat((2, 2, 1)), self.prim.repeat((2, 1, 1))]
# This should be simple enough to always work
structure = generate_target_structure_from_supercells(
supercells=supercells, **kwargs)
self.assertTrue(
np.allclose(self.cs.get_cluster_vector(structure), target_cv))
# Log output to StringIO stream
for handler in logger.handlers:
handler.close()
logger.removeHandler(handler)
# Use supercells that do not fit
supercells = [self.prim.repeat((2, 2, 1)), self.prim.repeat((3, 1, 1))]
logfile = NamedTemporaryFile(mode='w+', encoding='utf-8')
set_log_config(filename=logfile.name)
structure = generate_target_structure_from_supercells(
supercells=supercells, **kwargs)
logfile.seek(0)
lines = logfile.readlines()
logfile.close()
self.assertIn('At least one supercell was not commensurate', lines[0])
self.assertTrue(
np.allclose(self.cs.get_cluster_vector(structure), target_cv))
# Use two supercells that do not fit
supercells = [self.prim.repeat((3, 3, 1)), self.prim.repeat((3, 1, 1))]
logfile = NamedTemporaryFile(mode='w+', encoding='utf-8')
set_log_config(filename=logfile.name)
with self.assertRaises(ValueError) as cm:
generate_target_structure_from_supercells(supercells=supercells,
**kwargs)
logfile.seek(0)
lines = logfile.readlines()
logfile.close()
self.assertEqual(len(lines), 1) # Warning should be issued once
self.assertIn('At least one supercell was not commensurate', lines[0])
self.assertIn('No supercells that may host the specified',
str(cm.exception))
def test_mapping(structure,
reference=None,
expected_drmax=0.276249887,
expected_dravg=0.139034051,
expected_chemical_formula='H3Au6Pd2X5',
**kwargs):
"""
Convenience wrapper for testing mapping.
"""
if reference is None:
reference = self.reference
logfile = NamedTemporaryFile(mode='w+', encoding='utf-8')
set_log_config(filename=logfile.name)
mapped, info = map_structure_to_reference(structure, reference,
**kwargs)
self.assertEqual(len(info), 6)
self.assertAlmostEqual(info['drmax'], expected_drmax)
self.assertAlmostEqual(info['dravg'], expected_dravg)
self.assertEqual(mapped.get_chemical_formula(),
expected_chemical_formula)
logfile.seek(0)
lines = logfile.readlines()
logfile.close()
return lines, info
# Log ClusterSpace output to StringIO stream
for handler in logger.handlers:
logger.removeHandler(handler)
stream = StringIO()
stream_handler = logging.StreamHandler(stream)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
stream_handler.setLevel(logging.INFO)
cs = ClusterSpace(structure, cutoffs, symbols)
stream_handler.flush()
lines1 = stream.getvalue().split('\n')[:-1] # remove last blank line
# Log ClusterSpace output to file
for handler in logger.handlers:
logger.removeHandler(handler)
logfile = tempfile.NamedTemporaryFile(mode='w+', encoding='utf-8')
set_log_config(filename=logfile.name, level=logging.INFO)
cs = ClusterSpace(structure, cutoffs, symbols)
logfile.seek(0)
lines2 = [l.replace('\n', '') for l in logfile.readlines()]
# assert lines1 (from stringIO stream) and lines (from file stream) are equal
assert len(lines1) == len(lines2)
for l1, l2 in zip(lines1, lines2):
assert l1 == l2
"""
This example demonstrates how to generate special quasirandom structure.
"""
# Import modules
from ase import Atom
from ase.build import bulk
from icet import ClusterSpace
from icet.tools.structure_generation import (generate_sqs,
generate_sqs_from_supercells,
generate_sqs_by_enumeration,
generate_target_structure)
from icet.input_output.logging_tools import set_log_config
set_log_config(level='INFO')
# Generate SQS for binary fcc, 50 % concentration
primitive_structure = bulk('Au')
cs = ClusterSpace(primitive_structure, [8.0, 4.0], ['Au', 'Pd'])
target_concentrations = {'Au': 0.5, 'Pd': 0.5}
sqs = generate_sqs(cluster_space=cs,
max_size=8,
target_concentrations=target_concentrations)
print('Cluster vector of generated structure:', cs.get_cluster_vector(sqs))
# Generate SQS for binary fcc with specified supercells
supercells = [primitive_structure.repeat((1, 2, 4))]
sqs = generate_sqs_from_supercells(cluster_space=cs,
supercells=supercells,
n_steps=10000,
target_concentrations=target_concentrations)
import os
import unittest
import numpy as np
from ase import Atoms
from ase.build import bulk
from icet import ClusterExpansion, ClusterSpace
from icet.input_output.logging_tools import set_log_config
from mchammer.calculators import ClusterExpansionCalculator
from mchammer.ensembles import WangLandauEnsemble
from mchammer.observers.base_observer import BaseObserver
set_log_config(level=100)
class ConcreteObserver(BaseObserver):
"""Child class of BaseObserver created for testing."""
def __init__(self, interval, tag='ConcreteObserver'):
super().__init__(interval=interval, return_type=int, tag=tag)
def get_observable(self, structure):
"""Returns number of Au atoms."""
return structure.get_chemical_symbols().count('Au')
class TestEnsemble(unittest.TestCase):
"""Container for tests of the class functionality."""
def __init__(self, *args, **kwargs):
super(TestEnsemble, self).__init__(*args, **kwargs)
tests.sort()
for test in tests:
if test.endswith('__.py'):
continue
test = ScriptTestCase(filename=test)
suite.addTest(test)
if __name__ == "__main__":
from generate_structures_for_testing import create_database
create_database()
set_log_config(level='ERROR')
# Find testing dirs
main_dir = os.path.dirname(__file__)
unittest_dir = os.path.join(main_dir, 'unittest')
integration_dir = os.path.join(main_dir, 'integration')
# Collect tests
suite = unittest.TestLoader().discover(unittest_dir, pattern="*.py")
find_script_tests(suite, integration_dir)
# Run tests
ttr = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
results = ttr.run(suite)
assert len(results.failures) == 0, "At least one test failed"