Beispiel #1
0
def test1():
    print('generating graphene structure')
    graphene = GrapheneGenerator(armchair_edge_length=5,
                                 zigzag_edge_length=5)
    lattice = graphene.lattice
    print('graphene.bounds:\n{}'.format(graphene.bounds))
    print('graphene.centroid:\n{}'.format(graphene.centroid))
    print('graphene.lattice:\n{}'.format(lattice))
    print('graphene.lattice.a1:\n{}'.format(lattice.a1))
    print('graphene.lattice.a2:\n{}'.format(lattice.a2))
    print('graphene.lattice.a3:\n{}'.format(lattice.a3))
    print('graphene.lattice.orientation_matrix:\n{}'.format(
          lattice.orientation_matrix))
    print('rotating graphene')
    graphene.rotate(angle=-np.pi/2, axis='x')
    print('graphene.bounds:\n{}'.format(graphene.bounds))
    print('graphene.centroid:\n{}'.format(graphene.centroid))
    print('graphene.lattice:\n{}'.format(lattice))
    print('graphene.lattice.a1:\n{}'.format(lattice.a1))
    print('graphene.lattice.a2:\n{}'.format(lattice.a2))
    print('graphene.lattice.a3:\n{}'.format(lattice.a3))
    print('graphene.lattice.orientation_matrix:\n{}'.format(
          lattice.orientation_matrix))

    assert_true(np.allclose(lattice.angles, 3 * [90.0]))
    lattice_region = Cuboid(pmax=lattice.lengths)

    # lattice_region = Parallelepiped(u=lattice.a * xhat,
    #                                 v=lattice.b * yhat,
    #                                 w=lattice.c * zhat)
    assert_equal(lattice_region.a, lattice.a)
    assert_equal(lattice_region.b, lattice.b)
    assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    print('\nrotating lattice_region')
    lattice_region.rotate(transform_matrix=lattice.orientation_matrix)
    # assert_equal(lattice_region.a, lattice.a)
    # assert_equal(lattice_region.b, lattice.b)
    # assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    print('\ncentering lattice_region on graphene centroid')
    tvec = Vector(Point(graphene.centroid) - lattice_region.centroid)
    lattice_region.translate(tvec)
    # assert_equal(lattice_region.a, lattice.a)
    # assert_equal(lattice_region.b, lattice.b)
    # assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    bounding_box = generate_bounding_box(from_lattice=lattice,
                                         center=graphene.centroid,
                                         verbose=True)
    print('bounding_box:\n{}'.format(bounding_box))
    assert_equal(bounding_box, lattice_region)
    print('lattice_region.lengths: {}, {}, {}'.format(
          lattice_region.a, lattice_region.b, lattice_region.c))
Beispiel #2
0
def test_cuboid():
    r = Cuboid()
    assert_is_instance(r, Cuboid)
    assert_equal(r.centroid, Point([0.5, 0.5, 0.5]))
    assert_true(np.allclose(r.measure, 1.0))
    assert_true(r.contains(r.centroid))
    assert_false(r.contains([-0.1, 0, 0]))
    assert_is_instance(r.centroid, Point)
Beispiel #3
0
 def bounds(self):
     """Return bounds of `Molecules`."""
     return Cuboid(pmin=[self.x.min(),
                         self.y.min(),
                         self.z.min()],
                   pmax=[self.x.max(),
                         self.y.max(),
                         self.z.max()])
    def generate(self):
        """Generate structure data."""

        super().generate()

        if self.L0 is not None and self.fix_Lz:
            Lz_cutoff = 10 * self.L0 + 1
            region_bounds = Cuboid(pmin=Point([-np.inf, -np.inf, 0]),
                                   pmax=Point([np.inf, np.inf, Lz_cutoff]))
            self.atoms.clip_bounds(region_bounds)
    def _parse_bounding_box(self):
        self.bounding_box = Cuboid()
        for dim in ('x', 'y', 'z'):
            bounds = \
                self.header_data[' '.join([dim + lim for lim in ('lo', 'hi')])]
            [
                setattr(self.bounding_box, dim + lim, value)
                for lim, value in zip(('min', 'max'), bounds)
            ]

        self.kwargs['bounding_box'] = self.bounding_box
Beispiel #6
0
    def bounds(self):
        """Bounds of `Atoms`.

        Returns
        -------
        :class:`~sknano.core.geometric_regions.Cuboid`"""
        return Cuboid(pmin=[self.x.min(),
                            self.y.min(),
                            self.z.min()],
                      pmax=[self.x.max(),
                            self.y.max(),
                            self.z.max()])
Beispiel #7
0
def test1():
    print('generating graphene structure')
    graphene = GrapheneGenerator(armchair_edge_length=5, zigzag_edge_length=5)
    lattice = graphene.lattice
    print('graphene.bounds:\n{}'.format(graphene.bounds))
    print('graphene.centroid:\n{}'.format(graphene.centroid))
    print('graphene.lattice:\n{}'.format(lattice))
    print('graphene.lattice.a1:\n{}'.format(lattice.a1))
    print('graphene.lattice.a2:\n{}'.format(lattice.a2))
    print('graphene.lattice.a3:\n{}'.format(lattice.a3))
    print('graphene.lattice.orientation_matrix:\n{}'.format(
        lattice.orientation_matrix))
    print('rotating graphene')
    graphene.rotate(angle=-np.pi / 2, axis='x')
    print('graphene.bounds:\n{}'.format(graphene.bounds))
    print('graphene.centroid:\n{}'.format(graphene.centroid))
    print('graphene.lattice:\n{}'.format(lattice))
    print('graphene.lattice.a1:\n{}'.format(lattice.a1))
    print('graphene.lattice.a2:\n{}'.format(lattice.a2))
    print('graphene.lattice.a3:\n{}'.format(lattice.a3))
    print('graphene.lattice.orientation_matrix:\n{}'.format(
        lattice.orientation_matrix))

    assert_true(np.allclose(lattice.angles, 3 * [90.0]))
    lattice_region = Cuboid(pmax=lattice.lengths)

    # lattice_region = Parallelepiped(u=lattice.a * xhat,
    #                                 v=lattice.b * yhat,
    #                                 w=lattice.c * zhat)
    assert_equal(lattice_region.a, lattice.a)
    assert_equal(lattice_region.b, lattice.b)
    assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    print('\nrotating lattice_region')
    lattice_region.rotate(transform_matrix=lattice.orientation_matrix)
    # assert_equal(lattice_region.a, lattice.a)
    # assert_equal(lattice_region.b, lattice.b)
    # assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    print('\ncentering lattice_region on graphene centroid')
    tvec = Vector(Point(graphene.centroid) - lattice_region.centroid)
    lattice_region.translate(tvec)
    # assert_equal(lattice_region.a, lattice.a)
    # assert_equal(lattice_region.b, lattice.b)
    # assert_equal(lattice_region.c, lattice.c)
    print('lattice_region:\n{}'.format(lattice_region))
    print('lattice_region.centroid:\n{}'.format(lattice_region.centroid))

    bounding_box = generate_bounding_box(from_lattice=lattice,
                                         center=graphene.centroid,
                                         verbose=True)
    print('bounding_box:\n{}'.format(bounding_box))
    assert_equal(bounding_box, lattice_region)
    print('lattice_region.lengths: {}, {}, {}'.format(lattice_region.a,
                                                      lattice_region.b,
                                                      lattice_region.c))
Beispiel #8
0
def test2():
    graphene = GrapheneGenerator(armchair_edge_length=5,
                                 zigzag_edge_length=5)
    graphene.rotate(angle=-np.pi/2, axis='x')
    lattice = graphene.lattice

    bounding_box1 = Cuboid()
    bounding_box2 = Cuboid()

    lattice_region1 = Cuboid(pmax=lattice.lengths)
    bounding_box1.pmin = lattice_region1.pmin
    bounding_box1.pmax = lattice_region1.pmax

    a, b, c = lattice.lengths
    cos_alpha, cos_beta, cos_gamma = np.cos(np.radians(lattice.angles))
    lx = a
    xy = b * cos_gamma
    xz = c * cos_beta
    ly = np.sqrt(b ** 2 - xy ** 2)
    yz = (b * c * cos_alpha - xy * xz) / ly
    lz = np.sqrt(c ** 2 - xz ** 2 - yz ** 2)

    lattice_region2 = \
        Parallelepiped(u=Vector(lattice.ortho_matrix[:, 0].A.flatten()),
                       v=Vector(lattice.ortho_matrix[:, 1].A.flatten()),
                       w=Vector(lattice.ortho_matrix[:, 2].A.flatten()))

    xlo, ylo, zlo = lattice_region2.o
    print('xy={}, xz={}, yz={}'.format(xy, xz, yz))
    print('lx={}, ly={}, lz={}'.format(lx, ly, lz))
    print('xlo={}, ylo={}, zlo={}'.format(xlo, ylo, zlo))
    xlo_bound = xlo + min(0.0, xy, xz, xy + xz)
    xhi_bound = xlo + lx + max(0.0, xy, xz, xy + xz)
    ylo_bound = ylo + min(0.0, yz)
    yhi_bound = ylo + ly + max(0.0, yz)
    zlo_bound = zlo
    zhi_bound = zlo + lz
    bounding_box2.pmin = [xlo_bound, ylo_bound, zlo_bound]
    bounding_box2.pmax = [xhi_bound, yhi_bound, zhi_bound]

    print(bounding_box1)
    print(bounding_box2)

    [bounding_box.rotate(transform_matrix=lattice.orientation_matrix)
     for bounding_box in (bounding_box1, bounding_box2)]

    [bounding_box.translate(Vector(Point(graphene.centroid) -
                                   bounding_box.centroid))
     for bounding_box in (bounding_box1, bounding_box2)]

    [assert_true(bounding_box.pmin <= bounding_box.pmax) for bounding_box
     in (bounding_box1, bounding_box2)]

    assert_equal(bounding_box1, bounding_box2)

    print(bounding_box1)
    print(bounding_box2)
    def read_snapshot(self, f):
        try:
            snapshot = Snapshot(self.trajectory)
            f.readline()
            snapshot.timestep = int(f.readline().strip().split()[0])
            f.readline()
            snapshot.Natoms = int(f.readline().strip())
            snapshot.atom_selection = np.zeros(snapshot.Natoms, dtype=bool)

            item = f.readline().strip()
            try:
                snapshot.boxstr = item.split('BOUNDS')[1].strip()
            except IndexError:
                snapshot.boxstr = ''

            snapshot.triclinic = False
            snapshot.bounding_box = Cuboid()

            if 'xy' in snapshot.boxstr:
                snapshot.triclinic = True

            for dim, tilt_factor in zip(('x', 'y', 'z'), ('xy', 'xz', 'yz')):
                bounds = f.readline().strip().split()
                setattr(snapshot, dim + 'lo', float(bounds[0]))
                setattr(snapshot, dim + 'hi', float(bounds[1]))
                setattr(snapshot.bounding_box, dim + 'min',
                        getattr(snapshot, dim + 'lo'))
                setattr(snapshot.bounding_box, dim + 'max',
                        getattr(snapshot, dim + 'hi'))
                try:
                    setattr(snapshot, tilt_factor, float(bounds[2]))
                except IndexError:
                    setattr(snapshot, tilt_factor, 0.0)

            if not self.dumpattrs:
                xflag = yflag = zflag = None
                attrs = f.readline().strip().split()[2:]
                for i, attr in enumerate(attrs):
                    if attr in ('x', 'xu', 'xs', 'xsu'):
                        self.dumpattrs['x'] = i
                        if attr in ('x', 'xu'):
                            xflag = False
                        else:
                            xflag = True
                    elif attr in ('y', 'yu', 'ys', 'ysu'):
                        self.dumpattrs['y'] = i
                        if attr in ('y', 'yu'):
                            yflag = False
                        else:
                            yflag = True
                    elif attr in ('z', 'zu', 'zs', 'zsu'):
                        self.dumpattrs['z'] = i
                        if attr in ('z', 'zu'):
                            zflag = False
                        else:
                            zflag = True
                    else:
                        self.dumpattrs[attr] = i

                self.scale_original = None
                if all([flag is False for flag in (xflag, yflag, zflag)]):
                    self.scale_original = False
                if all([flag for flag in (xflag, yflag, zflag)]):
                    self.scale_original = True

                self.atomattrs = \
                    sorted(self.dumpattrs, key=self.dumpattrs.__getitem__)

                self.attr_dtypes = [attr_dtypes[attr] if attr in attr_dtypes
                                    else float for attr in self.atomattrs]

                if self.attrmap is not None:
                    self.remap_atomattr_names(self.attrmap)
                    self.attrmap = None

                self.unknown_attrs = \
                    {attr: self.atomattrs.index(attr) for
                     attr in set(self.atomattrs) - set(dir(Atom()))}

                [self.atomattrs.remove(attr) for attr in self.unknown_attrs]
            else:
                f.readline()

            snapshot.atomattrs = self.atomattrs
            snapshot.attr_dtypes = self.attr_dtypes

            atoms = \
                np.zeros((snapshot.Natoms, len(self.atomattrs)), dtype=float)
            for n in range(snapshot.Natoms):
                line = [float(value) for col, value in
                        enumerate(f.readline().strip().split())
                        if col not in self.unknown_attrs.values()]
                atoms[n] = line

            snapshot.atoms = atoms
            return snapshot

        except IndexError:
            return None
Beispiel #10
0
def test2():
    graphene = GrapheneGenerator(armchair_edge_length=5, zigzag_edge_length=5)
    graphene.rotate(angle=-np.pi / 2, axis='x')
    lattice = graphene.lattice

    bounding_box1 = Cuboid()
    bounding_box2 = Cuboid()

    lattice_region1 = Cuboid(pmax=lattice.lengths)
    bounding_box1.pmin = lattice_region1.pmin
    bounding_box1.pmax = lattice_region1.pmax

    a, b, c = lattice.lengths
    cos_alpha, cos_beta, cos_gamma = np.cos(np.radians(lattice.angles))
    lx = a
    xy = b * cos_gamma
    xz = c * cos_beta
    ly = np.sqrt(b**2 - xy**2)
    yz = (b * c * cos_alpha - xy * xz) / ly
    lz = np.sqrt(c**2 - xz**2 - yz**2)

    lattice_region2 = \
        Parallelepiped(u=Vector(lattice.ortho_matrix[:, 0].A.flatten()),
                       v=Vector(lattice.ortho_matrix[:, 1].A.flatten()),
                       w=Vector(lattice.ortho_matrix[:, 2].A.flatten()))

    xlo, ylo, zlo = lattice_region2.o
    print('xy={}, xz={}, yz={}'.format(xy, xz, yz))
    print('lx={}, ly={}, lz={}'.format(lx, ly, lz))
    print('xlo={}, ylo={}, zlo={}'.format(xlo, ylo, zlo))
    xlo_bound = xlo + min(0.0, xy, xz, xy + xz)
    xhi_bound = xlo + lx + max(0.0, xy, xz, xy + xz)
    ylo_bound = ylo + min(0.0, yz)
    yhi_bound = ylo + ly + max(0.0, yz)
    zlo_bound = zlo
    zhi_bound = zlo + lz
    bounding_box2.pmin = [xlo_bound, ylo_bound, zlo_bound]
    bounding_box2.pmax = [xhi_bound, yhi_bound, zhi_bound]

    print(bounding_box1)
    print(bounding_box2)

    [
        bounding_box.rotate(transform_matrix=lattice.orientation_matrix)
        for bounding_box in (bounding_box1, bounding_box2)
    ]

    [
        bounding_box.translate(
            Vector(Point(graphene.centroid) - bounding_box.centroid))
        for bounding_box in (bounding_box1, bounding_box2)
    ]

    [
        assert_true(bounding_box.pmin <= bounding_box.pmax)
        for bounding_box in (bounding_box1, bounding_box2)
    ]

    assert_equal(bounding_box1, bounding_box2)

    print(bounding_box1)
    print(bounding_box2)