Basis optimization CLI

docs/conf.py

@@ -199,6 +199,7 @@
 .. _cmake: https://cmake.org
 .. _scikit-build-core: https://scikit-build-core.readthedocs.io/en/latest/
 .. _netcdf4-py: https://github.com/Unidata/netcdf4-python
+.. _pyyaml: https://pyyaml.org/wiki/PyYAMLDocumentation
 .. _numpy: https://www.numpy.org/
 .. _scipy: https://docs.scipy.org/doc/scipy
 .. _pyparsing: https://github.com/pyparsing/pyparsing

docs/quickstart/install.rst

@@ -75,6 +75,7 @@ to run sisl, so generally one shouldn't worry about getting correct
 packages etc. Here the more detailed requirements are listed.
 
 - `Python`_ 3.9 or above
+- `pyyaml`_
 - `numpy`_
 - `scipy`_
 - `xarray`_

docs/toolbox/basis/basis.rst

@@ -23,7 +23,7 @@ Then, one can directly run the optimization:
 
 .. code-block:: bash
 
-   stoolbox basis optim --geometry input.fdf
+   stoolbox basis optimize --geometry input.fdf
 
 with ``input.fdf`` being the input file for the calculation. This will use all the default
 values. Since there are many possible tweaks, we invite you to read carefully the help
@@ -56,7 +56,7 @@ Then, you can pass it directly to the optimization using the ``--config`` option
 
 .. code-block:: bash
 
-   stoolbox basis optim --geometry input.fdf --config my_config.yaml
+   stoolbox basis optimize --geometry input.fdf --config my_config.yaml
 
 **Installing the optimizers:** The default optimizer is BADS (https://github.com/acerbilab/bads)
 which is the one that we have found works best to optimize basis sets. The optimizer is however

src/sisl/_core/periodictable.py

@@ -900,7 +900,7 @@
             return ""
 
         if row.ndim == 0:
-            return conv(row[()], col[()])
+            return np.asarray(conv(row, col), dtype=str)
         return np.asarray(list(map(conv, row, col)), dtype=str)
 
     @classmethod
@@ -939,7 +939,7 @@
             return -1
 
         if Z.ndim == 0:
-            return conv(Z[()])
+            return np.asarray(conv(Z[()]), dtype=int)
         return np.asarray(list(map(conv, Z)), dtype=int)
 
     @classmethod

src/sisl/_lib/_argparse.py

@@ -12,19 +12,24 @@
 try:
     from rich_argparse import RawTextRichHelpFormatter
 
     SislHelpFormatter = RawTextRichHelpFormatter
 except ImportError:
     SislHelpFormatter = argparse.RawDescriptionHelpFormatter
 
 
 def is_optional(field):
     """Check whether the annotation for a parameter is an Optional type."""
-    return typing.get_origin(field) is Union and type(None) in typing.get_args(field)
+    return is_union(field) and type(None) in typing.get_args(field)
+
+
+def is_union(field):
+    """Check whether the annotation for a parameter is an Union type."""
+    return typing.get_origin(field) is Union
 
 
 def is_literal(field):
     """Check whether the annotation for a parameter is a Literal type."""
     return typing.get_origin(field) is Literal
 
 
 def get_optional_arg(field):
@@ -35,17 +40,17 @@
     E.g.: Optional[int] -> int
     E.g.: Optional[Union[int, str]] -> raises ValueError
     """
     if not is_optional(field):
         return field
 
     args = typing.get_args(field)
     if len(args) > 2:
         raise ValueError("Optional type must have at most 2 arguments")
     for arg in args:
         if arg is not type(None):
             return arg
 
     raise ValueError("No non-None type found in Union")
 
 
 def get_literal_args(field):
@@ -53,7 +58,7 @@
 
     E.g.: Literal[1, 2, 3] -> (1, 2, 3)
     """
     return typing.get_args(field)
 
 
 class NotPassedArg:
@@ -64,51 +69,51 @@
     """
 
     def __init__(self, val):
         self.val = val
 
     def __repr__(self):
         return repr(self.val)
 
     def __str__(self):
         return str(self.val)
 
     def __eq__(self, other):
         return self.val == other
 
     def __getattr__(self, name):
         return getattr(self.val, name)
 
 
 def get_runner(func):
     """Wraps a function to receive the args parsed from argparse"""
 
     def _runner(args):
 
         # Get the config argument. If present, load the arguments
         # from the config (yaml) file.
         config = getattr(args, "config", None)
         config_args = {}
         if config is not None:
             import yaml
 
             with open(args.config, "r") as f:
                 config_args = yaml.safe_load(f)
 
         # Build the final arguments dictionary, using the arguments of the
         # config file as defaults.
         final_args = {}
         for k, v in vars(args).items():
             if k in ("runner", "config"):
                 continue
             elif isinstance(v, NotPassedArg):
                 final_args[k] = config_args.get(k, v.val)
             else:
                 final_args[k] = v
 
         # And call the function
         return func(**final_args)
 
     return _runner
 
 
 def get_argparse_parser(
@@ -154,28 +159,28 @@
     """
 
     # Check if the function needs to be added as a subparser
     is_sub = not subp is None
 
     # Get the function's information
     fdoc = FunctionDoc(func)
     signature = inspect.signature(func)
 
     # Initialize parser
     title = "".join(fdoc["Summary"])
     parser_help = "\n".join(fdoc["Extended Summary"])
     if is_sub:
         p = subp.add_parser(
             name or func.__name__.replace("_", "-"),
             description=parser_help,
             help=title,
             **parser_kwargs,
         )
     else:
         p = argparse.ArgumentParser(title, **parser_kwargs)
 
     # Add the config argument to load the arguments from a YAML file
     if add_config:
         p.add_argument(
             "--config",
             "-c",
             type=str,
@@ -183,26 +188,31 @@
             help="Path to a YAML file containing the arguments for the command",
         )
 
     group = p.add_argument_group("Function arguments")
 
     # Add all the function's parameters to the parser
     parameters_help = {p.name: p.desc for p in fdoc["Parameters"]}
     for param in signature.parameters.values():
 
         arg_names = [f"--{param.name.replace('_', '-')}"]
         if param.name in arg_aliases:
             arg_names.append(f"-{arg_aliases[param.name]}")
 
         annotation = param.annotation
         if is_optional(annotation):
             annotation = get_optional_arg(annotation)
 
         choices = None
         if is_literal(annotation):
             choices = get_literal_args(annotation)
             annotation = type(choices[0])
 
+        # If the annotation is some-kind of union, just replace
+        # it with a string...
+        if is_union(annotation):
+            annotation = str
+
         group.add_argument(
             *arg_names,
             type=annotation,
             default=NotPassedArg(param.default),
@@ -212,9 +222,9 @@
             help="\n".join(parameters_help.get(param.name, [])),
         )
 
     if is_sub:
         defaults = {"runner": get_runner(func), **defaults}
 
     p.set_defaults(**defaults)
 
     return p

src/sisl_toolbox/siesta/minimizer/_atom_basis.py

@@ -8,6 +8,7 @@
 
 import sisl as si
 from sisl._internal import set_module
+from sisl.messages import info
 from sisl.utils import NotNonePropertyDict
 
 from ._variable import Variable
@@ -323,6 +324,7 @@ def basis(self):
 
             # get options for this shell
             opts = self.opts[(n, l)]
+
             line = f"n={n} {l} {len(orbs)}"
             for key, value in opts.items():
                 if key == "pol":
@@ -342,6 +344,8 @@ def basis(self):
                                 # explicit radius, convert to Bohr
                                 ri *= _Ang2Bohr
                             line += f" {ri:.10f}"
+                    else:
+                        info("Omitting soft-confinement due to V0 < 0.001 eV")
 
                 elif key == "split":
                     # split-norm value
@@ -363,6 +367,8 @@ def basis(self):
                             line += f" {yukawa/_Ang2Bohr:.10f}"
                         if not width is None:
                             line += f" {width*_Ang2Bohr:.10f}"
+                    else:
+                        info("Omitting charge-confinement due to Z < 0.005 e")
                 else:
                     raise ValueError(f"Unknown option for n={n} l={l}: {key}")
             block.append(line)

src/sisl_toolbox/siesta/minimizer/_minimize.py

@@ -30,6 +30,9 @@
 
 _log = logging.getLogger(__name__)
 
+# TODO we should have some kind of checks for the bounds, whether they
+# make sense or not.
+
 
 def _convert_optimize_result(minimizer, result):
     """Convert optimize result to conform to the scaling procedure performed"""
@@ -350,15 +353,13 @@
     It uses the pybads package to perform the minimization.
     """
 
-    def run(self, options={}, get_hard_bounds: Callable = lambda x: x, **kwargs):
+    def run(self, options={}, func_hard_bounds: Callable = lambda x: x, **kwargs):
         from pybads.bads import BADS
 
         bounds = self.normalize_bounds()
         bounds = np.array(bounds)
 
-        bounds[bounds == 0] = 0.5
-
-        hard_bounds = get_hard_bounds(bounds)
+        hard_bounds = func_hard_bounds(bounds)
 
         with self:
 
@@ -374,8 +375,8 @@
             # They do a deep copy of the arguments at the end, when generating the result.
             # This might be a problem if the arguments are not pickleable. E.g. the minimizer function
             # is associated with the minimizer object, which might contain siles.
             try:
                 opt = bads.optimize()
             except TypeError:
                 pass