Esempio n. 1
0
    def test_equality(self):
        """ Test that __eq__ works as expected """
        c1 = Crystal.from_database("Pu-alpha")
        c2 = deepcopy(c1)
        self.assertEqual(c1, c2)

        c3 = Crystal.from_database("Pu-epsilon")
        self.assertNotEqual(c1, c3)
Esempio n. 2
0
def test_equality():
    """Test that __eq__ works as expected"""
    c1 = Crystal.from_database("Pu-alpha")
    c2 = deepcopy(c1)
    assert c1 == c2

    c3 = Crystal.from_database("Pu-epsilon")
    assert c1 != c3
Esempio n. 3
0
def test_powdersim_peak_alignment():
    """ Test that the diffraction peaks align with what is expected. """
    crystal = Crystal.from_database("C")

    for reflection in [(0, 1, 1), (1, 2, 0), (-1, 2, 0)]:
        qknown = np.linalg.norm(crystal.scattering_vector((0, 1, 1)))

        # Range of scattering vectors is tightly centered around a particular reflection
        # So that the maximum of the diffraction pattern MUST be at reflection (010)
        q = np.linspace(qknown - 0.1, qknown + 0.1, 256)
        pattern = powdersim(Crystal.from_database("C"), q)
        assert abs(q[np.argmax(pattern)] - qknown) < q[1] - q[0]
Esempio n. 4
0
    def test_constructors(self):
        """ Test Supercell constructors for varyous 'builtin' structures """
        for name in islice(Crystal.builtins, 20):
            with self.subTest(name):
                s = Crystal.from_database(name).supercell(2, 2, 2)

                self.assertEqual(len(s), 8 * len(s.crystal))
Esempio n. 5
0
def get_pendulossung(name='Si', miller=[0, 0, 0], keV=200, opt='p'):
    ''' give the theorertical 2-beam approximation Pendullosung thickness
    - `name`    : compound
    - `miller`  : [h,k,l]
    - `keV`     : wavelength (keV)
    RETURN
    - xi : Pendullosung thickness (A)
    '''
    # compute structure factor
    from crystals import Crystal
    crys = Crystal.from_database(name)
    lat_vec = crys.reciprocal_vectors
    pattern = np.array(
        [list(a.coords_fractional) + [a.atomic_number] for a in crys.atoms])
    hkl, Fhkl = structure_factor3D(pattern,
                                   lat_vec,
                                   hklMax=max(miller),
                                   sym=0,
                                   v='')
    ax, by, cz = crys.lattice_parameters[:3]
    Vcell = crys.volume
    # compute Pendullosung
    h, k, l = miller
    Ug, K = np.abs(Fhkl[h, k, l]) / Vcell, 1 / scatf.wavelength(keV)
    xi = K / Ug
    if 'p' in opt:
        print(green + "\tPendullosung thickness " + name + '[%d%d%d]' %
              (h, k, l) + black)
        print('%-5s= %.2f\n%-5s= %.2f\n%-5s= %.2f' %
              ('K', K, 'Ug', Ug, 'xi', xi))
    return xi
Esempio n. 6
0
def test_return_shape():
    """ Test that the return shape of pelectrostatic is the same as input arrays """
    crystal = Crystal.from_database("C")
    xx, yy = np.meshgrid(np.linspace(-10, 10, 32), np.linspace(-10, 10, 32))
    potential = pelectrostatic(crystal, xx, yy)

    assert xx.shape == potential.shape
Esempio n. 7
0
    def test_simulation_3_peaks(self):
        """ 
        Test calibration from simulation, down to 1% error . Peaks (200) and (220) from monoclinic VO2 are used,
        """
        s = np.linspace(0.11, 0.8, 1024)
        q = 4 * np.pi * s
        c = Crystal.from_database("vo2-m1")
        I = powdersim(c, s)

        peak1 = (2, 0, 0)
        Gx1, Gy1, Gz1 = c.scattering_vector(peak1)
        q1 = np.sqrt(Gx1 ** 2 + Gy1 ** 2 + Gz1 ** 2)
        arr_index1 = np.argmin(np.abs(q - q1))

        peak2 = (2, 2, 0)
        Gx2, Gy2, Gz2 = c.scattering_vector(peak2)
        q2 = np.sqrt(Gx2 ** 2 + Gy2 ** 2 + Gz2 ** 2)
        arr_index2 = np.argmin(np.abs(q - q2))

        peak3 = (3, 0, -2)
        Gx2, Gy2, Gz2 = c.scattering_vector(peak3)
        q3 = np.sqrt(Gx2 ** 2 + Gy2 ** 2 + Gz2 ** 2)
        arr_index3 = np.argmin(np.abs(q - q3))

        calibrated = powder_calq(
            I,
            c,
            peak_indices=(arr_index1, arr_index2, arr_index3),
            miller_indices=(peak1, peak2, peak3),
        )

        self.assertTupleEqual(I.shape, calibrated.shape)
        self.assertTrue(np.allclose(q, calibrated, rtol=0.01))
Esempio n. 8
0
def gen_xyz(file, n=[0, 0, 1], rep=[1, 1, 1], pad=0, xyz='', **kwargs):
    ''' convert cif file into autoslic .xyz input file
    - file : cif_file
    - rep : super cell repeat
    - n : reorient of the z axis into n
    - pad : amount of padding on each side (in unit of super cell size)
    '''
    if isinstance(file, str):
        tail = ''.join(np.array(n, dtype=str)) + '.xyz'
        if file.split('.')[-1] == 'cif':
            crys = Crystal.from_cif(file)
            if not xyz: xyz = file.replace('.cif', tail)
        elif sum(np.array(list(Crystal.builtins)) == file):
            crys = Crystal.from_database(file)
            if not xyz: xyz = file + tail
        lat_vec = np.array(crys.lattice_vectors)
        lat_params = crys.lattice_parameters[:3]
        pattern = np.array([[a.atomic_number] + list(a.coords_cartesian) +
                            [a.occupancy, 1.0] for a in crys.atoms])
    else:
        if not xyz: raise Exception('xyz filename required')
        pattern = file
    pattern, lat = make_xyz(xyz,
                            pattern,
                            lat_vec,
                            lat_params,
                            n=n,
                            pad=pad,
                            rep=rep,
                            **kwargs)
    npy_file = xyz.replace('.xyz', '.npy')
    np.save(npy_file, [lat, pattern])
    print(colors.green + 'binary coords file saved :' + colors.yellow +
          npy_file + colors.black)
Esempio n. 9
0
 def setUp(self):
     self.crystal = Crystal.from_database("C")
     self.reflections = list(combinations_with_replacement(range(-3, 4), 3))
     self.intensities = [
         np.abs(structure_factor(self.crystal, *reflection))**2
         for reflection in self.reflections
     ]
Esempio n. 10
0
def test_side_effects():
    """ Test that mesh arrays are not written to in pelectrostatic """
    crystal = Crystal.from_database("C")
    xx, yy = np.meshgrid(np.linspace(-10, 10, 32), np.linspace(-10, 10, 32))
    xx.setflags(write=False)
    yy.setflags(write=False)
    potential = pelectrostatic(crystal, xx, yy)
Esempio n. 11
0
def Li_rots():
    crys = Crystal.from_database('Li')
    coords = np.array([a.coords_cartesian for a in crys.atoms])

    # files = rcc.rotate_xyz(crys,Nrot=8,name='dat/Lithium/rots/',opt='p')
    files = rcc.orient_crystal(coords,ez=[0,0,1],n_u=[0,,1])
    for file in files[:4] : rcc.show_grid(file,title=file,equal=1)#,xyTicks=3.49,xylims=[0,100,0,100])
Esempio n. 12
0
def test_reciprocal_symmetry_operations(name):
    """Test that the reciprocal symmetry operations output makes sense"""
    identity = np.eye(4)

    c = Crystal.from_database(name)
    symops = c.reciprocal_symmetry_operations()
    assert np.allclose(identity, symops[0])
Esempio n. 13
0
 def test_primitive_for_builtins(self):
     """ Test that all built-in crystal have a primitive cell """
     for name in Crystal.builtins:
         with self.subTest(name):
             c = Crystal.from_database(name)
             prim = c.primitive(symprec=0.1)
             self.assertLessEqual(len(prim), len(c))
Esempio n. 14
0
    def test_builtins(self):
        """ Test that all names in Crystal.builtins build without errors,
        and that Crystal.source is correctly recorded. """
        for name in Crystal.builtins:
            with self.subTest(name):
                c = Crystal.from_database(name)

                self.assertIn(name, c.source)
Esempio n. 15
0
def import_crys(file):
    if file.split('.')[-1] == 'cif':
        crys = Crystal.from_cif(file)
    elif sum(np.array(list(Crystal.builtins)) == file):
        crys = Crystal.from_database(file)
    else:
        raise Exception('cannot import %s' % file)
    return crys
Esempio n. 16
0
 def test_chemical_composition_add_to_unity(self):
     """ Test that AtomicStructure.chemical_composition always adds up to 1 """
     # Faster to create a large atomic structure from a Crystal object
     # Testing for 10 crystal structures only
     for name in islice(Crystal.builtins, 10):
         with self.subTest("Chemical composition: " + name):
             structure = AtomicStructure(atoms=Crystal.from_database(name))
             self.assertAlmostEqual(sum(structure.chemical_composition.values()), 1)
Esempio n. 17
0
    def test_reciprocal_symmetry_operations(self):
        """ Test that the reciprocal symmetry operations output makes sense """
        identity = np.eye(4)

        for name in Crystal.builtins:
            with self.subTest(name):
                c = Crystal.from_database(name)
                symops = c.reciprocal_symmetry_operations()
                self.assertTrue(np.allclose(identity, symops[0]))
Esempio n. 18
0
def Li_xyz(path,n=[0,0,1],dopt=1,lfact=1.0,wobble=0,tail=''):
    file    = path+'Li%s%s.xyz' %(''.join(np.array(n,dtype=str)),tail)
    crys    = Crystal.from_database('Li')
    pattern = np.array([
        [a.atomic_number]+list(lfact*a.coords_cartesian)+[a.occupancy,wobble] for a in crys.atoms])
    # lat_params = tuple(lfact*np.array(crys.lattice_parameters[:3]))
    lat_params = lfact*np.array(crys.lattice_vectors)
    coords,lat = rcc.make_xyz(file,pattern,lat_params,n,fmt='%.4f',dopt='s')
    return file
def test_shape_and_dtype():
    """Test that output of structure_factor is same shape as input,
    and that the dtype is complex"""
    crystal = Crystal.from_database(next(iter(Crystal.builtins)))
    h, k, l = np.meshgrid([1, 2, 3], [1, 2, 3], [1, 2, 3])
    sf = structure_factor(crystal, h, k, l)

    assert sf.shape == h.shape
    assert sf.dtype == complex
Esempio n. 20
0
def test_str_vs_repr(name):
    """Test that str and repr are workign as expected"""
    c = Crystal.from_database(name)

    # If small crystal, repr and str should be the same
    if len(c) <= 10:
        assert repr(c) == str(c)
    else:
        assert repr(c) != str(c)
Esempio n. 21
0
def test_ase_atoms_back_and_forth(name):
    """ Test conversion to and from ase Atoms """
    crystal = Crystal.from_database(name)
    to_ase = crystal.to_ase()
    crystal2 = Crystal.from_ase(to_ase)

    # ase has different handling of coordinates which can lead to
    # rounding beyond 1e-3. Therefore, we cannot compare directly sets
    # assertSetEqual(set(crystal), set(crystal2))
    assert len(crystal) == len(crystal2)
Esempio n. 22
0
def test_cif_writer_idempotence(name):
    """ Test that conversion to CIF of a structure loaded from CIF is idempotent. """
    # Testing on all built-in structure assures us that corner cases
    # are taken care of.
    cryst = Crystal.from_database(name)
    with tempfile.TemporaryDirectory() as temp_dir:
        f = Path(temp_dir) / "temp.cif"
        cryst.to_cif(f)
        cryst2 = Crystal.from_cif(f)
        assert cryst == cryst2
Esempio n. 23
0
def test_lattice_parameters_back_and_forth(name):
    """Test that the conversion between lattice vectors and lattice parameters
    is working"""

    c = Crystal.from_database(name)
    lv1 = c.lattice_vectors
    params = c.lattice_parameters
    lv2 = lattice_vectors_from_parameters(*params)

    assert np.allclose(lv1, lv2)
Esempio n. 24
0
    def test_output_shape(self):
        """ Test that the output shape is as expected. """
        # Simulate a powder pattern first
        crystal = Crystal.from_database("vo2-m1")
        q = np.linspace(0.2, 10, 1024)
        I = powdersim(crystal=crystal, q=q)

        radii = np.arange(0.1, 5, 1 / 50)
        pairdist = patterson(q=q, I=I, crystal=crystal, radii=radii)

        self.assertEqual(radii.shape, pairdist.shape)
Esempio n. 25
0
    def test_str_vs_repr(self):
        """ Test that str and repr are workign as expected """
        for name in Crystal.builtins:
            with self.subTest(name):
                c = Crystal.from_database(name)

                # If small crystal, repr and str should be the same
                if len(c) <= 10:
                    self.assertEqual(repr(c), str(c))
                else:
                    self.assertNotEqual(repr(c), str(c))
Esempio n. 26
0
    def test_powder_calq(self):
        """ Test scattering vector calibration """
        crystal = Crystal.from_database("vo2-m1")
        self.dataset.powder_calq(crystal, (10, 100), [(1, 0, 0), (2, 0, 0)])

        # Check that shapes match
        self.assertTupleEqual(self.dataset.powder_eq().shape,
                              self.dataset.scattering_vector.shape)
        # Check that scattering_vector is strictly increasing
        self.assertTrue(
            np.all(np.greater(np.diff(self.dataset.scattering_vector), 0)))
Esempio n. 27
0
 def test_reciprocity_with_symmetry_expansion(self):
     """ Test that symmetry_reduction is reciprocal to symmetry_expansion """
     structures = ["vo2-m1", "Os", "Na"]  # , 'Nb', 'Pd', 'Zn']
     for s in structures:
         with self.subTest("Crystal " + s):
             cryst = Crystal.from_database(s)
             asym_cell = symmetry_reduction(cryst.unitcell,
                                            cryst.symmetry_operations())
             ucell = set(
                 symmetry_expansion(asym_cell, cryst.symmetry_operations()))
             self.assertEqual(set(cryst.unitcell), ucell)
Esempio n. 28
0
def test_dirax_indexing_initial_guess(name):
    """
    Test that indexing succeeds with an initial guess and very few reflections.
    """
    cryst = Crystal.from_database(name)
    # We restrict the number of reflections to a single (0,0,0); with
    # the initial guess, indexing should still succeed!
    lat, _ = index_dirax([(0, 0, 0)], initial=cryst)

    assert np.allclose(lat.lattice_parameters,
                       cryst.lattice_parameters,
                       atol=1)
Esempio n. 29
0
    def test_equality(self):
        """ Test that AtomicStructure is equal to itself but not others """
        self.assertEqual(self.structure, self.structure)
        self.assertEqual(self.structure, deepcopy(self.structure))
        self.assertNotEqual(self.structure, self.substructure)

        # Special case: make structures from Crystals
        c1 = Crystal.from_database("vo2-m1")
        c2 = deepcopy(c1)
        s1 = AtomicStructure(atoms=c1)
        s2 = AtomicStructure(atoms=c2.atoms)
        self.assertEqual(s1, s2)
Esempio n. 30
0
def test_dirax_indexing_ideal(name, bound):
    """
    Test that indexing always succeeds with an ideal
    set of reflections: no noise, no alien reflections.
    """
    cryst = Crystal.from_database(name)
    refls = [
        cryst.scattering_vector(r)
        for r in cryst.bounded_reflections(bound=bound)
    ]
    lat, hkls = index_dirax(refls)

    assert np.allclose(hkls - np.rint(hkls), 0, atol=0.001)