pyscfad.ml.pbc.gto.cell_pad.CellPad#

class pyscfad.ml.pbc.gto.cell_pad.CellPad(numbers, coords, basis=None, a=None, Ls=None, rcut=None, precision=1e-08, dimension=3, charge=0, spin=0, cart=False, verbose=3, trace_coords=False, trace_basis=False, cuint_plan=None, bas0=None, env0=None)[source]#

Bases: MolePad

Padded unit cell (for batched periodic calculations).

Same padding conventions as MolePad (numbers == 0 marks padding atoms; shells/AOs are padded uniformly per element through the BasisArray), plus the lattice data:

Parameters:

  • a (ArrayLike | None) – Lattice vectors [3, 3] (in Bohr; rows are the vectors). May be traced (e.g. for batching over solids).

  • Ls (ArrayLike | None) – Fixed-shape lattice translations [nL, 3]. Build them as make_image_grid(nimgs) @ a with a static, batch-wide nimgs so every cell in a batch shares the same nL; per-cell validity is handled at integral time through get_Ls_mask().

  • rcut (float | None) – Static lattice-sum cutoff radius (Bohr). Choose the maximum over the batch (e.g. from pyscfad.pbc.gto.cell.estimate_rcut on a representative unpadded cell).

  • numbers (ArrayLike)

  • coords (ArrayLike)

  • basis (BasisArray | None)

  • precision (float)

  • dimension (int)

  • charge (int)

  • spin (int)

  • cart (bool)

  • verbose (int)

  • trace_coords (bool)

  • trace_basis (bool)

  • cuint_plan (CuintPlan | None)

  • bas0 (ArrayLike)

  • env0 (ArrayLike)

Methods

cutoff_to_mesh(ke_cutoff)

Convert KE cutoff to FFT-mesh

get_Gv_weights([mesh])

Calculate G-vectors and weights.

get_Ls_mask([Ls, rcut])

get_abs_kpts(scaled_kpts)

Get absolute k-points (in 1/Bohr), given "scaled" k-points in fractions of lattice vectors.

get_ewald_params([precision, mesh])

Choose a reasonable value of Ewald 'eta' and 'cut' parameters.

get_scaled_atom_coords([a])

Get scaled atomic coordinates.

get_scaled_kpts(abs_kpts[, kpts_in_ibz])

Get scaled k-points, given absolute k-points in 1/Bohr.

lattice_intor(intor_name[, comp, hermi, Ls, ...])

Lattice one-electron integrals over the padded cell.

lattice_vectors()

make_kpts(nks[, wrap_around, ...])

Given number of kpoints along x,y,z , generate kpoints

reciprocal_vectors([norm_to])