Add default rgrid to mol from_size and from_pruned

- Change tests as well

src/grid/molgrid.py

@@ -449,9 +449,9 @@ def from_size(
         cls,
         atnums: np.ndarray,
         atcoords: np.ndarray,
-        rgrid: OneDGrid,
         size: int,
         aim_weights: Union[callable, np.ndarray],
+        rgrid: OneDGrid = None,
         rotate: int = 37,
         store: bool = False,
     ):
@@ -463,20 +463,21 @@ def from_size(
         >>> onedg = UniformInteger(100) # number of points, oned grid before TF.
         >>> rgrid = ExpRTransform(1e-5, 2e1).generate_radial(onedg) # radial grid
         >>> becke = BeckeWeights(order=3)
-        >>> molgrid = MolGrid.from_size(atnums, atcoords, rgrid, 110, becke)
+        >>> molgrid = MolGrid.from_size(atnums, atcoords, 110, becke, rgrid)
 
         Parameters
         ----------
         atnums : np.ndarray(M, 3)
             Atomic number of :math:`M` atoms in molecule.
         atcoords : np.ndarray(N, 3)
             Cartesian coordinates for each atoms
-        rgrid : OneDGrid
-            one dimension grid  to construct spherical grid
         size : int
             Num of points on each shell of angular grid
         aim_weights : Callable or np.ndarray(K,)
             Atoms in molecule weights.
+        rgrid : OneDGrid, optional
+            One-dimensional grid to construct the atomic grid. If none, then
+            default radial grid is generated based on atomic numbers.
         rotate : bool or int , optional
             Flag to set auto rotation for atomic grid, if given int, the number
             will be used as a seed to generate rantom matrix.
@@ -491,18 +492,23 @@ def from_size(
         """
         at_grids = []
         for i in range(len(atcoords)):
-            at_grids.append(AtomGrid(rgrid, sizes=[size], center=atcoords[i], rotate=rotate))
+            if rgrid is None:
+                atnum = atnums[i]
+                rad_grid = _generate_default_rgrid(atnum)
+            else:
+                rad_grid = rgrid
+            at_grids.append(AtomGrid(rad_grid, sizes=[size], center=atcoords[i], rotate=rotate))
         return cls(atnums, at_grids, aim_weights, store=store)
 
     @classmethod
     def from_pruned(
         cls,
         atnums: np.ndarray,
         atcoords: np.ndarray,
-        rgrid: Union[OneDGrid, list],
         radius: Union[float, list],
         aim_weights: Union[callable, np.ndarray],
         sectors_r: np.ndarray,
+        rgrid: Union[OneDGrid, list] = None,
         sectors_degree: np.ndarray = None,
         sectors_size: np.ndarray = None,
         rotate: int = 37,
@@ -517,10 +523,6 @@ def from_pruned(
             List of atomic numbers for each atom.
         atcoords: np.ndarray(M, 3)
             Cartesian coordinates for each atoms
-        rgrid : OneDGrid or List[OneDGrid] or Dict[int: OneDGrid]
-            One dimensional grid for the radial component.  If a list is provided,then ith
-            grid correspond to the ith atom.  If dictionary is provided, then the keys are
-            correspond to the `atnums[i]` attribute.
         radius: float, List[float]
             The atomic radius to be multiplied with `r_sectors` (to make them atom specific).
             If float, then the same atomic radius is used for all atoms, else a list specifies
@@ -532,6 +534,11 @@ def from_pruned(
             Each row is a sequence of boundary points specifying radial sectors of the pruned grid
             for the `m`th atom. The first sector is ``[0, radius*sectors_r[0]]``, then
             ``[radius*sectors_r[0], radius*sectors_r[1]]``, and so on.
+        rgrid : OneDGrid or List[OneDGrid] or Dict[int: OneDGrid], optional
+            One dimensional grid for the radial component.  If a list is provided,then ith
+            grid correspond to the ith atom.  If dictionary is provided, then the keys are
+            correspond to the `atnums[i]` attribute. If None, then using atomic numbers it will
+            generate a default radial grid (PowerRTransform of UniformInteger grid).
         sectors_degree: List[List], keyword-only argument
             Each row is a sequence of Lebedev/angular degrees for each radial sector of the pruned
             grid for the `m`th atom. If both `sectors_degree` and `sectors_size` are given,
@@ -571,6 +578,9 @@ def from_pruned(
                 rad = rgrid[i]
             elif isinstance(rgrid, dict):
                 rad = rgrid[atnums[i]]
+            elif rgrid is None:
+                atnum = atnums[i]
+                rad = _generate_default_rgrid(atnum)
             else:
                 raise TypeError(f"not supported radial grid input; got input type: {type(rgrid)}")
 

src/grid/tests/test_molgrid.py

@@ -578,10 +578,10 @@ def test_from_pruned(self):
         mol_grid = MolGrid.from_pruned(
             nums,
             coors,
-            self.rgrid,
             radius,
             becke,
             sectors_r=sectors_r,
+            rgrid=self.rgrid,
             sectors_degree=sectors_deg,
             rotate=False,
         )