aiida_pseudo.groups.family.pseudo_dojo
======================================

.. py:module:: aiida_pseudo.groups.family.pseudo_dojo

.. autoapi-nested-parse::

   Subclass of `PseudoPotentialFamily` designed to represent a PseudoDojo configuration.



Classes
-------

.. autoapisummary::

   aiida_pseudo.groups.family.pseudo_dojo.PseudoDojoConfiguration
   aiida_pseudo.groups.family.pseudo_dojo.PseudoDojoFamily


Module Contents
---------------

.. py:class:: PseudoDojoConfiguration

   Bases: :py:obj:`NamedTuple`


   Named tuple that represents a PseudoDojo configuration.


   .. py:attribute:: version
      :type:  str


   .. py:attribute:: functional
      :type:  str


   .. py:attribute:: relativistic
      :type:  str


   .. py:attribute:: protocol
      :type:  str


   .. py:attribute:: pseudo_format
      :type:  str


   .. py:method:: __str__()

      Represent the configuration as a string.



.. py:class:: PseudoDojoFamily(label=None, **kwargs)

   Bases: :py:obj:`aiida_pseudo.groups.mixins.RecommendedCutoffMixin`, :py:obj:`aiida_pseudo.groups.family.pseudo.PseudoPotentialFamily`


   Subclass of ``PseudoPotentialFamily`` designed to represent a PseudoDojo configuration.

   The ``PseudoDojoFamily`` is essentially a ``PseudoPotentialFamily`` with some additional constraints. It can only
   be used to contain the pseudo potentials and corresponding metadata of an official PseudoDojo configuration.


   .. py:attribute:: _pseudo_types


   .. py:attribute:: _pseudo_repo_file_extensions
      :value: ('djrepo',)



   .. py:attribute:: label_template
      :value: 'PseudoDojo/{version}/{functional}/{relativistic}/{protocol}/{pseudo_format}'



   .. py:attribute:: default_configuration


   .. py:attribute:: valid_configurations


   .. py:attribute:: url_base
      :value: 'http://www.pseudo-dojo.org/pseudos/'



   .. py:attribute:: urls
      :type:  ClassVar[dict[str, str]]


   .. py:method:: get_valid_labels() -> Sequence[str]
      :classmethod:


      Return the tuple of labels of all valid PseudoDojo configurations.



   .. py:method:: format_configuration_label(configuration: PseudoDojoConfiguration) -> str
      :classmethod:


      Format a label for an `PseudoDojoFamily` with the required syntax.

      :param configuration: the PseudoDojo configuration.
      :return: label.



   .. py:method:: get_url_archive(label)
      :classmethod:


      Return the URL for the pseudopotential archive file for a given family label.

      :param label: the family label as formatted by ``format_configuration_label``.
      :return: the URL from which the pseudopotential archive can be downloaded.
      :raises: `ValueError` if the label is not a valid configuration label.



   .. py:method:: get_url_metadata(label)
      :classmethod:


      Return the URL for the pseudopotential metadata file for a given family label.

      :param label: the family label as formatted by ``format_configuration_label``.
      :return: the URL from which the pseudopotential metadata can be downloaded.
      :raises: `ValueError` if the label is not a valid configuration label.



   .. py:method:: get_md5_from_djrepo(djrepo, pseudo_type)
      :classmethod:


      Get the appropriate md5 hash from a DJREPO file.

      :param djrepo: dictionary loaded from DJREPO JSON file.
      :reutnrs: md5 string.



   .. py:method:: get_cutoffs_from_djrepo(djrepo, pseudo_type)
      :classmethod:


      Collect and organize the suggested cutoffs (hints) from a DJREPO file.

      DJREPO files only provide a kinetic energy cutoff, so for pseudo types which contain norm-conserving pseudos
      from PseudoDojo, we use a dual of 8.0 to generate the charge density (rho) cutoff.

      For PAW potentials from PseudoDojo (which are assumed to be JthXmlData), a dual of 2.0 is used.

      The cutoffs in DJREPO files are given in Hartree, which is converted to eV.

      :param djrepo: dictionary loaded from DJREPO JSON file
      :returns: cutoffs dictionary (in eV) where keys are stringency levels and values are
          {'cutoff_wfc': ..., 'cutoff_rho': ...}



   .. py:method:: parse_djrepos_from_folder(dirpath: pathlib.Path, pseudo_type)
      :classmethod:


      Parse the djrepo files in the given directory into a list of data nodes.

      .. note:: The directory pointed to by `dirpath` should only contain djrepo files. Optionally, it can contain
          just a single directory, that contains all the djrepo files. If any other files are stored in the basepath
          or the subdirectory that cannot be successfully parsed as djrepo files the method will raise a `ValueError`.

      :param dirpath: absolute path to a directory containing djrepos.
      :return: list of data nodes.
      :raises ValueError: if `dirpath` is not a directory or contains anything other than files.
      :raises ValueError: if `dirpath` contains multiple djrepos for the same element.
      :raises ParsingError: if the constructor of the pseudo type fails for one of the files in the `dirpath`.



   .. py:method:: parse_djrepos_from_archive(filepath_metadata: pathlib.Path, fmt=None, pseudo_type=None)
      :classmethod:


      Parse metadata from a djrepo .tgz archive.

      .. warning:: the archive should not contain any subdirectories, but just the djrepo files.

      :param filepath_metadata: the path to the metadata .tgz archive.
      :param fmt: the format of the archive, if not specified will attempt to guess based on extension of `filepath`.
      :param pseudo_type: subclass of ``PseudoPotentialData`` to be used for the parsed pseudos. If not specified and
          the family only defines a single supported pseudo type in ``_pseudo_types`` then that will be used otherwise
          a ``ValueError`` is raised.
      :return: element: value dictionaries containing md5s and cutoffs.
      :raises OSError: if the archive could not be unpacked or the djrepos in it could not be parsed into md5s and
          cutoffs.