def _load_data(self, atom_syms, coords, bohrs=True):
        """ Internal function for making XYZ object from explicit geom data.

        Parameters
        ----------
        atom_syms
            Squeezes to array of N |str| --
            Element symbols for the XYZ. Must be valid elements as defined in
            the keys of :data:`const.atom_num <opan.const.atom_num>`.

        coords
            Squeezes to array of 3N |npfloat_| castables --
            Coordinates for the geometry.

        bohrs
            |bool|, optional --
            Units of coordinates (default |True|)

        Raises
        ------
        ~opan.XYZError
            (typecode :attr:`~opan.error.XYZError.OVERWRITE`)
            If :class:`ORCA_XYZ` object has already been initialized.

        ~exceptions.ValueError
            If atom_syms & coords dimensions are incompatible

        ~exceptions.ValueError
            If type of `atom_syms` and/or `coords` is invalid

        """

        # Imports
        import numpy as np
        from .const import atom_num, PHYS
        from .error import XYZError

        # Gripe if already initialized
        if 'geoms' in dir(self):
            raise XYZError(XYZError.OVERWRITE,
                    "Cannot overwrite contents of existing OpanXYZ", "")
        ## end if

        # Check and store dimensions
        if not len(coords.shape) == 1:
            raise ValueError("Coordinates are not a vector")
        ## end if
        if not len(atom_syms.shape) == 1:
            raise ValueError("Atom symbols are not a simple list")
        ## end if
        if not coords.shape[0] == 3 * atom_syms.shape[0]:
            raise ValueError("len(coords) != 3 * len(atom_syms)")
        ## end if

        # Proof the atoms list
        if not all( (atom_syms[i].upper() in atom_num)
                                for i in range(atom_syms.shape[0]) ):
            # Invalid atoms specified
            raise ValueError("Invalid atoms specified: {0}".format(
                    [(j, atom_syms[j]) for j in
                        (i for (i, valid) in
                            enumerate(map(lambda k: k in atom_num, atom_syms))
                            if not valid
                        )
                    ] ))
        ## end if

        # Ensure the geometry is all numeric
        if not all(map(np.isreal, coords)):
            raise ValueError("All coordinates must be real numeric")
        ## end if

        # Store the number of atoms. Only one geometry. Standard string
        #  content for things only relevant to file load.
        self.num_atoms = atom_syms.shape[0]
        self.num_geoms = 1
        self.in_str = self.LOAD_DATA_FLAG
        self.descs = np.array([self.LOAD_DATA_FLAG])
        self.XYZ_path = self.LOAD_DATA_FLAG

        # Store the atoms as vector
        self.atom_syms = list(map(str.upper, list(atom_syms)))

        # Store the single geometry by bracketing with an array
        self.geoms = [coords / (1.0 if bohrs else PHYS.ANG_PER_BOHR)]