PySCF

https://pyscf.org
Admin
PySCF is a comprehensive open-source Python package for quantum chemistry and electronic structure...
Tokens:5,565,525
Snippets:21,956
Trust Score:9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup for ao2mo examples

Source: https://pyscf.org/pyscf_api_docs/pyscf.ao2mo.html

Initial setup code required to define the molecule and orbital coefficients for the examples.

```python
>>> from pyscf import gto, ao2mo
>>> import h5py
>>> def view(h5file, dataname='eri_mo'):
...     with h5py.File(h5file) as f5:
...         print('dataset %s, shape %s' % (str(f5.keys()), str(f5[dataname].shape)))
>>> mol = gto.M(atom='O 0 0 0; H 0 1 0; H 0 0 1', basis='sto3g')
>>> mo1 = numpy.random.random((mol.nao_nr(), 10))
>>> mo2 = numpy.random.random((mol.nao_nr(), 8))
```

--------------------------------

### Example Molecule Setup

Source: https://pyscf.org/_modules/pyscf/mcscf/mc1step.html

Sets up a sample molecule for testing or demonstration purposes. This includes defining atomic positions and other molecular properties.

```python
if __name__ == '__main__':
    from pyscf import scf
    from pyscf import fci
    from pyscf.mcscf import addons

    mol = gto.Mole()
    mol.verbose = 0
    mol.output = None#
```

--------------------------------

### Example Cell Setup

Source: https://pyscf.org/_modules/pyscf/pbc/df/df_jk.html

Demonstrates the setup of a periodic cell using pyscf.pbc.gto for a simple cubic lattice with two carbon atoms. This includes defining lattice vectors, mesh size, atomic positions, basis set, and verbosity.

```python
if __name__ == '__main__':
    import pyscf.pbc.gto as pgto
    import pyscf.pbc.scf as pscf

    L = 5.
    n = 11
    cell = pgto.Cell()
    cell.a = numpy.diag([L,L,L])
    cell.mesh = numpy.array([n,n,n])

    cell.atom = '''C    3.    2.       3.
                   C    1.    1.       1.'''
    #cell.basis = {'He': [[0, (1.0, 1.0)]]}
    #cell.basis = '631g'
    #cell.basis = {'He': [[0, (2.4, 1)], [1, (1.1, 1)]]}
    cell.basis = 'ccpvdz'
    cell.verbose = 0
    cell.build(0,0)
    cell.verbose = 5
```

--------------------------------

### DFRAGF2 Example Usage

Source: https://pyscf.org/_modules/pyscf/agf2/dfragf2.html

Example demonstrating the setup and execution of the DFRAGF2 calculation for ionization potential and electron affinity.

```python
if __name__ == '__main__':
    from pyscf import gto, scf, mp

    mol = gto.M(atom='O 0 0 0; H 0 0 1; H 0 1 0', basis='cc-pvdz', verbose=3)
    rhf = scf.RHF(mol).density_fit()
    rhf.conv_tol = 1e-11
    rhf.run()

    ragf2 = DFRAGF2(rhf)

    ragf2.run()
    ragf2.ipagf2(nroots=5)
    ragf2.eaagf2(nroots=5)
```

--------------------------------

### Basic Molecular Dynamics Simulation Setup

Source: https://pyscf.org/pyscf_api_docs/pyscf.md.html

Sets up and runs a simple NVE (constant Number of particles, Volume, Energy) molecular dynamics simulation using PySCF. This example demonstrates initializing a DFT calculation and then running the simulation with specified time step and duration.

```python
from pyscf import gto, dft
import pyscf.md as md
mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='def2-tzvp')
mf = dft.RKS(mol)
mf.xc = 'pbe,pbe'
integrator = md.NVE(mf, dt=5, time=10).run()

```

--------------------------------

### Example of adding MM charges to gradients

Source: https://pyscf.org/_modules/pyscf/qmmm/itrf.html

Demonstrates how to use `add_mm_charges_grad` to compute QM gradients with MM charges included. Shows setup and kernel execution.

```python
from pyscf import gto, scf, grad
    mol = gto.M(atom='H 0 0 0; F 0 0 1', basis='ccpvdz', verbose=0)
    mf = mm_charge(scf.RHF(mol), [(0.5,0.6,0.8)], [-0.3])
    mf.kernel()
    hfg = mm_charge_grad(grad.hf.RHF(mf), coords, charges)
    hfg.kernel()
```

--------------------------------

### Example: Get and Print Basis Set Information

Source: https://pyscf.org/_modules/pyscf/gto/basis/bse.html

Demonstrates fetching the '6-31g' basis set for Oxygen, printing its information, and displaying the orbital basis and literature references in PySCF format.

```python
from basis_set_exchange import api, references

    # Get reference data
    reference_data = api.get_reference_data()
    #print(references)

    o631gbas = api.get_basis('6-31g', elements='O')
    #print('O 6-31G basis, BSE format
{}'.format(o631gbas))
    _print_basis_information(o631gbas)
    o631gorb, o631gref = _orbital_basis(o631gbas)
    print('O 6-31G orbital basis, PySCF format
{}'.format(o631gorb))
    print('Literature references')
    for ref in o631gref:
        print(references.reference_text(ref, reference_data[ref]))
    print('')
```

--------------------------------

### Example Usage

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Example of performing a CASSCF calculation using PySCF.

```APIDOC
## Examples:
```python
>>> from pyscf import gto, scf, mcscf
>>> mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='ccpvdz', verbose=0)
>>> mf = scf.RHF(mol)
>>> mf.scf()
>>> mc = mcscf.CASSCF(mf, 6, 6)
>>> mc.kernel()[0]
-109.044401882238134
```
```

--------------------------------

### Running a CASCI Calculation

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Example of performing a CASCI calculation. It initializes a molecule, runs an RHF calculation, sets up CASCI, and then executes the kernel to obtain the total energy.

```python
from pyscf import gto, scf, mcscf

mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='ccpvdz', verbose=0)
mf = scf.RHF(mol)
s = mf.kernel()
mc = mcscf.CASCI(mf, 6, 6)
print(mc.kernel()[0])
```

--------------------------------

### SCF Calculation with Initial Guess

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Demonstrates how to perform a SCF calculation using a custom initial guess density matrix. This is useful for controlling the starting point of the SCF iteration.

```python
import numpy
from pyscf import gto, scf
mol = gto.M(atom='H 0 0 0; F 0 0 1.1')
mf = scf.hf.SCF(mol)
dm_guess = numpy.eye(mol.nao_nr())
mf.kernel(dm_guess)
converged SCF energy = -98.5521904482821
-98.552190448282104
```

--------------------------------

### SCF Calculation with Initial Guess Density Matrix

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Demonstrates how to perform an SCF calculation using a provided initial guess density matrix. This is useful for controlling the starting point of the SCF iteration.

```python
>>> import numpy
>>> from pyscf import gto, scf
>>> mol = gto.M(atom='H 0 0 0; F 0 0 1.1')
>>> mf = scf.hf.SCF(mol)
>>> dm_guess = numpy.eye(mol.nao_nr())
>>> mf.kernel(dm_guess)
converged SCF energy = -98.5521904482821
-98.552190448282104

```

--------------------------------

### Run SCF calculation with custom initial guess

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Drives the SCF calculation using a provided initial guess density matrix. Useful for controlling the starting point of the SCF convergence process.

```python
>>> from pyscf import gto, scf
>>> mol = gto.M(atom='H 0 0 0; H 0 0 1.1', basis='cc-pvdz')
>>> conv, e, mo_e, mo, mo_occ = scf.hf.kernel(scf.hf.SCF(mol), dm0=numpy.eye(mol.nao_nr()))
>>> print('conv = %s, E(HF) = %.12f' % (conv, e))
conv = True, E(HF) = -1.081170784378
```

--------------------------------

### Example Usage (Main Block)

Source: https://pyscf.org/_modules/pyscf/adc/radc.html

Imports necessary modules for SCF, molecule definition, and ADC calculations for example usage.

```python
from pyscf import scf
from pyscf import gto
from pyscf import adc
```

--------------------------------

### Example Usage of Gradient Calculations

Source: https://pyscf.org/_modules/pyscf/grad/cmspdft.html

Example demonstrating the setup and usage of various gradient calculation functions, including diab_response and diab_grad, with comparison against reference values.

```python
if __name__ == '__main__':
    import math
    from pyscf import scf, gto, mcscf
    from pyscf.fci import csf_solver
    from pyscf.mcpdft.pdft_feff import vector_error
    xyz = '''O  0.00000000   0.08111156   0.00000000
             H  0.78620605   0.66349738   0.00000000
             H -0.78620605   0.66349738   0.00000000'''
    mol = gto.M (atom=xyz, basis='6-31g', symmetry=False, output='cmspdft.log',
        verbose=lib.logger.DEBUG)
    mf = scf.RHF (mol).run ()
    mc = mcscf.CASSCF (mf, 4, 4).set (fcisolver = csf_solver (mol, 1))
    mc = mc.state_average ([1.0/3,]*3).run ()
    ci_arr = np.asarray (mc.ci)

    mc_grad = mc.nuc_grad_method ()
    Lis = math.pi * (np.random.rand (3) - 0.5)
    eris = mc.ao2mo (mc.mo_coeff)

    dw_test = diab_response (mc_grad, Lis, mo=mc.mo_coeff, ci=mc.ci,
        eris=eris)
    dworb_test, dwci_test = mc_grad.unpack_uniq_var (dw_test)
    dwci_test = np.asarray (dwci_test)
    dwis_test = lib.einsum ('pab,qab->pq', dwci_test, ci_arr.conj ()) 
    dwci_test -= lib.einsum ('pq,qab->pab', dwis_test, ci_arr)
    dw_ref = diab_response_o0 (mc_grad, Lis, mo=mc.mo_coeff, ci=mc.ci,
        eris=eris)
    dworb_ref, dwci_ref = mc_grad.unpack_uniq_var (dw_ref)
    dwci_ref = np.asarray (dwci_ref)
    dwis_ref = lib.einsum ('pab,qab->pq', dwci_ref, ci_arr.conj ()) 
    dwci_ref -= lib.einsum ('pq,qab->pab', dwis_ref, ci_arr)
    dh_test = diab_grad (mc_grad, Lis, mo=mc.mo_coeff, ci=mc.ci, eris=eris)
    dh_ref = diab_grad_o0 (mc_grad, Lis, mo=mc.mo_coeff, ci=mc.ci, eris=eris)

    print ("dworb:", vector_error (dworb_test, dworb_ref), linalg.norm (
        dworb_ref))
    print ("dwci:", vector_error (dwci_test, dwci_ref), linalg.norm (dwci_ref))
    print ("dwis:", vector_error (dwis_test, dwis_ref), linalg.norm (dwis_ref))
    print ("dh:", vector_error (dh_test, dh_ref), linalg.norm (dh_ref))

    print (dh_test, '\n', dh_ref)
```

--------------------------------

### CASSCF Example with RHF

Source: https://pyscf.org/_modules/pyscf/mcscf/newton_casscf.html

Demonstrates a basic CASSCF calculation starting from a Restricted Hartree-Fock (RHF) object. The example shows how to set up the CASSCF object and run the kernel calculation.

```python
from pyscf import gto, scf, mcscf
mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='ccpvdz', verbose=0)
 הראש = scf.RHF(mol)
 הראש.scf()
mc = mcscf.CASSCF(mf, 6, 6)
mc.kernel()[0]
```

--------------------------------

### Transition State Optimization with Custom Parameters (qsdopt)

Source: https://pyscf.org/user/geomopt.html

This example shows how to perform a transition state optimization using QSD with specific keyword arguments for hessian update frequency, step size, and minimum distance for convergence.

```python
from pyscf.qsdopt.qsd_optimizer import QSD
from pyscf import gto, scf

mol = gto.M(atom='''
C  -2.17177  -0.46068  -0.00000
C  -0.02194  -0.50455  0.00000
H  0.35133   0.30506   -0.59169
H  0.33677   -0.40796  1.00344
H  0.31586   -1.43259  -0.41175
H  -2.68285  -0.25342  0.93134
H  -2.40018  0.15510   -0.90287
H   -2.53568   -1.52338   -0.17790''', basis='minao', verbose=0)
mf = scf.RHF(mol)

optimizer = QSD(mf, stationary_point="TS")
optimizer.kernel(hess_update_freq=0, step=0.5, hmin=1e-3)

```

--------------------------------

### Basic CASSCF Calculation Example

Source: https://pyscf.org/pyscf_api_docs/pyscf.scf.html

Performs a Restricted Hartree-Fock calculation and then a CASSCF calculation. This snippet demonstrates the basic workflow for setting up and running a CASSCF calculation.

```python
>>> from pyscf import gto, scf, mcscf
>>> mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='ccpvdz', verbose=0)
>>> mf = scf.RHF(mol)
>>> mf.scf()
>>> mc = mcscf.CASSCF(mf, 6, 6)
>>> mc.kernel()[0]
-109.044401882238134
```

--------------------------------

### CCSD Symmetry Test Case

Source: https://pyscf.org/_modules/pyscf/cc/ccsd_t.html

Example setup for running a CCSD calculation with symmetry enabled.

```python
if __name__ == '__main__':
    from pyscf import gto
    from pyscf import scf
    from pyscf import cc

    mol = gto.Mole()
    mol.atom = [
        [8 , (0. , 0.     , 0.)],
        [1 , (0. , -.957 , .587)],
        [1 , (0.2,  .757 , .487)]]

    mol.basis = 'ccpvdz'
    mol.build()
    rhf = scf.RHF(mol)
    rhf.conv_tol = 1e-14
    rhf.scf()
    mcc = cc.CCSD(rhf)
    mcc.conv_tol = 1e-14
    mcc.ccsd()
    e3a = kernel(mcc, mcc.ao2mo())
    print(e3a - -0.0033300722704016289)

    mol = gto.Mole()
    mol.atom = [
        [8 , (0. , 0.     , 0.)],
        [1 , (0. , -.757 , .587)],
        [1 , (0. ,  .757 , .587)]]
    mol.symmetry = True
```

--------------------------------

### PCM Initialization with CASCI Example

Source: https://pyscf.org/_modules/pyscf/solvent.html

Example showing how to initialize the PCM model for a CASCI calculation, including setting up the solvent object.

```python
sol = PCM(mol)
    mc = PCM(CASCI(mf, 6, 6), sol)
    mc.kernel()
```

--------------------------------

### QCISD Execution Example

Source: https://pyscf.org/_modules/pyscf/cc/qcisd_slow.html

Example script demonstrating how to initialize a molecule, run an RHF calculation, and perform a QCISD calculation with perturbative triples.

```python
if __name__ == '__main__':
    from pyscf import gto, scf

    mol = gto.Mole()
    mol.atom = """C  0.000  0.000  0.000
                  H  0.637  0.637  0.637
                  H -0.637 -0.637  0.637
                  H -0.637  0.637 -0.637
                  H  0.637 -0.637 -0.637"""
    mol.basis = 'cc-pvdz'
    mol.verbose = 7
    mol.spin = 0
    mol.build()
    mf = scf.RHF(mol).run(conv_tol=1e-14)

    mycc = QCISD(mf, frozen=1)
    ecc, t1, t2 = mycc.kernel()
    print(mycc.e_tot - -40.383989)
    et = mycc.qcisd_t()
    print(mycc.e_tot+et - -40.387679)
```

--------------------------------

### DFMP2 Example Usage

Source: https://pyscf.org/_modules/pyscf/mp/dfmp2_slow.html

Demonstrates the usage of the DFMP2 class with different density fitting setups and basis sets. It includes examples for standard RHF, density-fitted RHF, and custom auxiliary basis sets.

```python
if __name__ == '__main__':
    from pyscf import scf
    from pyscf import gto, df
    mol = gto.Mole()
    mol.verbose = 0
    mol.atom = [
        [8 , (0. , 0.     , 0.)],
        [1 , (0. , -0.757 , 0.587)],
        [1 , (0. , 0.757  , 0.587)]]

    mol.basis = 'cc-pvdz'
    mol.build()
    mf = scf.RHF(mol).run()
    pt = DFMP2(mf)
    emp2, t2 = pt.kernel()
    print(emp2 - -0.204004830285)

    pt.with_df = df.DF(mol)
    pt.with_df.auxbasis = 'weigend'
    emp2, t2 = pt.kernel()
    print(emp2 - -0.204254500453)

    mf = scf.density_fit(scf.RHF(mol), 'weigend')
    mf.kernel()
    pt = DFMP2(mf)
    emp2, t2 = pt.kernel()
    print(emp2 - -0.203986171133)

    pt.with_df = df.DF(mol)
    pt.with_df.auxbasis = df.make_auxbasis(mol, mp2fit=True)
    emp2, t2 = pt.kernel()
    print(emp2 - -0.203738031827)

    pt.frozen = 2
    emp2, t2 = pt.kernel()
    print(emp2 - -0.14433975122418313)
```

--------------------------------

### Example usage for NAC calculation

Source: https://pyscf.org/_modules/pyscf/nac/sacasscf.html

Demonstrates the setup and execution of non-adiabatic coupling calculations for a LiH molecule.

```python
if __name__=='__main__':
    from pyscf import gto, scf, mcscf
    from scipy import linalg
    mol = gto.M (atom = 'Li 0 0 0; H 0 0 1.5', basis='sto-3g',
                 output='sacasscf_nacs.log', verbose=lib.logger.INFO)
    mf = scf.RHF (mol).run ()
    mc = mcscf.CASSCF (mf, 2, 2).fix_spin_(ss=0).state_average ([0.5,0.5]).run (conv_tol=1e-10)
    openmolcas_energies = np.array ([-7.85629118, -7.72175252])
    print ("energies:",mc.e_states)
    print ("disagreement w openmolcas:", np.around (mc.e_states-openmolcas_energies, 8))
    mc_nacs = NonAdiabaticCouplings (mc)
    print ("no csf contr")
    nac_01 = mc_nacs.kernel (state=(0,1), use_etfs=True)
    nac_10 = mc_nacs.kernel (state=(1,0), use_etfs=True)
    nac_01_mult = mc_nacs.kernel (state=(0,1), use_etfs=True, mult_ediff=True)
    nac_10_mult = mc_nacs.kernel (state=(1,0), use_etfs=True, mult_ediff=True)
    print ("antisym")
    print (nac_01)
    print ("checking antisym:",linalg.norm(nac_01+nac_10))
    print ("sym")
    print (nac_01_mult)
    print ("checking sym:",linalg.norm(nac_01_mult-nac_10_mult))


    print ("incl csf contr")
    nac_01 = mc_nacs.kernel (state=(0,1), use_etfs=False)
    nac_10 = mc_nacs.kernel (state=(1,0), use_etfs=False)
    nac_01_mult = mc_nacs.kernel (state=(0,1), use_etfs=False, mult_ediff=True)
    nac_10_mult = mc_nacs.kernel (state=(1,0), use_etfs=False, mult_ediff=True)
    print ("antisym")
    print (nac_01)
    print ("checking antisym:",linalg.norm(nac_01+nac_10))
    print ("sym")
    print (nac_01_mult)
    print ("checking sym:",linalg.norm(nac_01_mult-nac_10_mult))

    print ("Check gradients")
    mc_grad = mc.nuc_grad_method ()
    de_0 = mc_grad.kernel (state=0)
    print (de_0)
    de_1 = mc_grad.kernel (state=1)
    print (de_1)
```

--------------------------------

### Example Usage of Linearized Multi-State MC-PDFT

Source: https://pyscf.org/_modules/pyscf/mcpdft/lpdft.html

Demonstrates the setup and execution of a linearized multi-state MC-PDFT calculation using PySCF. This example involves setting up a molecule, running RHF, and then configuring and running the multi-state solver.

```python
if __name__ == "__main__":
    from pyscf import gto, scf
    from pyscf import mcpdft
    from pyscf.csf_fci import csf_solver

    mol = gto.M(
        atom="""H 0 0 0
                       H 1.5 0 0""",
        basis="sto-3g",
        verbose=5,
        spin=0,
        unit="AU",
        symmetry=True,
    )

    mf = scf.RHF(mol).run()

    mc = mcpdft.CASSCF(mf, "tPBE", 2, 2, grids_level=6)
    mc.fcisolver = csf_solver(mol, smult=1)

    N_STATES = 2

    mc = mc.state_average(
        [
            1.0 / float(N_STATES),
        ]
        * N_STATES
    )

    sc = linear_multi_state(mc)
    sc.kernel()
```

--------------------------------

### CASSCF 1-Step Solver Example

Source: https://pyscf.org/_modules/pyscf/mcscf/mc1step.html

Demonstrates initializing and running the CASSCF 1-step solver with custom convergence tolerances for both the main optimization and the AH solver.

```python
from pyscf import gto, scf, mcscf
mol = gto.M(atom='N 0 0 0; N 0 0 1', basis='ccpvdz', verbose=0)
mf = scf.UHF(mol)
mf.scf()
mc = mcscf.CASSCF(mf, 6, 6)
mc.conv_tol = 1e-10
mc.ah_conv_tol = 1e-5
mc.kernel()[0]
>>> -109.044401898486001
mc.ah_conv_tol = 1e-10
mc.kernel()[0]
>>> -109.044401887945668
```

--------------------------------

### Troubleshoot CMake build errors

Source: https://pyscf.org/_sources/user/install.md.txt

Example of a build failure output when the cmake program is missing during source installation.

```bash
Building wheels for collected packages: pyscf
  Building wheel for pyscf (setup.py) ... error
  error: subprocess-exited-with-error
  × python setup.py bdist_wheel did not run successfully.
  │ exit code: 1
  ╰─> [7 lines of output]
      scipy>1.1.0 may crash when calling scipy.linalg.eigh. (Issues https://github.com/scipy/scipy/issues/15362 https://github.com/scipy/scipy/issues/16151)
      running bdist_wheel
      running build
      running build_ext
      Configuring extensions
      cmake -S/Users/<user>/personal/codes/chemistry/pyscf/pyscf/lib -Bbuild/temp.macosx-12-x86_64-cpython-310
      error: command 'cmake' failed: No such file or directory
      [end of output]
```

--------------------------------

### Example usage

Source: https://pyscf.org/_modules/pyscf/gto/basis/parse_gaussian.html

Demonstrates loading a basis set for Carbon from a file.

```python
if __name__ == '__main__':
    print(load('def2-qzvp-jkfit.gbs', 'C'))
```

--------------------------------

### Selected CI Calculation Example

Source: https://pyscf.org/_modules/pyscf/fci/selected_ci.html

Performs a selected CI calculation using the kernel function with a fixed space, starting from a given CI vector. This example demonstrates setting up a molecule, performing RHF, and then running the selected CI.

```python
from functools import reduce
from pyscf import gto
from pyscf import scf
from pyscf.fci import spin_op
from pyscf.fci import addons

mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
    ['H', ( 1.,-1.    , 0.   )],
    ['H', ( 0.,-1.    ,-1.   )],
    ['H', ( 1.,-0.5   ,-1.   )],
    ['H', ( 0.,-0.    ,-1.   )],
    ['H', ( 1.,-0.5   , 0.   )],
    ['H', ( 0., 1.    , 1.   )],
    ['H', ( 1., 2.    , 3.   )],
    ['H', ( 1., 2.    , 4.   )],
]
mol.basis = 'sto-3g'
mol.build()

m = scf.RHF(mol)
m.kernel()
norb = m.mo_coeff.shape[1]
nelec = mol.nelectron
h1e = reduce(numpy.dot, (m.mo_coeff.T, m.get_hcore(), m.mo_coeff))
eri = ao2mo.kernel(m._eri, m.mo_coeff, compact=False)
eri = eri.reshape(norb,norb,norb,norb)

e1, c1 = kernel(h1e, eri, norb, nelec)
e2, c2 = direct_spin1.kernel(h1e, eri, norb, nelec)
print(e1, e1 - -11.894559902235565, 'diff to FCI', e1-e2)

print(c1.shape, c2.shape)
dm1_1 = make_rdm1(c1, norb, nelec)
dm1_2 = direct_spin1.make_rdm1(c2, norb, nelec)
print(abs(dm1_1 - dm1_2).sum())
dm2_1 = make_rdm2(c1, norb, nelec)
dm2_2 = direct_spin1.make_rdm12(c2, norb, nelec)[1]
print(abs(dm2_1 - dm2_2).sum())

myci = SelectedCI()
e, c = kernel_fixed_space(myci, h1e, eri, norb, nelec, c1._strs)
print(e - -11.894559902235565)

print(myci.large_ci(c1, norb, nelec))
print(myci.spin_square(c1, norb, nelec)[0] -
      spin_op.spin_square0(to_fci(c1, norb, nelec), norb, nelec)[0])
```

--------------------------------

### K-point Band Structure Setup

Source: https://pyscf.org/_modules/pyscf/pbc/df/df_jk.html

Initializes variables for k-point band structure calculations, including formatting k-point lists and setting up arrays for potential and kinetic energy matrices.

```python
    kpts_band, input_band = _format_kpts_band(kpts_band, kpts), kpts_band
    nband = len(kpts_band)
    vkR = numpy.zeros((nset,nband,nao,nao))
    vkI = numpy.zeros((nset,nband,nao,nao))
```

--------------------------------

### Example Usage Script

Source: https://pyscf.org/_modules/pyscf/mrpt/nevpt2.html

Demonstrates setting up a CASCI calculation and invoking the transformation utilities.

```python
if __name__ == '__main__':
    from pyscf import gto
    from pyscf import scf
    from pyscf import mcscf

    mol = gto.Mole()
    mol.verbose = 0
    mol.output = None
    mol.atom = [
        ['O', ( 0., 0.    , 0.    )],
        ['O', ( 0., 0.    , 1.207 )],
    ]
    mol.basis = '6-31g'
    mol.spin = 2
    mol.build()

    m = scf.RHF(mol)
    m.conv_tol = 1e-20
    ehf = m.scf()
    mc = mcscf.CASCI(m, 6, 8)
    mc.fcisolver.conv_tol = 1e-14
    ci_e = mc.kernel()[0]
    mc.verbose = 4
    print(ci_e)
    #dm1, dm2, dm3, dm4 = fci.rdm.make_dm1234('FCI4pdm_kern_sf',
    #                                         mc.ci, mc.ci, mc.ncas, mc.nelecas)
    print(sc_nevpt(mc), -0.169785157128082)


    mol = gto.Mole()
    mol.verbose = 0
    mol.output = None
    mol.atom = [
        ['H', ( 0., 0.    , 0.    )],
        ['H', ( 0., 0.    , 0.8   )],
```

--------------------------------

### DMET CAS Guess Execution Example

Source: https://pyscf.org/_modules/pyscf/mcscf/dmet_cas.html

Demonstrates the setup and execution of a CASSCF calculation using DMET-generated initial orbitals.

```python
if __name__ == '__main__':
    from pyscf import mcscf

    mol = gto.M(
        verbose = 0,
        atom = '''
           H    0.000000,  0.500000,  1.5
           O    0.000000,  0.000000,  1.
           O    0.000000,  0.000000, -1.
           H    0.000000, -0.500000, -1.5''',
        basis = 'ccpvdz',
    )

    mf = scf.RHF(mol)
    mf.scf()

    aolst = [i for i,s in enumerate(mol.ao_labels()) if 'H 1s' in s]
    dm = mf.make_rdm1()
    ncas, nelecas, mo = guess_cas(mf, dm, aolst, verbose=4)
    mc = mcscf.CASSCF(mf, ncas, nelecas).set(verbose=4)
    emc = mc.kernel(mo)[0]
    print(emc,)
```

--------------------------------

### PCM Initialization Example

Source: https://pyscf.org/_modules/pyscf/solvent.html

Example demonstrating the initialization of the PCM model with an RHF object and its subsequent kernel execution.

```python
mf = PCM(scf.RHF(mol))
    mf.kernel()
```

--------------------------------

### Execute GCCSD RDM Workflow

Source: https://pyscf.org/_modules/pyscf/cc/gccsd_rdm.html

Example script demonstrating the setup of a GCCSD calculation and the subsequent generation of 1-RDM and 2-RDM.

```python
if __name__ == '__main__':
    from functools import reduce
    from pyscf import gto
    from pyscf import scf
    from pyscf import ao2mo
    from pyscf.cc import gccsd

    mol = gto.Mole()
    mol.atom = [
        [8 , (0. , 0.     , 0.)],
        [1 , (0. , -0.757 , 0.587)],
        [1 , (0. , 0.757  , 0.587)]]
    mol.basis = '631g'
    mol.spin = 2
    mol.build()
    mf = scf.UHF(mol).run(conv_tol=1.)
    mf = scf.addons.convert_to_ghf(mf)

    mycc = gccsd.GCCSD(mf)
    ecc, t1, t2 = mycc.kernel()
    l1, l2 = mycc.solve_lambda()
    dm1 = make_rdm1(mycc, t1, t2, l1, l2)
    dm2 = make_rdm2(mycc, t1, t2, l1, l2)
    nao = mol.nao_nr()
    mo_a = mf.mo_coeff[:nao]
    mo_b = mf.mo_coeff[nao:]
    nmo = mo_a.shape[1]
    eri = ao2mo.kernel(mf._eri, mo_a+mo_b, compact=False).reshape([nmo]*4)
    orbspin = mf.mo_coeff.orbspin
    sym_forbid = (orbspin[:,None] != orbspin)
    eri[sym_forbid,:,:] = 0
    eri[:,:,sym_forbid] = 0
    hcore = scf.RHF(mol).get_hcore()
    h1 = reduce(numpy.dot, (mo_a.T.conj(), hcore, mo_a))
    h1+= reduce(numpy.dot, (mo_b.T.conj(), hcore, mo_b))
    e1 = numpy.einsum('ij,ji', h1, dm1)
    e1+= numpy.einsum('ijkl,ijkl', eri, dm2) * .5
    e1+= mol.energy_nuc()
    print(e1 - mycc.e_tot)
```

--------------------------------

### Example Usage for Symmetry Adaptation

Source: https://pyscf.org/_modules/pyscf/pbc/symm/basis.html

Demonstrates the setup of a water molecule cell and the verification of symmetry-adapted basis against molecular symmetry routines.

```python
if __name__ == "__main__":
    from pyscf.pbc import gto
    cell = gto.Cell()
    cell.atom = [['O' , (1. , 0.    , 0.   ,)],
                 ['H' , (0. , -.757 , 0.587,)],
                 ['H' , (0. , 0.757 , 0.587,)]]
    cell.a = [[1., 0., 0.],
              [0., 1., 0.],
              [0., 0., 1.]]
    cell.basis = 'ccpvdz'
    cell.verbose = 5
    cell.space_group_symmetry = True
    cell.symmorphic = True
    cell.build()
    kpts = cell.make_kpts([1,1,1], space_group_symmetry=True)
    so = symm_adapted_basis(cell, kpts)[0][0]

    from pyscf import gto as mol_gto
    from pyscf.symm import geom as mol_geom
    from pyscf.symm.basis import symm_adapted_basis as mol_symm_adapted_basis
    mol = cell.copy()
    gpname, origin, axes = mol_geom.detect_symm(mol._atom)
    atoms = mol_gto.format_atom(cell._atom, origin, axes)
    mol.build(False, False, atom=atoms)
    mol_so = mol_symm_adapted_basis(mol, gpname)[0]

    print(abs(so[0] - mol_so[0]).max())
    print(abs(so[1] - mol_so[1]).max())
    print(abs(so[2] - mol_so[3]).max())
    print(abs(so[3] - mol_so[2]).max())
```

--------------------------------

### Setup C Backend Options

Source: https://pyscf.org/_modules/pyscf/sgx/sgx_jk.html

Initializes the C backend options for integral calculations, including number of basis functions, grids, and screening parameters. This function configures the internal data structures required for efficient computation.

```python
def _setup_opt(self):
        """
        Set up the C backend for the data.
        """
        self._this.mode = 0
        self._this.nbas = self.mol.nbas
        self._this.ngrids = self.grids.weights.size
        self._this.ao_loc = _arr2c(self._ao_loc)
        if self._screen_energy:
            self._this.etol = self._etol_per_sgx_block
        else:
            self._this.etol = 1e10
        self._this.vtol = None
        self._this.wt = None  # set in each cycle
        self._this.mbar_ij = _arr2c(self._mbar_ij)
        self._this.mmax_i = _arr2c(self._mmax_i)
        self._this.msum_i = _arr2c(self._msum_i)
        if self.bound_algo == "sample_pos":
            self._this.rbar_ij = _arr2c(self._rbar_ij)
        else:
            self._this.rbar_ij = None
        self._this.mbar_bi = None
        if self._screen_energy or self._screen_potential:
            # buf can contain the following:
            # For batch screening step
            #   Nothing for no dm screening
            #   3 * nbas * double, 2 * nbas * int for sort1
            #   5 * nbas * double, 2 * nbas * int for sort2
            # For the shell screening step
            #   Nothing for no dm screening
            #   3 * nbas * double, 3 nbas * int
            dsize = self.mol.nbas * ctypes.sizeof(ctypes.c_double)
            isize = self.mol.nbas * ctypes.sizeof(ctypes.c_int)
            bsize = self.mol.nbas * ctypes.sizeof(ctypes.c_uint8)
            # shl_info can contain the following:
            #   shlscreen_i (nbas * uint8_t)
            #   bscreen_i (nbas * double)
            #   fbar_i (nbas * double)
            #   ffbar_i (nbas * double)
            bsb = 5 * dsize + 3 * isize
            sisb = bsize + 3 * dsize
            grid_screen = "SGXscreen_grid"
            shl_screen = "SGXscreen_shells_sorted"
        else:
            bsb = 0
            sisb = 0
            grid_screen = "SGXnoscreen_grid"
            shl_screen = "SGXscreen_shells_simple"
        self._this.fscreen_grid = _vhf._fpointer(grid_screen)
        self._this.fscreen_shl = _vhf._fpointer(shl_screen)
        self._this.direct_scf_tol = self._itol
        self._this.buf_size_bytes = bsb
        self._this.shl_info_size_bytes = sisb
        # TODO need to make this modifiable in the future
        # for more sophisticated use cases.
        if self.mol.cart:
            self._intor = "int1e_grids_cart"
        else:
            self._intor = "int1e_grids_sph"

```

--------------------------------

### Run PBC SCF JK calculation example

Source: https://pyscf.org/_modules/pyscf/pbc/df/mdf_jk.html

Demonstrates setting up a periodic cell and calculating JK matrices with density fitting.

```python
if __name__ == '__main__':
    import pyscf.pbc.gto as pgto
    import pyscf.pbc.scf as pscf

    L = 5.
    n = 11
    cell = pgto.Cell()
    cell.a = numpy.diag([L,L,L])
    cell.mesh = numpy.array([n,n,n])

    cell.atom = '''C    3.    2.       3.
                   C    1.    1.       1.'''
    #cell.basis = {'He': [[0, (1.0, 1.0)]]}
    #cell.basis = '631g'
    #cell.basis = {'He': [[0, (2.4, 1)], [1, (1.1, 1)]]}
    cell.basis = 'ccpvdz'
    cell.verbose = 0
    cell.build(0,0)
    cell.verbose = 5
    #print cell.nimgs
    #cell.nimgs = [4,4,4]

    mf = pscf.RHF(cell)
    auxbasis = 'weigend'
    mf = density_fit(mf, auxbasis)
    mf.with_df.mesh = (n,) * 3
    dm = mf.get_init_guess()
    vj = get_jk(mf.with_df, dm, exxdiv=mf.exxdiv, with_k=False)[0]
    print(numpy.einsum('ij,ji->', vj, dm), 'ref=46.698951141791')
    vj, vk = get_jk(mf.with_df, dm, exxdiv=mf.exxdiv)
    print(numpy.einsum('ij,ji->', vj, dm), 'ref=46.698951141791')
    print(numpy.einsum('ij,ji->', vk, dm), 'ref=37.348980782463')

    kpts = cell.make_kpts([2]*3)[:4]
    from pyscf.pbc.df import MDF
    with_df = MDF(cell, kpts)
    with_df.auxbasis = 'weigend'
    with_df.mesh = [n] * 3
    dms = numpy.array([dm]*len(kpts))
    vj, vk = with_df.get_jk(dms, exxdiv=mf.exxdiv, kpts=kpts)
    print(numpy.einsum('ij,ji->', vj[0], dms[0]), - 46.69784775484954)
    print(numpy.einsum('ij,ji->', vj[1], dms[1]), - 46.69815612398015)
    print(numpy.einsum('ij,ji->', vj[2], dms[2]), - 46.69526857884275)
    print(numpy.einsum('ij,ji->', vj[3], dms[3]), - 46.69571387135913)
    print(numpy.einsum('ij,ji->', vk[0], dms[0]), - 37.27054185436858)
    print(numpy.einsum('ij,ji->', vk[1], dms[1]), - 37.27081050772277)
    print(numpy.einsum('ij,ji->', vk[2], dms[2]), - 37.27081024429790)
    print(numpy.einsum('ij,ji->', vk[3], dms[3]), - 37.27090527533867)
```

--------------------------------

### RADCIP Initialization Example

Source: https://pyscf.org/_modules/pyscf/adc/radc_ip.html

Instantiate and run the RADCIP class. Requires a pre-computed ADC object.

```python
myadc = adc.RADC(mf).run()
myadcip = adc.RADCIP(myadc).run()
```

--------------------------------

### CCSD(T) Calculation Example

Source: https://pyscf.org/_modules/pyscf/cc/gccsd_t.html

Demonstrates a standard CCSD(T) calculation using PySCF, starting from RHF. The result is compared with the GHF-CCSD(T) calculation.

```python
from pyscf import gto
from pyscf import scf
from pyscf import cc

mol = gto.Mole()
mol.atom = [
    [8 , (0. , 0.     , 0.)],
    [1 , (0. , -.957 , .587)],
    [1 , (0.2,  .757 , .487)]]

mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-1)
mycc = cc.CCSD(mf).set(conv_tol=1e-11).run()
et = mycc.ccsd_t()

mycc = cc.GCCSD(mf.to_ghf()).set(conv_tol=1e-11).run()
eris = mycc.ao2mo()
print(kernel(mycc, eris) - et)
```
Tokens:
Raw