class_docstr: Create a molecule object that stores molecular information and default basis set parameters.
  
  The molecule object can be passed to functions that perform a Hartree-Fock calculation.
  
  Args:
      symbols (list[str]): Symbols of the atomic species in the molecule. Currently, atoms with
          atomic numbers 1-10 are supported.
      coordinates (array[float]): 1D array with the atomic positions in Cartesian coordinates. The
          coordinates must be given in atomic units and the size of the array should be ``3*N``
          where ``N`` is the number of atoms.
      charge (int): net charge of the molecule
      mult (int): Spin multiplicity :math:`\mathrm{mult}=N_\mathrm{unpaired} + 1` for
          :math:`N_\mathrm{unpaired}` unpaired electrons occupying the HF orbitals. Currently,
          openshell systems are not supported; ``mult`` must be equal to :math:`1`.
      basis_name (str): Atomic basis set used to represent the molecular orbitals. Currently, the
          only supported basis sets are 'STO-3G', '6-31G', '6-311G' and 'CC-PVDZ'.
      load_data (bool): flag to load data from the basis-set-exchange library
      l (tuple[int]): angular momentum quantum numbers of the basis function
      alpha (array[float]): exponents of the primitive Gaussian functions
      coeff (array[float]): coefficients of the contracted Gaussian functions
      r (array[float]): positions of the Gaussian functions
      normalize (bool): if True, the basis functions get normalized
  
  **Example**
  
  >>> symbols  = ['H', 'H']
  >>> geometry = np.array([[0.0, 0.0, -0.694349],
  >>>                      [0.0, 0.0,  0.694349]], requires_grad = True)
  >>> mol = Molecule(symbols, geometry)
  >>> print(mol.n_electrons)
  2
code: def __init__(
      self,
      symbols,
      coordinates,
      charge=0,
      mult=1,
      basis_name="sto-3g",
      load_data=False,
      l=None,
      alpha=None,
      coeff=None,
      normalize=True,
  ):
      if (
          basis_name.lower()
          not in [
              "sto-3g",
              "6-31g",
              "6-311g",
              "cc-pvdz",
          ]
          and load_data is False
      ):
          raise ValueError(
              "Currently, the only supported basis sets are 'sto-3g', '6-31g', '6-311g' and "
              "'cc-pvdz'. Please consider using `load_data=True` to download the basis set from "
              "an external library that can be installed with: pip install basis-set-exchange."
          )
  
      if set(symbols) - set(atomic_numbers):
          raise ValueError(
              f"Atoms in {set(symbols) - set(atomic_numbers)} are not supported."
          )
  
      self.symbols = symbols
      self.coordinates = coordinates
      self.charge = charge
      self.mult = mult
      self.basis_name = basis_name.lower()
  
      self.n_basis, self.basis_data = mol_basis_data(
          self.basis_name, self.symbols, load_data
      )
  
      self.nuclear_charges = [atomic_numbers[s] for s in self.symbols]
  
      self.n_electrons = sum(self.nuclear_charges) - self.charge
  
      if self.n_electrons % 2 == 1 or self.mult != 1:
          raise ValueError(
              "Openshell systems are not supported. Change the charge or spin "
              "multiplicity of the molecule."
          )
  
      if l is None:
          l = [i[0] for i in self.basis_data]
  
      if alpha is None:
          alpha = [
              pnp.array(i[1], requires_grad=False)
              for i in self.basis_data
          ]
  
      if coeff is None:
          coeff = [
              pnp.array(i[2], requires_grad=False)
              for i in self.basis_data
          ]
          if normalize:
              coeff = [
                  pnp.array(
                      c * primitive_norm(l[i], alpha[i]),
                      requires_grad=False,
                  )
                  for i, c in enumerate(coeff)
              ]
  
      r = list(
          itertools.chain(
              *[
                  [self.coordinates[i]] * self.n_basis[i]
                  for i in range(len(self.n_basis))
              ]
          )
      )
  
      self.l = l
      self.alpha = alpha
      self.coeff = coeff
      self.r = r
  
      self.basis_set = [
          BasisFunction(
              self.l[i], self.alpha[i], self.coeff[i], self.r[i]
          )
          for i in range(len(l))
      ]
      self.n_orbitals = len(self.l)
  
      self.mo_coefficients = None
  
file_path: pennylane/pennylane/qchem/molecule.py
imports: import itertools
  import collections
  from pennylane import numpy
  from .basis_data import atomic_numbers
  from .basis_set import BasisFunction, mol_basis_data
  from .integrals import contracted_norm, primitive_norm
label_desc: Use image node_id 1 to create a new Molecule object  with example: obj = Molecule(symbols, coordinates, charge, mult, basis_name, load_data, l, alpha, coeff, normalize)