pyscf.pbc package

Subpackages

• pyscf.pbc.adc package
  • Submodules
  • pyscf.pbc.adc.dfadc module
    • get_ovvv_df()
    • get_vvvv_df()
  • pyscf.pbc.adc.kadc_ao2mo module
    • calculate_chunk_size()
    • transform_integrals_df()
    • transform_integrals_incore()
    • transform_integrals_outcore()
  • pyscf.pbc.adc.kadc_rhf module
    • RADC
      • RADC.compute_amplitudes()
      • RADC.compute_amplitudes_energy()
      • RADC.compute_energy()
      • RADC.density_fit()
      • RADC.ea_adc()
      • RADC.get_chnk_size()
      • RADC.get_nmo()
      • RADC.get_nocc()
      • RADC.ip_adc()
      • RADC.kernel()
      • RADC.kernel_gs()
      • RADC.nkpts
      • RADC.nmo
      • RADC.nocc
      • RADC.transform_integrals()
    • kernel()
  • pyscf.pbc.adc.kadc_rhf_amplitudes module
    • compute_amplitudes()
    • compute_amplitudes_energy()
    • compute_energy()
    • contract_ladder()
  • pyscf.pbc.adc.kadc_rhf_ea module
    • RADCEA
      • RADCEA.gen_matvec()
      • RADCEA.get_diag()
      • RADCEA.get_imds()
      • RADCEA.get_init_guess()
      • RADCEA.get_properties()
      • RADCEA.get_trans_moments()
      • RADCEA.kernel()
      • RADCEA.matvec()
      • RADCEA.renormalize_eigenvectors()
      • RADCEA.vector_size()
    • ea_contract_r_vvvv()
    • get_diag()
    • get_imds()
    • get_properties()
    • get_trans_moments()
    • get_trans_moments_orbital()
    • matvec()
    • renormalize_eigenvectors()
    • vector_size()
  • pyscf.pbc.adc.kadc_rhf_ip module
    • RADCIP
      • RADCIP.gen_matvec()
      • RADCIP.get_diag()
      • RADCIP.get_imds()
      • RADCIP.get_init_guess()
      • RADCIP.get_properties()
      • RADCIP.get_trans_moments()
      • RADCIP.kernel()
      • RADCIP.matvec()
      • RADCIP.renormalize_eigenvectors()
      • RADCIP.vector_size()
    • get_diag()
    • get_imds()
    • get_properties()
    • get_trans_moments()
    • get_trans_moments_orbital()
    • matvec()
    • renormalize_eigenvectors()
    • vector_size()
  • Module contents
    • KRADC()
• pyscf.pbc.ao2mo package
  • Submodules
  • pyscf.pbc.ao2mo.eris module
    • assemble_eri()
    • general()
    • get_ao_eri()
    • get_ao_pairs_G()
    • get_mo_eri()
    • get_mo_pairs_G()
    • get_mo_pairs_invG()
  • Module contents
• pyscf.pbc.cc package
  • Submodules
  • pyscf.pbc.cc.ccsd module
    • GCCSD
      • GCCSD.ao2mo()
      • GCCSD.ccsd()
    • RCCSD
      • RCCSD.ao2mo()
      • RCCSD.ccsd()
    • UCCSD
      • UCCSD.ao2mo()
      • UCCSD.ccsd()
  • pyscf.pbc.cc.eom_kccsd_ghf module
    • EOMEA
      • EOMEA.amplitudes_to_vector()
      • EOMEA.ccsd_star_contract()
      • EOMEA.eaccsd()
      • EOMEA.eaccsd_star()
      • EOMEA.eaccsd_star_contract()
      • EOMEA.gen_matvec()
      • EOMEA.get_diag()
      • EOMEA.get_init_guess()
      • EOMEA.get_padding_k_idx()
      • EOMEA.kernel()
      • EOMEA.l_matvec()
      • EOMEA.make_imds()
      • EOMEA.mask_frozen()
      • EOMEA.matvec()
      • EOMEA.nkpts
      • EOMEA.vector_size()
      • EOMEA.vector_to_amplitudes()
    • EOMEA_Ta
      • EOMEA_Ta.make_imds()
    • EOMEE
      • EOMEE.amplitudes_to_vector()
      • EOMEE.eeccsd()
      • EOMEE.gen_matvec()
      • EOMEE.get_diag()
      • EOMEE.get_init_guess()
      • EOMEE.get_kconserv_ee_r1()
      • EOMEE.get_kconserv_ee_r2()
      • EOMEE.kernel()
      • EOMEE.make_imds()
      • EOMEE.matvec()
      • EOMEE.nkpts
      • EOMEE.vector_size()
      • EOMEE.vector_to_amplitudes()
    • EOMIP
      • EOMIP.amplitudes_to_vector()
      • EOMIP.ccsd_star_contract()
      • EOMIP.gen_matvec()
      • EOMIP.get_diag()
      • EOMIP.get_init_guess()
      • EOMIP.get_padding_k_idx()
      • EOMIP.ipccsd()
      • EOMIP.ipccsd_star()
      • EOMIP.ipccsd_star_contract()
      • EOMIP.kernel()
      • EOMIP.l_matvec()
      • EOMIP.make_imds()
      • EOMIP.mask_frozen()
      • EOMIP.matvec()
      • EOMIP.nkpts
      • EOMIP.vector_size()
      • EOMIP.vector_to_amplitudes()
    • EOMIP_Ta
      • EOMIP_Ta.make_imds()
    • amplitudes_to_vector_ea()
    • amplitudes_to_vector_ee()
    • amplitudes_to_vector_ip()
    • eaccsd()
    • eaccsd_diag()
    • eaccsd_matvec()
    • eaccsd_star()
    • eaccsd_star_contract()
    • eeccsd()
    • eeccsd_diag()
    • eeccsd_matvec()
    • enforce_2p_spin_doublet()
    • enforce_2p_spin_ea_doublet()
    • enforce_2p_spin_ip_doublet()
    • get_padding_k_idx()
    • ipccsd()
    • ipccsd_diag()
    • ipccsd_matvec()
    • ipccsd_star()
    • ipccsd_star_contract()
    • kernel()
    • kernel_ee()
    • leaccsd_matvec()
    • lipccsd_matvec()
    • mask_frozen_ea()
    • mask_frozen_ip()
    • perturbed_ccsd_kernel()
    • spatial2spin_ea_doublet()
    • spatial2spin_ip_doublet()
    • spin2spatial_ea_doublet()
    • spin2spatial_ip_doublet()
    • vector_to_amplitudes_ea()
    • vector_to_amplitudes_ee()
    • vector_to_amplitudes_ip()
  • pyscf.pbc.cc.eom_kccsd_rhf module
    • EOMEA
      • EOMEA.amplitudes_to_vector()
      • EOMEA.ccsd_star_contract()
      • EOMEA.ea_amplitudes_to_vector()
      • EOMEA.ea_vector_desc
      • EOMEA.ea_vector_to_amplitudes()
      • EOMEA.get_diag()
      • EOMEA.l_matvec()
      • EOMEA.make_imds()
      • EOMEA.mask_frozen()
      • EOMEA.matvec()
      • EOMEA.nkpts
      • EOMEA.vector_size()
      • EOMEA.vector_to_amplitudes()
    • EOMEA_Ta
      • EOMEA_Ta.make_imds()
    • EOMEE
      • EOMEE.eeccsd()
      • EOMEE.get_diag()
      • EOMEE.kernel()
      • EOMEE.make_imds()
      • EOMEE.matvec()
      • EOMEE.nkpts
      • EOMEE.vector_size()
    • EOMEESinglet
      • EOMEESinglet.amplitudes_to_vector()
      • EOMEESinglet.cis()
      • EOMEESinglet.eomee_ccsd_singlet()
      • EOMEESinglet.gen_matvec()
      • EOMEESinglet.get_init_guess()
      • EOMEESinglet.kernel()
      • EOMEESinglet.matvec()
      • EOMEESinglet.vector_size()
      • EOMEESinglet.vector_to_amplitudes()
    • EOMEESpinFlip
      • EOMEESpinFlip.vector_size()
    • EOMEETriplet
      • EOMEETriplet.vector_size()
    • EOMIP
      • EOMIP.amplitudes_to_vector()
      • EOMIP.ccsd_star_contract()
      • EOMIP.get_diag()
      • EOMIP.ip_amplitudes_to_vector()
      • EOMIP.ip_vector_desc
      • EOMIP.ip_vector_to_amplitudes()
      • EOMIP.l_matvec()
      • EOMIP.make_imds()
      • EOMIP.mask_frozen()
      • EOMIP.matvec()
      • EOMIP.nkpts
      • EOMIP.vector_size()
      • EOMIP.vector_to_amplitudes()
    • EOMIP_Ta
      • EOMIP_Ta.make_imds()
    • amplitudes_to_vector_singlet()
    • cis_easy()
    • eaccsd_diag()
    • eaccsd_matvec()
    • eaccsd_star_contract()
    • eeccsd()
    • eeccsd_cis_approx_slow()
    • eeccsd_diag()
    • eeccsd_matvec()
    • eeccsd_matvec_singlet()
    • eeccsd_matvec_singlet_Hr1()
    • eomee_ccsd_singlet()
    • get_init_guess_cis()
    • ipccsd_diag()
    • ipccsd_matvec()
    • ipccsd_star_contract()
    • join_indices()
    • leaccsd_matvec()
    • lipccsd_matvec()
    • vector_to_amplitudes_singlet()
  • pyscf.pbc.cc.eom_kccsd_rhf_ea module
    • amplitudes_to_vector()
    • iter_12()
    • vector_size()
    • vector_to_amplitudes()
  • pyscf.pbc.cc.eom_kccsd_rhf_ip module
    • amplitudes_to_vector()
    • iter_12()
    • vector_size()
    • vector_to_amplitudes()
  • pyscf.pbc.cc.eom_kccsd_uhf module
    • EOMEA
      • EOMEA.amplitudes_to_vector()
      • EOMEA.get_diag()
      • EOMEA.get_init_guess()
      • EOMEA.get_padding_k_idx()
      • EOMEA.make_imds()
      • EOMEA.mask_frozen()
      • EOMEA.matvec()
      • EOMEA.vector_size()
      • EOMEA.vector_to_amplitudes()
    • EOMIP
      • EOMIP.amplitudes_to_vector()
      • EOMIP.gen_matvec()
      • EOMIP.get_diag()
      • EOMIP.get_init_guess()
      • EOMIP.get_padding_k_idx()
      • EOMIP.make_imds()
      • EOMIP.mask_frozen()
      • EOMIP.matvec()
      • EOMIP.vector_size()
      • EOMIP.vector_to_amplitudes()
    • amplitudes_to_vector_ea()
    • amplitudes_to_vector_ip()
    • eaccsd_diag()
    • eaccsd_matvec()
    • get_padding_k_idx()
    • ipccsd_diag()
    • ipccsd_matvec()
    • mask_frozen_ea()
    • mask_frozen_ip()
    • vector_to_amplitudes_ea()
    • vector_to_amplitudes_ip()
  • pyscf.pbc.cc.kccsd module
    • CCSD
    • GCCSD
      • GCCSD.amplitudes_to_vector()
      • GCCSD.ao2mo()
      • GCCSD.ccsd()
      • GCCSD.ccsd_t()
      • GCCSD.dump_flags()
      • GCCSD.energy()
      • GCCSD.from_uccsd()
      • GCCSD.get_frozen_mask()
      • GCCSD.get_nmo()
      • GCCSD.get_nocc()
      • GCCSD.init_amps()
      • GCCSD.nkpts
      • GCCSD.spatial2spin()
      • GCCSD.spin2spatial()
      • GCCSD.to_gpu()
      • GCCSD.to_uccsd()
      • GCCSD.update_amps()
      • GCCSD.vector_to_amplitudes()
    • KCCSD
    • KGCCSD
    • check_antisymm_12()
    • check_antisymm_34()
    • check_antisymm_3412()
    • energy()
    • spatial2spin()
    • spin2spatial()
    • update_amps()
  • pyscf.pbc.cc.kccsd_rhf module
    • KRCCSD
    • RCCSD
      • RCCSD.amplitudes_to_vector()
      • RCCSD.ao2mo()
      • RCCSD.ccsd()
      • RCCSD.ccsd_t()
      • RCCSD.ccsd_vector_desc
      • RCCSD.dump_flags()
      • RCCSD.eaccsd()
      • RCCSD.eaccsd_diag()
      • RCCSD.eaccsd_matvec()
      • RCCSD.energy()
      • RCCSD.get_frozen_mask()
      • RCCSD.get_nmo()
      • RCCSD.get_nocc()
      • RCCSD.get_normt_diff()
      • RCCSD.imds
      • RCCSD.init_amps()
      • RCCSD.ipccsd()
      • RCCSD.ipccsd_diag()
      • RCCSD.ipccsd_matvec()
      • RCCSD.kernel()
      • RCCSD.max_space
      • RCCSD.nkpts
      • RCCSD.to_gpu()
      • RCCSD.update_amps()
      • RCCSD.vector_to_amplitudes()
    • add_vvvv_()
    • describe_nested()
    • energy()
    • get_normt_diff()
    • kconserve_pmatrix()
    • nested_to_vector()
    • update_amps()
    • vector_to_nested()
  • pyscf.pbc.cc.kccsd_rhf_ksymm module
    • KsymAdaptedRCCSD
      • KsymAdaptedRCCSD.amplitudes_to_vector()
      • KsymAdaptedRCCSD.ao2mo()
      • KsymAdaptedRCCSD.energy()
      • KsymAdaptedRCCSD.init_amps()
      • KsymAdaptedRCCSD.update_amps()
      • KsymAdaptedRCCSD.vector_to_amplitudes()
    • add_vvvv_()
    • energy()
    • update_amps()
  • pyscf.pbc.cc.kccsd_t module
    • kernel()
  • pyscf.pbc.cc.kccsd_t_rhf module
    • check_read_success()
    • create_eris_vooo()
    • create_eris_vvop()
    • create_t3_eris()
    • get_data_slices()
    • kernel()
    • transpose_t2()
    • zip_kpoints()
  • pyscf.pbc.cc.kccsd_t_rhf_slow module
    • kernel()
  • pyscf.pbc.cc.kccsd_uhf module
    • KUCCSD
      • KUCCSD.amplitudes_to_vector()
      • KUCCSD.ao2mo()
      • KUCCSD.dump_flags()
      • KUCCSD.energy()
      • KUCCSD.get_frozen_mask()
      • KUCCSD.get_nmo()
      • KUCCSD.get_nocc()
      • KUCCSD.get_normt_diff()
      • KUCCSD.init_amps()
      • KUCCSD.max_space
      • KUCCSD.nkpts
      • KUCCSD.to_gpu()
      • KUCCSD.update_amps()
      • KUCCSD.vector_to_amplitudes()
    • UCCSD
    • add_vvvv_()
    • amplitudes_to_vector()
    • convert_mo_coeff()
    • energy()
    • get_normt_diff()
    • mo_c_list_to_array()
    • update_amps()
    • vector_to_amplitudes()
  • pyscf.pbc.cc.kintermediates module
    • Foo()
    • Fov()
    • Fvv()
    • Woooo()
    • Wooov()
    • Wovoo()
    • Wovvo()
    • Wvovv()
    • Wvvvo()
    • Wvvvv()
    • cc_Foo()
    • cc_Fov()
    • cc_Fvv()
    • cc_Woooo()
    • cc_Wovvo()
    • cc_Wovvo_jk()
    • cc_Wvvvv()
    • get_full_t3p2()
    • get_t3p2_imds_slow()
    • make_tau()
  • pyscf.pbc.cc.kintermediates_rhf module
    • Loo()
    • Lvv()
    • W1ovov()
    • W1ovvo()
    • W2ovov()
    • W2ovvo()
    • Woooo()
    • Wooov()
    • Wovoo()
    • Wovov()
    • Wovvo()
    • Wvovv()
    • Wvvvo()
    • Wvvvv()
    • cc_Foo()
    • cc_Fov()
    • cc_Fvv()
    • cc_Woooo()
    • cc_Wvoov()
    • cc_Wvovo()
    • cc_Wvvvv()
    • get_Wvvvv()
    • get_t3p2_imds()
    • get_t3p2_imds_slow()
  • pyscf.pbc.cc.kintermediates_rhf_ksymm module
    • Loo()
    • Lvv()
    • cc_Foo()
    • cc_Fov()
    • cc_Fvv()
    • cc_Woooo()
    • cc_Wvoov()
    • cc_Wvovo()
    • cc_Wvvvv()
  • pyscf.pbc.cc.kintermediates_uhf module
    • Foo()
    • Fov()
    • Fvv()
    • W1oovv()
    • W2oovv()
    • Woooo()
    • Wooov()
    • Woovo()
    • Woovv()
    • Wovvo()
    • Wvvov()
    • Wvvvo()
    • Wvvvv()
    • cc_Foo()
    • cc_Fov()
    • cc_Fvv()
    • cc_Woooo()
    • cc_Wovvo()
    • cc_Wvvvv()
    • cc_Wvvvv_half()
    • get_Wvvvv()
    • kconserv_mat()
    • make_tau()
    • make_tau2()
  • pyscf.pbc.cc.kuccsd_rdm module
    • make_rdm1()
  • Module contents
    • CCSD()
    • GCCSD()
    • KCCSD()
    • KGCCSD()
    • KRCCSD()
    • KUCCSD()
    • RCCSD()
    • UCCSD()
• pyscf.pbc.ci package
  • Submodules
  • pyscf.pbc.ci.cisd module
    • GCISD
      • GCISD.ao2mo()
    • RCISD
      • RCISD.ao2mo()
    • UCISD
      • UCISD.ao2mo()
  • pyscf.pbc.ci.kcis_rhf module
    • KCIS
      • KCIS.amplitudes_to_vector()
      • KCIS.ao2mo()
      • KCIS.dump_flags()
      • KCIS.gen_matvec()
      • KCIS.get_diag()
      • KCIS.get_frozen_mask()
      • KCIS.get_init_guess()
      • KCIS.get_kconserv_r()
      • KCIS.get_nmo()
      • KCIS.get_nocc()
      • KCIS.kernel()
      • KCIS.matvec()
      • KCIS.nkpts
      • KCIS.nmo
      • KCIS.nocc
      • KCIS.vector_size()
      • KCIS.vector_to_amplitudes()
    • cis_H()
    • cis_diag()
    • cis_matvec_singlet()
    • kernel()
  • Module contents
    • CIS()
    • CISD()
    • GCISD()
    • KCIS()
    • RCISD()
    • UCISD()
• pyscf.pbc.df package
  • Submodules
  • pyscf.pbc.df.aft module
    • AFTDF
      • AFTDF.ao2mo()
      • AFTDF.ao2mo_7d()
      • AFTDF.blockdim
      • AFTDF.build()
      • AFTDF.check_sanity()
      • AFTDF.dump_flags()
      • AFTDF.get_ao_eri()
      • AFTDF.get_ao_pairs()
      • AFTDF.get_ao_pairs_G()
      • AFTDF.get_eri()
      • AFTDF.get_jk()
      • AFTDF.get_mo_eri()
      • AFTDF.get_mo_pairs()
      • AFTDF.get_mo_pairs_G()
      • AFTDF.get_naoaux()
      • AFTDF.get_nuc()
      • AFTDF.get_pp()
      • AFTDF.loop()
      • AFTDF.prange()
      • AFTDF.reset()
      • AFTDF.update_mf()
    • AFTDFMixin
      • AFTDFMixin.ft_loop()
      • AFTDFMixin.pw_loop()
      • AFTDFMixin.range_coulomb()
      • AFTDFMixin.weighted_coulG()
    • estimate_eta()
    • estimate_eta_for_ke_cutoff()
    • estimate_eta_min()
    • estimate_ke_cutoff()
    • estimate_ke_cutoff_for_eta()
    • estimate_ke_cutoff_for_omega()
    • estimate_omega()
    • estimate_omega_for_ke_cutoff()
    • estimate_omega_min()
    • get_nuc()
    • get_pp()
    • weighted_coulG()
  • pyscf.pbc.df.aft_ao2mo module
    • ao2mo_7d()
    • general()
    • get_ao_pairs_G()
    • get_eri()
    • get_mo_pairs_G()
  • pyscf.pbc.df.aft_jk module
    • get_j_for_bands()
    • get_j_kpts()
    • get_jk()
    • get_k_for_bands()
    • get_k_kpts()
  • pyscf.pbc.df.df module
    • CDERIArray
      • CDERIArray.load()
    • DF
    • GDF
      • GDF.ao2mo()
      • GDF.ao2mo_7d()
      • GDF.auxbasis
      • GDF.blockdim
      • GDF.build()
      • GDF.cderi_array()
      • GDF.dump_flags()
      • GDF.force_dm_kbuild
      • GDF.get_ao_eri()
      • GDF.get_eri()
      • GDF.get_jk()
      • GDF.get_mo_eri()
      • GDF.get_naoaux()
      • GDF.get_nuc()
      • GDF.get_pp()
      • GDF.gs
      • GDF.has_kpts()
      • GDF.loop()
      • GDF.prange()
      • GDF.reset()
      • GDF.sr_loop()
      • GDF.to_gpu()
      • GDF.update()
      • GDF.update_cc()
      • GDF.update_mp()
    • make_auxcell()
    • make_modrho_basis()
  • pyscf.pbc.df.df_ao2mo module
    • PBC2DIntegralsWarning
    • ao2mo_7d()
    • general()
    • get_eri()
    • warn_pbc2d_eri()
  • pyscf.pbc.df.df_jk module
    • density_fit()
    • get_j_kpts()
    • get_j_kpts_kshift()
    • get_jk()
    • get_k_kpts()
    • get_k_kpts_kshift()
  • pyscf.pbc.df.fft module
    • FFTDF
      • FFTDF.ao2mo()
      • FFTDF.ao2mo_7d()
      • FFTDF.aoR_loop()
      • FFTDF.blockdim
      • FFTDF.build()
      • FFTDF.check_sanity()
      • FFTDF.dump_flags()
      • FFTDF.get_ao_eri()
      • FFTDF.get_ao_pairs()
      • FFTDF.get_ao_pairs_G()
      • FFTDF.get_eri()
      • FFTDF.get_j_e1()
      • FFTDF.get_jk()
      • FFTDF.get_jk_e1()
      • FFTDF.get_k_e1()
      • FFTDF.get_mo_eri()
      • FFTDF.get_mo_pairs()
      • FFTDF.get_mo_pairs_G()
      • FFTDF.get_naoaux()
      • FFTDF.get_nuc()
      • FFTDF.get_pp()
      • FFTDF.loop()
      • FFTDF.mesh
      • FFTDF.range_coulomb()
      • FFTDF.reset()
      • FFTDF.to_gpu()
      • FFTDF.update_mf()
    • get_nuc()
    • get_pp()
  • pyscf.pbc.df.fft_ao2mo module
    • ao2mo_7d()
    • general()
    • get_ao_pairs_G()
    • get_eri()
    • get_mo_pairs_G()
  • pyscf.pbc.df.fft_jk module
    • get_j()
    • get_j_e1_kpts()
    • get_j_kpts()
    • get_jk()
    • get_k()
    • get_k_e1_kpts()
    • get_k_kpts()
  • pyscf.pbc.df.ft_ao module
    • ExtendedMole
      • ExtendedMole.bas_map
      • ExtendedMole.bas_mask_to_segment()
      • ExtendedMole.bas_type_to_indices()
      • ExtendedMole.from_cell()
      • ExtendedMole.gen_ft_kernel()
      • ExtendedMole.get_ovlp_mask()
      • ExtendedMole.sh_loc
      • ExtendedMole.strip_basis()
    • estimate_rcut()
    • ft_ao()
    • ft_aopair()
    • ft_aopair_kpts()
    • gen_ft_kernel()
  • pyscf.pbc.df.gdf_builder module
    • auxbar()
    • estimate_eta_for_ke_cutoff()
    • estimate_eta_min()
    • estimate_ke_cutoff_for_eta()
    • estimate_rcut()
    • fuse_auxcell()
    • make_modchg_basis()
  • pyscf.pbc.df.incore module
    • Int3cBuilder
      • Int3cBuilder.build()
      • Int3cBuilder.gen_int3c_kernel()
      • Int3cBuilder.get_q_cond()
      • Int3cBuilder.reset()
    • aux_e2()
    • aux_e2_sum_auxbas()
    • estimate_rcut()
    • fill_2c2e()
    • format_aux_basis()
    • int3c1e_nuc_grad()
    • make_auxcell()
    • make_auxmol()
    • wrap_int3c()
    • wrap_int3c1e_nuc_grad()
    • wrap_int3c_sum_auxbas()
  • pyscf.pbc.df.mdf module
    • MDF
      • MDF.ao2mo()
      • MDF.ao2mo_7d()
      • MDF.build()
      • MDF.get_ao_eri()
      • MDF.get_eri()
      • MDF.get_jk()
      • MDF.get_mo_eri()
      • MDF.get_naoaux()
      • MDF.get_nuc()
      • MDF.get_pp()
      • MDF.loop()
      • MDF.update()
      • MDF.update_cc()
      • MDF.update_mp()
  • pyscf.pbc.df.mdf_ao2mo module
    • ao2mo_7d()
    • general()
    • get_eri()
  • pyscf.pbc.df.mdf_jk module
    • density_fit()
    • get_j_kpts()
    • get_jk()
    • get_k_kpts()
  • pyscf.pbc.df.outcore module
    • aux_e1()
  • pyscf.pbc.df.rsdf module
    • RSDF
    • RSGDF
      • RSGDF.build()
      • RSGDF.dump_flags()
      • RSGDF.weighted_coulG()
    • get_aux_chg()
  • pyscf.pbc.df.rsdf_builder module
    • estimate_ft_rcut()
    • estimate_ke_cutoff_for_omega()
    • estimate_omega_for_ke_cutoff()
    • estimate_omega_min()
    • estimate_rcut()
    • get_nuc()
    • get_pp()
  • pyscf.pbc.df.rsdf_helper module
    • MoleNoBasSort
      • MoleNoBasSort.build()
    • estimate_mesh_for_omega()
    • estimate_omega_for_npw()
    • intor_j2c()
    • remove_exp_basis()
    • wrap_int3c_nospltbas()
  • pyscf.pbc.df.rsdf_jk module
    • density_fit()
  • Module contents
• pyscf.pbc.dft package
  • Subpackages
    • pyscf.pbc.dft.multigrid package
      • Submodules
      • pyscf.pbc.dft.multigrid.multigrid module
      • pyscf.pbc.dft.multigrid.multigrid_pair module
      • pyscf.pbc.dft.multigrid.pp module
      • pyscf.pbc.dft.multigrid.utils module
      • Module contents
  • Submodules
  • pyscf.pbc.dft.cdft module
    • cdft()
    • fast_iao_mullikan_pop()
  • pyscf.pbc.dft.gen_grid module
    • AtomicGrids
    • BeckeGrids
      • BeckeGrids.build()
      • BeckeGrids.make_mask()
      • BeckeGrids.to_gpu()
    • UniformGrids
      • UniformGrids.build()
      • UniformGrids.coords
      • UniformGrids.cutoff
      • UniformGrids.dump_flags()
      • UniformGrids.kernel()
      • UniformGrids.make_mask()
      • UniformGrids.reset()
      • UniformGrids.to_gpu()
      • UniformGrids.weights
    • gen_becke_grids()
    • get_becke_grids()
    • make_mask()
  • pyscf.pbc.dft.gks module
    • GKS
      • GKS.collinear
      • GKS.dump_flags()
      • GKS.energy_elec()
      • GKS.get_veff()
      • GKS.nuc_grad_method()
      • GKS.spin_samples
      • GKS.stability()
      • GKS.to_gpu()
      • GKS.to_hf()
      • GKS.x2c()
      • GKS.x2c1e()
    • get_veff()
  • pyscf.pbc.dft.kgks module
    • KGKS
      • KGKS.collinear
      • KGKS.dump_flags()
      • KGKS.energy_elec()
      • KGKS.get_rho()
      • KGKS.get_veff()
      • KGKS.nuc_grad_method()
      • KGKS.spin_samples
      • KGKS.stability()
      • KGKS.to_gpu()
      • KGKS.to_hf()
      • KGKS.x2c()
      • KGKS.x2c1e()
    • get_veff()
  • pyscf.pbc.dft.krks module
    • KRKS
      • KRKS.dump_flags()
      • KRKS.energy_elec()
      • KRKS.get_rho()
      • KRKS.get_veff()
      • KRKS.nuc_grad_method()
      • KRKS.to_gpu()
      • KRKS.to_hf()
    • energy_elec()
    • get_rho()
    • get_veff()
  • pyscf.pbc.dft.krks_ksymm module
    • KRKS
    • KsymAdaptedKRKS
      • KsymAdaptedKRKS.dump_chk()
      • KsymAdaptedKRKS.dump_flags()
      • KsymAdaptedKRKS.eig()
      • KsymAdaptedKRKS.energy_elec()
      • KsymAdaptedKRKS.get_hcore()
      • KsymAdaptedKRKS.get_init_guess()
      • KsymAdaptedKRKS.get_jk()
      • KsymAdaptedKRKS.get_occ()
      • KsymAdaptedKRKS.get_orbsym()
      • KsymAdaptedKRKS.get_ovlp()
      • KsymAdaptedKRKS.get_rho()
      • KsymAdaptedKRKS.get_veff()
      • KsymAdaptedKRKS.init_guess_by_chkfile()
      • KsymAdaptedKRKS.kpts
      • KsymAdaptedKRKS.orbsym
      • KsymAdaptedKRKS.to_hf()
    • get_rho()
    • get_veff()
  • pyscf.pbc.dft.krkspu module
    • KRKSpU
      • KRKSpU.energy_elec()
      • KRKSpU.get_veff()
      • KRKSpU.nuc_grad_method()
      • KRKSpU.to_hf()
    • energy_elec()
    • format_idx()
    • get_veff()
    • make_minao_lo()
    • mdot()
    • proj_ref_ao()
    • set_U()
  • pyscf.pbc.dft.krkspu_ksymm module
    • KRKSpU
    • KsymAdaptedKRKSpU
      • KsymAdaptedKRKSpU.energy_elec()
      • KsymAdaptedKRKSpU.get_veff()
      • KsymAdaptedKRKSpU.to_hf()
  • pyscf.pbc.dft.kroks module
    • KROKS
      • KROKS.dump_flags()
      • KROKS.energy_elec()
      • KROKS.get_rho()
      • KROKS.get_veff()
      • KROKS.to_gpu()
      • KROKS.to_hf()
    • get_veff()
  • pyscf.pbc.dft.kuks module
    • KUKS
      • KUKS.dump_flags()
      • KUKS.energy_elec()
      • KUKS.get_rho()
      • KUKS.get_veff()
      • KUKS.nuc_grad_method()
      • KUKS.to_gpu()
      • KUKS.to_hf()
    • energy_elec()
    • get_veff()
  • pyscf.pbc.dft.kuks_ksymm module
    • KUKS
    • KsymAdaptedKUKS
      • KsymAdaptedKUKS.dump_chk()
      • KsymAdaptedKUKS.dump_flags()
      • KsymAdaptedKUKS.eig()
      • KsymAdaptedKUKS.energy_elec()
      • KsymAdaptedKUKS.get_hcore()
      • KsymAdaptedKUKS.get_init_guess()
      • KsymAdaptedKUKS.get_jk()
      • KsymAdaptedKUKS.get_occ()
      • KsymAdaptedKUKS.get_orbsym()
      • KsymAdaptedKUKS.get_ovlp()
      • KsymAdaptedKUKS.get_rho()
      • KsymAdaptedKUKS.get_veff()
      • KsymAdaptedKUKS.init_guess_by_chkfile()
      • KsymAdaptedKUKS.kpts
      • KsymAdaptedKUKS.nelec
      • KsymAdaptedKUKS.orbsym
      • KsymAdaptedKUKS.to_hf()
    • get_rho()
    • get_veff()
  • pyscf.pbc.dft.kukspu module
    • KUKSpU
      • KUKSpU.energy_elec()
      • KUKSpU.get_veff()
      • KUKSpU.nuc_grad_method()
      • KUKSpU.to_hf()
    • energy_elec()
    • get_veff()
  • pyscf.pbc.dft.kukspu_ksymm module
    • KUKSpU
    • KsymAdaptedKUKSpU
      • KsymAdaptedKUKSpU.energy_elec()
      • KsymAdaptedKUKSpU.get_veff()
      • KsymAdaptedKUKSpU.to_hf()
  • pyscf.pbc.dft.numint module
    • KNumInt
      • KNumInt.block_loop()
      • KNumInt.cache_xc_kernel()
      • KNumInt.cache_xc_kernel1()
      • KNumInt.eval_ao()
      • KNumInt.eval_rho()
      • KNumInt.eval_rho1()
      • KNumInt.eval_rho2()
      • KNumInt.get_fxc()
      • KNumInt.get_rho()
      • KNumInt.get_vxc()
      • KNumInt.make_mask()
      • KNumInt.nr_fxc()
      • KNumInt.nr_rks()
      • KNumInt.nr_rks_fxc()
      • KNumInt.nr_rks_fxc_st()
      • KNumInt.nr_uks()
      • KNumInt.nr_uks_fxc()
      • KNumInt.nr_vxc()
      • KNumInt.to_gpu()
    • NumInt
      • NumInt.block_loop()
      • NumInt.cache_xc_kernel()
      • NumInt.cache_xc_kernel1()
      • NumInt.cutoff
      • NumInt.eval_ao()
      • NumInt.eval_rho()
      • NumInt.eval_rho1()
      • NumInt.eval_rho2()
      • NumInt.get_fxc()
      • NumInt.get_rho()
      • NumInt.get_vxc()
      • NumInt.make_mask()
      • NumInt.nr_fxc()
      • NumInt.nr_nlc_vxc()
      • NumInt.nr_rks()
      • NumInt.nr_rks_fxc()
      • NumInt.nr_rks_fxc_st()
      • NumInt.nr_uks()
      • NumInt.nr_uks_fxc()
      • NumInt.nr_vxc()
      • NumInt.to_gpu()
    • cache_xc_kernel()
    • cache_xc_kernel1()
    • eval_ao()
    • eval_ao_kpts()
    • eval_rho()
    • eval_rho2()
    • get_rho()
    • nr_nlc_vxc()
    • nr_rks()
    • nr_rks_fxc()
    • nr_rks_fxc_st()
    • nr_rks_vxc()
    • nr_uks()
    • nr_uks_fxc()
    • nr_uks_vxc()
  • pyscf.pbc.dft.numint2c module
    • KNumInt2C
      • KNumInt2C.block_loop()
      • KNumInt2C.cache_xc_kernel()
      • KNumInt2C.cache_xc_kernel1()
      • KNumInt2C.collinear
      • KNumInt2C.collinear_samples
      • KNumInt2C.collinear_thrd
      • KNumInt2C.eval_ao()
      • KNumInt2C.eval_rho()
      • KNumInt2C.eval_rho1()
      • KNumInt2C.eval_rho2()
      • KNumInt2C.eval_xc_eff()
      • KNumInt2C.get_fxc()
      • KNumInt2C.get_rho()
      • KNumInt2C.get_vxc()
      • KNumInt2C.make_mask()
      • KNumInt2C.mcfun_eval_xc_adapter()
      • KNumInt2C.nr_fxc()
      • KNumInt2C.nr_gks_fxc()
      • KNumInt2C.nr_gks_vxc()
      • KNumInt2C.nr_vxc()
      • KNumInt2C.spin_samples
    • NumInt2C
      • NumInt2C.block_loop()
      • NumInt2C.cache_xc_kernel()
      • NumInt2C.cache_xc_kernel1()
      • NumInt2C.collinear
      • NumInt2C.collinear_samples
      • NumInt2C.collinear_thrd
      • NumInt2C.eval_ao()
      • NumInt2C.eval_rho()
      • NumInt2C.eval_rho1()
      • NumInt2C.eval_rho2()
      • NumInt2C.eval_xc_eff()
      • NumInt2C.get_fxc()
      • NumInt2C.get_rho()
      • NumInt2C.get_vxc()
      • NumInt2C.make_mask()
      • NumInt2C.mcfun_eval_xc_adapter()
      • NumInt2C.nr_fxc()
      • NumInt2C.nr_gks_fxc()
      • NumInt2C.nr_gks_vxc()
      • NumInt2C.nr_vxc()
      • NumInt2C.spin_samples
  • pyscf.pbc.dft.rks module
    • KohnShamDFT
      • KohnShamDFT.build()
      • KohnShamDFT.density_fit()
      • KohnShamDFT.dump_flags()
      • KohnShamDFT.get_rho()
      • KohnShamDFT.initialize_grids()
      • KohnShamDFT.jk_method()
      • KohnShamDFT.mix_density_fit()
      • KohnShamDFT.reset()
      • KohnShamDFT.rs_density_fit()
      • KohnShamDFT.small_rho_cutoff
      • KohnShamDFT.to_gks()
      • KohnShamDFT.to_gpu()
      • KohnShamDFT.to_hf()
      • KohnShamDFT.to_rks()
      • KohnShamDFT.to_uks()
    • RKS
      • RKS.dump_flags()
      • RKS.energy_elec()
      • RKS.get_veff()
      • RKS.get_vsap()
      • RKS.init_guess_by_vsap()
      • RKS.to_gpu()
      • RKS.to_hf()
    • get_rho()
    • get_veff()
    • prune_small_rho_grids_()
  • pyscf.pbc.dft.roks module
    • ROKS
      • ROKS.dump_flags()
      • ROKS.energy_elec()
      • ROKS.get_veff()
      • ROKS.get_vsap()
      • ROKS.init_guess_by_vsap()
      • ROKS.to_gpu()
      • ROKS.to_hf()
    • get_veff()
  • pyscf.pbc.dft.uks module
    • UKS
      • UKS.dump_flags()
      • UKS.energy_elec()
      • UKS.get_rho()
      • UKS.get_veff()
      • UKS.get_vsap()
      • UKS.init_guess_by_vsap()
      • UKS.to_gpu()
      • UKS.to_hf()
    • get_veff()
  • Module contents
    • KKS()
    • KRKS()
    • KRKSpU()
    • KS()
    • KUKS()
    • KUKSpU()
    • RKS()
• pyscf.pbc.eph package
  • Submodules
  • pyscf.pbc.eph.eph_fd module
    • copy_mf()
    • gen_cells()
    • get_vmat()
    • kernel()
    • run_hess()
    • run_mfs()
  • Module contents
• pyscf.pbc.geomopt package
  • Submodules
  • pyscf.pbc.geomopt.geometric_solver module
  • Module contents
    • optimize()
• pyscf.pbc.grad package
  • Submodules
  • pyscf.pbc.grad.krhf module
    • Gradients
      • Gradients.as_scanner()
      • Gradients.extra_force()
      • Gradients.get_veff()
      • Gradients.grad_elec()
      • Gradients.kernel()
      • Gradients.make_rdm1e()
    • GradientsBase
      • GradientsBase.get_hcore()
      • GradientsBase.get_j()
      • GradientsBase.get_jk()
      • GradientsBase.get_k()
      • GradientsBase.get_ovlp()
      • GradientsBase.grad_nuc()
      • GradientsBase.hcore_generator()
    • SCF_GradScanner
    • as_scanner()
    • get_hcore()
    • get_j()
    • get_jk()
    • get_k()
    • get_ovlp()
    • get_veff()
    • grad_elec()
    • grad_nuc()
    • hcore_generator()
    • make_rdm1e()
  • pyscf.pbc.grad.krks module
    • Gradients
      • Gradients.dump_flags()
      • Gradients.get_veff()
    • get_veff()
    • get_vxc()
  • pyscf.pbc.grad.kuhf module
    • Gradients
      • Gradients.get_veff()
      • Gradients.grad_elec()
      • Gradients.make_rdm1e()
    • get_veff()
    • grad_elec()
    • make_rdm1e()
  • pyscf.pbc.grad.kuks module
    • Gradients
      • Gradients.get_veff()
    • get_veff()
    • get_vxc()
  • pyscf.pbc.grad.rhf module
    • Gradients
      • Gradients.get_veff()
      • Gradients.grad_elec()
      • Gradients.make_rdm1e()
    • GradientsBase
      • GradientsBase.get_ovlp()
      • GradientsBase.grad_nuc()
    • get_ovlp()
    • get_veff()
    • grad_elec()
    • grad_nuc()
  • pyscf.pbc.grad.rks module
    • Gradients
  • pyscf.pbc.grad.uhf module
    • Gradients
      • Gradients.get_veff()
      • Gradients.grad_elec()
      • Gradients.make_rdm1e()
    • get_veff()
    • grad_elec()
  • pyscf.pbc.grad.uks module
    • Gradients
  • Module contents
• pyscf.pbc.gto package
  • Subpackages
    • pyscf.pbc.gto.basis package
      • Submodules
      • pyscf.pbc.gto.basis.split_BASIS_MOLOPT module
      • pyscf.pbc.gto.basis.split_GTH_BASIS_SETS module
      • pyscf.pbc.gto.basis.split_HFX_BASIS module
      • Module contents
    • pyscf.pbc.gto.pseudo package
      • Submodules
      • pyscf.pbc.gto.pseudo.pp module
      • pyscf.pbc.gto.pseudo.pp_int module
      • pyscf.pbc.gto.pseudo.split_GTH_POTENTIALS module
      • Module contents
  • Submodules
  • pyscf.pbc.gto.cell module
    • C()
    • Cell
      • Cell.Gv
      • Cell.bas_rcut()
      • Cell.build()
      • Cell.build_lattice_symmetry()
      • Cell.cutoff_to_mesh()
      • Cell.drop_exponent
      • Cell.dumps()
      • Cell.energy_nuc()
      • Cell.eval_ao()
      • Cell.eval_gto()
      • Cell.ew_cut
      • Cell.ew_eta
      • Cell.ewald()
      • Cell.exp_to_discard
      • Cell.format_atom()
      • Cell.from_ase()
      • Cell.fromfile()
      • Cell.fromstring()
      • Cell.gen_uniform_grids()
      • Cell.get_Gv()
      • Cell.get_Gv_weights()
      • Cell.get_SI()
      • Cell.get_abs_kpts()
      • Cell.get_bounding_sphere()
      • Cell.get_enuc()
      • Cell.get_ewald_params()
      • Cell.get_kpts()
      • Cell.get_lattice_Ls()
      • Cell.get_nimgs()
      • Cell.get_scaled_atom_coords()
      • Cell.get_scaled_kpts()
      • Cell.get_uniform_grids()
      • Cell.gs
      • Cell.h
      • Cell.kernel()
      • Cell.lattice_vectors()
      • Cell.loads()
      • Cell.loads_()
      • Cell.make_kpts()
      • Cell.mesh
      • Cell.nelec
      • Cell.nimgs
      • Cell.pack()
      • Cell.pbc_eval_ao()
      • Cell.pbc_eval_gto()
      • Cell.pbc_intor()
      • Cell.precision
      • Cell.rcut
      • Cell.rcut_by_shells()
      • Cell.reciprocal_vectors()
      • Cell.symmetrize_mesh()
      • Cell.to_mol()
      • Cell.tofile()
      • Cell.tostring()
      • Cell.tot_electrons()
      • Cell.unpack()
      • Cell.unpack_()
      • Cell.vol
    • M()
    • bas_rcut()
    • conc_cell()
    • dumps()
    • energy_nuc()
    • error_for_ke_cutoff()
    • estimate_ke_cutoff()
    • estimate_rcut()
    • ewald()
    • fromfile()
    • fromstring()
    • gen_uniform_grids()
    • get_Gv()
    • get_Gv_weights()
    • get_SI()
    • get_bounding_sphere()
    • get_ewald_params()
    • get_nimgs()
    • get_uniform_grids()
    • intor_cross()
    • loads()
    • make_kpts()
    • pack()
    • pgf_rcut()
    • rcut_by_shells()
    • tofile()
    • tostring()
    • tot_electrons()
    • unpack()
  • pyscf.pbc.gto.ecp module
    • ecp_int()
  • pyscf.pbc.gto.eval_gto module
    • eval_gto()
    • get_lattice_Ls()
    • pbc_eval_gto()
  • pyscf.pbc.gto.ewald_methods module
    • bspline()
    • ewald_nuc_grad()
    • particle_mesh_ewald()
    • particle_mesh_ewald_nuc_grad()
  • pyscf.pbc.gto.neighborlist module
    • NeighborListOpt
      • NeighborListOpt.build()
      • NeighborListOpt.reset()
    • build_neighbor_list_for_shlpairs()
    • free_neighbor_list()
    • neighbor_list_to_ndarray()
  • Module contents
• pyscf.pbc.gw package
  • Submodules
  • pyscf.pbc.gw.gw_slow module
  • pyscf.pbc.gw.kgw_slow module
  • pyscf.pbc.gw.kgw_slow_supercell module
    • GW
      • GW.base_imds
    • IMDS
      • IMDS.entire_space
      • IMDS.eri_ov()
      • IMDS.get_rhs()
      • IMDS.get_sigma_element()
      • IMDS.initial_guess()
      • IMDS.orb_dims
    • corrected_moe()
  • pyscf.pbc.gw.krgw_ac module
    • AC_pade_thiele_diag()
    • AC_twopole_diag()
    • KRGWAC
      • KRGWAC.ac
      • KRGWAC.dump_flags()
      • KRGWAC.fc
      • KRGWAC.get_frozen_mask()
      • KRGWAC.get_nmo()
      • KRGWAC.get_nocc()
      • KRGWAC.kernel()
      • KRGWAC.linearized
      • KRGWAC.nmo
      • KRGWAC.nocc
    • get_qij()
    • get_rho_response()
    • get_rho_response_head()
    • get_rho_response_wing()
    • get_sigma_diag()
    • kernel()
    • pade_thiele()
    • thiele()
    • two_pole()
    • two_pole_fit()
  • pyscf.pbc.gw.krgw_cd module
    • KRGWCD
      • KRGWCD.dump_flags()
      • KRGWCD.eta
      • KRGWCD.fc
      • KRGWCD.get_frozen_mask()
      • KRGWCD.get_nmo()
      • KRGWCD.get_nocc()
      • KRGWCD.kernel()
      • KRGWCD.linearized
      • KRGWCD.nmo
      • KRGWCD.nocc
    • get_WmnI_diag()
    • get_qij()
    • get_rho_response()
    • get_rho_response_R()
    • get_rho_response_head()
    • get_rho_response_head_R()
    • get_rho_response_wing()
    • get_rho_response_wing_R()
    • get_sigmaI_diag()
    • get_sigmaR_diag()
    • get_sigma_diag()
    • kernel()
  • pyscf.pbc.gw.kugw_ac module
    • AC_pade_thiele_diag()
    • AC_twopole_diag()
    • KUGWAC
      • KUGWAC.ac
      • KUGWAC.dump_flags()
      • KUGWAC.fc
      • KUGWAC.get_frozen_mask()
      • KUGWAC.get_nmo()
      • KUGWAC.get_nocc()
      • KUGWAC.kernel()
      • KUGWAC.linearized
      • KUGWAC.nmo
      • KUGWAC.nocc
    • get_qij()
    • get_rho_response()
    • get_rho_response_head()
    • get_rho_response_wing()
    • get_sigma_diag()
    • kernel()
    • pade_thiele()
    • thiele()
    • two_pole()
    • two_pole_fit()
  • Module contents
    • KGW()
    • KRGW()
    • KUGW()
• pyscf.pbc.lib package
  • Submodules
  • pyscf.pbc.lib.arnoldi module
    • Arnoldi
      • Arnoldi.allocateVecs()
      • Arnoldi.checkConvergence()
      • Arnoldi.checkDeflate()
      • Arnoldi.computeResidual()
      • Arnoldi.constructAllSolV()
      • Arnoldi.constructDeflatedSub()
      • Arnoldi.constructSol()
      • Arnoldi.constructSolAv()
      • Arnoldi.constructSolV()
      • Arnoldi.constructSubspace()
      • Arnoldi.gramSchmidtCurrentVec()
      • Arnoldi.guessInitial()
      • Arnoldi.hMult()
      • Arnoldi.push_Av()
      • Arnoldi.solve()
      • Arnoldi.solveSubspace()
      • Arnoldi.updateVecs()
    • davidson_nosymm()
  • pyscf.pbc.lib.chkfile module
    • load_cell()
  • pyscf.pbc.lib.kpts module
    • KPoints
      • KPoints.addition_table
      • KPoints.build()
      • KPoints.check_mo_occ_symmetry()
      • KPoints.dm_at_ref_cell()
      • KPoints.dump_info()
      • KPoints.get_kconserv()
      • KPoints.get_rotation_mat_for_mos()
      • KPoints.index_to_ktuple()
      • KPoints.inverse_table
      • KPoints.ktuple_to_index()
      • KPoints.little_cogroup_rep()
      • KPoints.little_cogroups()
      • KPoints.loop_ktuples()
      • KPoints.make_gdf_kptij_lst_jk()
      • KPoints.make_k4_ibz()
      • KPoints.make_kpts_ibz()
      • KPoints.make_ktuples_ibz()
      • KPoints.nkpts
      • KPoints.nkpts_ibz
      • KPoints.symmetrize_density()
      • KPoints.symmetrize_wavefunction()
      • KPoints.transform_1e_operator()
      • KPoints.transform_dm()
      • KPoints.transform_fock()
      • KPoints.transform_mo_coeff()
      • KPoints.transform_mo_energy()
      • KPoints.transform_mo_occ()
      • KPoints.transform_single_mo_coeff()
    • KQuartets
      • KQuartets.build()
      • KQuartets.cache_stabilizer()
      • KQuartets.loop_stabilizer()
    • MORotationMatrix
      • MORotationMatrix.build()
    • check_mo_occ_symmetry()
    • dm_at_ref_cell()
    • get_rotation_mat_for_mos()
    • make_k4_ibz()
    • make_kpts()
    • make_kpts_ibz()
    • make_ktuples_ibz()
    • map_k_points_fast()
    • map_kpts_tuples()
    • symmetrize_density()
    • symmetrize_wavefunction()
    • transform_1e_operator()
    • transform_dm()
    • transform_fock()
    • transform_mo_coeff()
    • transform_mo_coeff_k()
    • transform_mo_energy()
    • transform_mo_occ()
    • transform_single_mo_coeff()
  • pyscf.pbc.lib.kpts_helper module
    • KPointSymmetryError
    • KptsHelper
      • KptsHelper.build_symm_map()
      • KptsHelper.transform_symm()
    • VectorComposer
      • VectorComposer.flush()
      • VectorComposer.put()
    • VectorSplitter
      • VectorSplitter.get()
      • VectorSplitter.truncate()
    • check_kpt_antiperm_symmetry()
    • conj_mapping()
    • gamma_point()
    • get_kconserv()
    • get_kconserv3()
    • get_kconserv_ria()
    • group_by_conj_pairs()
    • intersection()
    • is_gamma_point()
    • is_zero()
    • kk_adapted_iter()
    • loop_kkk()
    • member()
    • members_with_wrap_around()
    • round_to_fbz()
    • unique()
    • unique_with_wrap_around()
  • pyscf.pbc.lib.ktensor module
    • KsymmArray
      • KsymmArray.dtype
      • KsymmArray.fromdense()
      • KsymmArray.fromraw()
      • KsymmArray.ndim
      • KsymmArray.shape
      • KsymmArray.subarray_ndim
      • KsymmArray.subarray_order
      • KsymmArray.subarray_shape
      • KsymmArray.todense()
      • KsymmArray.zeros()
    • empty()
    • empty_like()
    • fromdense()
    • fromraw()
    • index_to_coords()
    • set_2d()
    • set_4d()
    • slice_to_coords()
    • transform_2d()
    • transform_4d()
    • zeros()
  • pyscf.pbc.lib.linalg_helper module
    • Arnoldi
      • Arnoldi.allocateVecs()
      • Arnoldi.checkConvergence()
      • Arnoldi.checkDeflate()
      • Arnoldi.computeResidual()
      • Arnoldi.constructAllSolV()
      • Arnoldi.constructDeflatedSub()
      • Arnoldi.constructSol()
      • Arnoldi.constructSolAv()
      • Arnoldi.constructSolV()
      • Arnoldi.constructSubspace()
      • Arnoldi.gramSchmidtCurrentVec()
      • Arnoldi.guessInitial()
      • Arnoldi.hMult()
      • Arnoldi.push_Av()
      • Arnoldi.solve()
      • Arnoldi.solveSubspace()
      • Arnoldi.updateVecs()
    • DavidsonZL
      • DavidsonZL.genMatrix()
      • DavidsonZL.genV0()
      • DavidsonZL.matvecs()
      • DavidsonZL.solve_full()
      • DavidsonZL.solve_iter()
    • davidson()
    • davidson_guess()
    • diagonalize_asymm()
    • eigGeneral()
    • eigs()
    • mgs_ortho()
    • realRepresentation()
    • svd_cut()
  • Module contents
• pyscf.pbc.mp package
  • Submodules
  • pyscf.pbc.mp.kmp2 module
    • KMP2
      • KMP2.dump_flags()
      • KMP2.get_frozen_mask()
      • KMP2.get_nmo()
      • KMP2.get_nocc()
      • KMP2.kernel()
      • KMP2.make_rdm1()
      • KMP2.make_rdm2()
      • KMP2.to_gpu()
    • KRMP2
    • get_frozen_mask()
    • get_nmo()
    • get_nocc()
    • kernel()
    • make_rdm1()
    • make_rdm2()
    • padded_mo_coeff()
    • padded_mo_energy()
    • padding_k_idx()
  • pyscf.pbc.mp.kmp2_ksymm module
    • KMP2
    • KRMP2
    • KsymAdaptedKMP2
      • KsymAdaptedKMP2.kernel()
      • KsymAdaptedKMP2.make_rdm1()
      • KsymAdaptedKMP2.make_rdm2()
    • kernel()
    • kernel_with_t2()
    • make_rdm1()
    • make_t2_for_rdm1()
  • pyscf.pbc.mp.kmp2_stagger module
    • KMP2_stagger
      • KMP2_stagger.dump_flags()
      • KMP2_stagger.kernel()
    • kernel()
  • pyscf.pbc.mp.kump2 module
    • KUMP2
      • KUMP2.get_frozen_mask()
      • KUMP2.get_nmo()
      • KUMP2.get_nocc()
      • KUMP2.kernel()
    • get_frozen_mask()
    • get_nmo()
    • get_nocc()
    • kernel()
    • padded_mo_coeff()
    • padded_mo_energy()
    • padding_k_idx()
  • pyscf.pbc.mp.mp2 module
    • GMP2
      • GMP2.ao2mo()
    • RMP2
      • RMP2.ao2mo()
    • UMP2
      • UMP2.ao2mo()
  • Module contents
    • GMP2()
    • KMP2()
    • KRMP2()
    • MP2()
    • RMP2()
    • UMP2()
• pyscf.pbc.mpicc package
  • Submodules
  • pyscf.pbc.mpicc.kccsd_rhf module
  • pyscf.pbc.mpicc.kintermediates_rhf module
  • pyscf.pbc.mpicc.mpi_kpoint_helper module
    • unique_pqr_list
      • unique_pqr_list.get_irrVec()
      • unique_pqr_list.get_transformation()
      • unique_pqr_list.get_uniqueList()
      • unique_pqr_list.transform_irr2full()
  • Module contents
    • KCCSD()
    • KRCCSD()
• pyscf.pbc.mpitools package
  • Submodules
  • pyscf.pbc.mpitools.mpi module
  • pyscf.pbc.mpitools.mpi_blksize module
  • pyscf.pbc.mpitools.mpi_helper module
  • pyscf.pbc.mpitools.mpi_load_balancer module
  • pyscf.pbc.mpitools.mpi_pool module
  • Module contents
• pyscf.pbc.scf package
  • Submodules
  • pyscf.pbc.scf.addons module
    • canonical_occ()
    • canonical_occ_()
    • convert_to_ghf()
    • convert_to_khf()
    • convert_to_kscf()
    • convert_to_rhf()
    • convert_to_uhf()
    • mo_energy_with_exxdiv_none()
    • project_dm_k2k()
    • project_mo_nr2nr()
    • smearing()
    • smearing_()
  • pyscf.pbc.scf.chkfile module
    • load_scf()
  • pyscf.pbc.scf.cphf module
    • kernel()
    • solve()
    • solve_nos1()
    • solve_withs1()
  • pyscf.pbc.scf.ghf module
    • GHF
      • GHF.CCSD()
      • GHF.MP2()
      • GHF.analyze()
      • GHF.convert_from_()
      • GHF.gen_response()
      • GHF.get_bands()
      • GHF.get_grad()
      • GHF.get_hcore()
      • GHF.get_jk()
      • GHF.get_occ()
      • GHF.get_ovlp()
      • GHF.get_veff()
      • GHF.init_guess_by_atom()
      • GHF.init_guess_by_chkfile()
      • GHF.init_guess_by_huckel()
      • GHF.init_guess_by_minao()
      • GHF.mulliken_meta()
      • GHF.mulliken_pop()
      • GHF.sfx2c1e()
      • GHF.spin_square()
      • GHF.stability()
      • GHF.to_gpu()
      • GHF.to_ks()
      • GHF.x2c()
      • GHF.x2c1e()
    • get_jk()
  • pyscf.pbc.scf.hf module
    • RHF
      • RHF.CCSD()
      • RHF.MP2()
      • RHF.analyze()
      • RHF.convert_from_()
      • RHF.gen_response()
      • RHF.nuc_grad_method()
      • RHF.spin_square()
      • RHF.stability()
      • RHF.to_gpu()
      • RHF.to_ks()
    • SCF
      • SCF.analyze()
      • SCF.build()
      • SCF.check_sanity()
      • SCF.density_fit()
      • SCF.dip_moment()
      • SCF.dump_chk()
      • SCF.dump_flags()
      • SCF.energy_nuc()
      • SCF.from_chk()
      • SCF.get_bands()
      • SCF.get_hcore()
      • SCF.get_init_guess()
      • SCF.get_j()
      • SCF.get_jk()
      • SCF.get_jk_incore()
      • SCF.get_k()
      • SCF.get_ovlp()
      • SCF.get_rho()
      • SCF.get_veff()
      • SCF.init_direct_scf()
      • SCF.init_guess_by_1e()
      • SCF.init_guess_by_chkfile()
      • SCF.jk_method()
      • SCF.kpt
      • SCF.kpts
      • SCF.mix_density_fit()
      • SCF.mol
      • SCF.mulliken_pop()
      • SCF.reset()
      • SCF.rs_density_fit()
      • SCF.sfx2c1e()
      • SCF.to_ghf()
      • SCF.to_gpu()
      • SCF.to_kscf()
      • SCF.to_rhf()
      • SCF.to_uhf()
      • SCF.x2c()
      • SCF.x2c1e()
    • dip_moment()
    • get_bands()
    • get_hcore()
    • get_j()
    • get_jk()
    • get_nuc()
    • get_ovlp()
    • get_rho()
    • get_t()
    • init_guess_by_chkfile()
    • makov_payne_correction()
    • normalize_dm_()
  • pyscf.pbc.scf.kghf module
    • KGHF
      • KGHF.CCSD()
      • KGHF.MP2
      • KGHF.analyze()
      • KGHF.convert_from_()
      • KGHF.gen_response()
      • KGHF.get_bands()
      • KGHF.get_grad()
      • KGHF.get_hcore()
      • KGHF.get_init_guess()
      • KGHF.get_j()
      • KGHF.get_jk()
      • KGHF.get_k()
      • KGHF.get_occ()
      • KGHF.get_ovlp()
      • KGHF.get_veff()
      • KGHF.init_guess_by_atom()
      • KGHF.init_guess_by_chkfile()
      • KGHF.init_guess_by_minao()
      • KGHF.mulliken_meta()
      • KGHF.mulliken_pop()
      • KGHF.to_gpu()
      • KGHF.to_ks()
      • KGHF.x2c()
      • KGHF.x2c1e()
    • get_jk()
    • get_occ()
    • mulliken_meta()
  • pyscf.pbc.scf.kghf_ksymm module
    • KGHF
    • KsymAdaptedKGHF
      • KsymAdaptedKGHF.convert_from_()
      • KsymAdaptedKGHF.eig()
      • KsymAdaptedKGHF.energy_elec()
      • KsymAdaptedKGHF.get_hcore()
      • KsymAdaptedKGHF.get_init_guess()
      • KsymAdaptedKGHF.get_jk()
      • KsymAdaptedKGHF.get_occ()
      • KsymAdaptedKGHF.get_orbsym()
      • KsymAdaptedKGHF.get_ovlp()
      • KsymAdaptedKGHF.init_guess_by_atom()
      • KsymAdaptedKGHF.init_guess_by_chkfile()
      • KsymAdaptedKGHF.init_guess_by_minao()
      • KsymAdaptedKGHF.orbsym
      • KsymAdaptedKGHF.to_ks()
    • eig()
    • get_jk()
    • get_occ()
  • pyscf.pbc.scf.khf module
    • KRHF
      • KRHF.CCSD()
      • KRHF.MP2()
      • KRHF.analyze()
      • KRHF.check_sanity()
      • KRHF.convert_from_()
      • KRHF.gen_response()
      • KRHF.get_init_guess()
      • KRHF.mulliken_meta()
      • KRHF.nuc_grad_method()
      • KRHF.spin_square()
      • KRHF.stability()
      • KRHF.to_gpu()
      • KRHF.to_ks()
    • KSCF
      • KSCF.analyze()
      • KSCF.build()
      • KSCF.canonicalize()
      • KSCF.check_sanity()
      • KSCF.conv_tol_grad
      • KSCF.convert_from_()
      • KSCF.density_fit()
      • KSCF.dip_moment()
      • KSCF.dump_chk()
      • KSCF.dump_flags()
      • KSCF.eig()
      • KSCF.energy_elec()
      • KSCF.energy_nuc()
      • KSCF.from_chk()
      • KSCF.get_bands()
      • KSCF.get_fermi()
      • KSCF.get_fock()
      • KSCF.get_grad()
      • KSCF.get_hcore()
      • KSCF.get_init_guess()
      • KSCF.get_j()
      • KSCF.get_jk()
      • KSCF.get_jk_incore()
      • KSCF.get_k()
      • KSCF.get_occ()
      • KSCF.get_ovlp()
      • KSCF.get_rho()
      • KSCF.get_veff()
      • KSCF.init_direct_scf()
      • KSCF.init_guess_by_1e()
      • KSCF.init_guess_by_atom()
      • KSCF.init_guess_by_chkfile()
      • KSCF.init_guess_by_minao()
      • KSCF.kmesh
      • KSCF.kpts
      • KSCF.make_rdm1()
      • KSCF.make_rdm2()
      • KSCF.mix_density_fit()
      • KSCF.mo_coeff_kpts
      • KSCF.mo_energy_kpts
      • KSCF.mo_occ_kpts
      • KSCF.mol
      • KSCF.mulliken_meta()
      • KSCF.mulliken_pop()
      • KSCF.newton()
      • KSCF.reset()
      • KSCF.rs_density_fit()
      • KSCF.sfx2c1e()
      • KSCF.to_ghf()
      • KSCF.to_khf()
      • KSCF.to_kscf()
      • KSCF.to_rhf()
      • KSCF.to_uhf()
      • KSCF.x2c()
      • KSCF.x2c1e()
    • analyze()
    • canonicalize()
    • dip_moment()
    • energy_elec()
    • get_fermi()
    • get_fock()
    • get_grad()
    • get_hcore()
    • get_j()
    • get_jk()
    • get_occ()
    • get_ovlp()
    • get_rho()
    • init_guess_by_atom()
    • init_guess_by_chkfile()
    • init_guess_by_minao()
    • make_rdm1()
    • mulliken_meta()
  • pyscf.pbc.scf.khf_ksymm module
    • KRHF
    • KsymAdaptedKRHF
      • KsymAdaptedKRHF.MP2()
      • KsymAdaptedKRHF.convert_from_()
      • KsymAdaptedKRHF.get_init_guess()
      • KsymAdaptedKRHF.to_ks()
    • KsymAdaptedKSCF
      • KsymAdaptedKSCF.dump_chk()
      • KsymAdaptedKSCF.dump_flags()
      • KsymAdaptedKSCF.eig()
      • KsymAdaptedKSCF.energy_elec()
      • KsymAdaptedKSCF.get_hcore()
      • KsymAdaptedKSCF.get_jk()
      • KsymAdaptedKSCF.get_occ()
      • KsymAdaptedKSCF.get_orbsym()
      • KsymAdaptedKSCF.get_ovlp()
      • KsymAdaptedKSCF.get_rho()
      • KsymAdaptedKSCF.init_guess_by_chkfile()
      • KsymAdaptedKSCF.kmesh
      • KsymAdaptedKSCF.kpts
      • KsymAdaptedKSCF.orbsym
      • KsymAdaptedKSCF.sfx2c1e()
      • KsymAdaptedKSCF.to_khf()
      • KsymAdaptedKSCF.x2c()
      • KsymAdaptedKSCF.x2c1e()
    • eig()
    • energy_elec()
    • get_occ()
    • get_rho()
    • ksymm_scf_common_init()
  • pyscf.pbc.scf.krohf module
    • KROHF
      • KROHF.CCSD
      • KROHF.MP2
      • KROHF.analyze()
      • KROHF.canonicalize()
      • KROHF.conv_tol_grad
      • KROHF.dump_flags()
      • KROHF.eig()
      • KROHF.energy_elec()
      • KROHF.gen_response()
      • KROHF.get_fock()
      • KROHF.get_grad()
      • KROHF.get_init_guess()
      • KROHF.get_occ()
      • KROHF.get_rho()
      • KROHF.get_veff()
      • KROHF.init_guess_by_atom()
      • KROHF.init_guess_by_chkfile()
      • KROHF.init_guess_by_huckel()
      • KROHF.init_guess_by_minao()
      • KROHF.init_guess_by_mod_huckel()
      • KROHF.make_rdm1()
      • KROHF.mulliken_meta()
      • KROHF.nelec
      • KROHF.spin_square()
      • KROHF.stability()
      • KROHF.to_gpu()
      • KROHF.to_ks()
    • canonicalize()
    • get_fock()
    • get_occ()
    • get_roothaan_fock()
    • make_rdm1()
    • mulliken_meta()
  • pyscf.pbc.scf.kuhf module
    • KUHF
      • KUHF.CCSD()
      • KUHF.MP2()
      • KUHF.analyze()
      • KUHF.canonicalize()
      • KUHF.conv_tol_grad
      • KUHF.convert_from_()
      • KUHF.dip_moment()
      • KUHF.dump_flags()
      • KUHF.eig()
      • KUHF.energy_elec()
      • KUHF.gen_response()
      • KUHF.get_bands()
      • KUHF.get_fermi()
      • KUHF.get_fock()
      • KUHF.get_grad()
      • KUHF.get_init_guess()
      • KUHF.get_occ()
      • KUHF.get_rho()
      • KUHF.get_veff()
      • KUHF.init_guess_breaksym
      • KUHF.init_guess_by_1e()
      • KUHF.init_guess_by_atom()
      • KUHF.init_guess_by_chkfile()
      • KUHF.init_guess_by_huckel()
      • KUHF.init_guess_by_minao()
      • KUHF.init_guess_by_mod_huckel()
      • KUHF.make_rdm1()
      • KUHF.mulliken_meta()
      • KUHF.mulliken_meta_spin()
      • KUHF.mulliken_pop()
      • KUHF.nelec
      • KUHF.nuc_grad_method()
      • KUHF.spin_square()
      • KUHF.stability()
      • KUHF.to_gpu()
      • KUHF.to_ks()
    • canonicalize()
    • dip_moment()
    • energy_elec()
    • get_fermi()
    • get_fock()
    • get_occ()
    • init_guess_by_chkfile()
    • make_rdm1()
    • mulliken_meta()
    • mulliken_meta_spin()
  • pyscf.pbc.scf.kuhf_ksymm module
    • KUHF
    • KsymAdaptedKUHF
      • KsymAdaptedKUHF.convert_from_()
      • KsymAdaptedKUHF.dump_flags()
      • KsymAdaptedKUHF.eig()
      • KsymAdaptedKUHF.energy_elec()
      • KsymAdaptedKUHF.get_init_guess()
      • KsymAdaptedKUHF.get_occ()
      • KsymAdaptedKUHF.get_orbsym()
      • KsymAdaptedKUHF.get_rho()
      • KsymAdaptedKUHF.nelec
      • KsymAdaptedKUHF.orbsym
      • KsymAdaptedKUHF.to_ks()
    • energy_elec()
    • get_occ()
  • pyscf.pbc.scf.newton_ah module
    • gen_g_hop_rhf()
    • gen_g_hop_rohf()
    • gen_g_hop_uhf()
    • newton()
  • pyscf.pbc.scf.rohf module
    • ROHF
      • ROHF.CCSD
      • ROHF.MP2
      • ROHF.analyze()
      • ROHF.canonicalize()
      • ROHF.dip_moment()
      • ROHF.dump_flags()
      • ROHF.eig()
      • ROHF.energy_elec()
      • ROHF.gen_response()
      • ROHF.get_bands()
      • ROHF.get_fock()
      • ROHF.get_grad()
      • ROHF.get_init_guess()
      • ROHF.get_occ()
      • ROHF.get_rho()
      • ROHF.get_veff()
      • ROHF.init_guess_by_1e()
      • ROHF.init_guess_by_atom()
      • ROHF.init_guess_by_chkfile()
      • ROHF.init_guess_by_huckel()
      • ROHF.init_guess_by_minao()
      • ROHF.init_guess_by_mod_huckel()
      • ROHF.make_rdm1()
      • ROHF.nelec
      • ROHF.spin_square()
      • ROHF.stability()
      • ROHF.to_gpu()
      • ROHF.to_ks()
  • pyscf.pbc.scf.rsjk module
    • RangeSeparatedJKBuilder
      • RangeSeparatedJKBuilder.build()
      • RangeSeparatedJKBuilder.dump_flags()
      • RangeSeparatedJKBuilder.get_jk()
      • RangeSeparatedJKBuilder.has_long_range()
      • RangeSeparatedJKBuilder.qindex
      • RangeSeparatedJKBuilder.reset()
      • RangeSeparatedJKBuilder.to_gpu()
      • RangeSeparatedJKBuilder.weighted_coulG()
      • RangeSeparatedJKBuilder.weighted_coulG_LR()
      • RangeSeparatedJKBuilder.weighted_coulG_SR()
    • RangeSeparationJKBuilder
    • estimate_ke_cutoff_for_omega()
    • estimate_omega_for_ke_cutoff()
    • estimate_rcut()
  • pyscf.pbc.scf.scfint module
    • get_hcore()
    • get_int1e()
    • get_int1e_cross()
    • get_ovlp()
    • get_t()
  • pyscf.pbc.scf.stability module
    • rhf_external()
    • rhf_internal()
    • rhf_stability()
    • uhf_external()
    • uhf_internal()
    • uhf_stability()
  • pyscf.pbc.scf.uhf module
    • UHF
      • UHF.CCSD()
      • UHF.MP2()
      • UHF.analyze()
      • UHF.canonicalize()
      • UHF.convert_from_()
      • UHF.dip_moment()
      • UHF.dump_flags()
      • UHF.eig()
      • UHF.energy_elec()
      • UHF.gen_response()
      • UHF.get_bands()
      • UHF.get_fock()
      • UHF.get_grad()
      • UHF.get_init_guess()
      • UHF.get_occ()
      • UHF.get_rho()
      • UHF.get_veff()
      • UHF.init_guess_breaksym
      • UHF.init_guess_by_1e()
      • UHF.init_guess_by_atom()
      • UHF.init_guess_by_chkfile()
      • UHF.init_guess_by_huckel()
      • UHF.init_guess_by_minao()
      • UHF.init_guess_by_mod_huckel()
      • UHF.make_rdm1()
      • UHF.make_rdm2()
      • UHF.mulliken_meta()
      • UHF.mulliken_meta_spin()
      • UHF.mulliken_pop()
      • UHF.nelec
      • UHF.spin_square()
      • UHF.stability()
      • UHF.to_gpu()
      • UHF.to_ks()
    • dip_moment()
    • init_guess_by_chkfile()
  • Module contents
    • HF()
    • KGHF()
    • KHF()
    • KKS()
    • KRHF()
    • KRKS()
    • KROKS()
    • KS()
    • KUHF()
    • KUKS()
    • RHF()
    • RKS()
    • ROKS()
    • UKS()
• pyscf.pbc.symm package
  • Submodules
  • pyscf.pbc.symm.basis module
    • symm_adapted_basis()
  • pyscf.pbc.symm.geom module
    • get_crystal_class()
    • search_point_group_ops()
    • search_space_group_ops()
  • pyscf.pbc.symm.group module
    • FiniteGroup
      • FiniteGroup.character_table()
      • FiniteGroup.conjugacy_classes()
      • FiniteGroup.conjugacy_mask
      • FiniteGroup.conjugacy_table
      • FiniteGroup.elements_from_hash()
      • FiniteGroup.get_elements_map()
      • FiniteGroup.get_irrep_chi()
      • FiniteGroup.hash_table
      • FiniteGroup.inverse_table
      • FiniteGroup.issubset()
      • FiniteGroup.multiplication_table
      • FiniteGroup.order
      • FiniteGroup.project_chi()
    • GroupElement
      • GroupElement.inv()
    • PGElement
      • PGElement.decrypt_hash()
      • PGElement.inv()
      • PGElement.matrix
      • PGElement.rot
    • PointGroup
      • PointGroup.elements_from_hash()
      • PointGroup.group_index
      • PointGroup.group_name()
    • Representation
      • Representation.chi
      • Representation.chi_to_rep()
      • Representation.rep
      • Representation.rep_to_chi()
  • pyscf.pbc.symm.pyscf_spglib module
  • pyscf.pbc.symm.space_group module
    • SPGElement
      • SPGElement.a2b()
      • SPGElement.a2r()
      • SPGElement.b2a()
      • SPGElement.b2r()
      • SPGElement.dot()
      • SPGElement.dot_rot()
      • SPGElement.inv()
      • SPGElement.is_eye
      • SPGElement.is_inversion
      • SPGElement.r2a()
      • SPGElement.r2b()
      • SPGElement.rot_is_eye
      • SPGElement.rot_is_inversion
      • SPGElement.trans_is_zero
      • SPGElement.transform()
    • SpaceGroup
      • SpaceGroup.build()
      • SpaceGroup.dump_info()
    • transform_rot()
    • transform_trans()
  • pyscf.pbc.symm.symmetry module
    • Symmetry
      • Symmetry.build()
      • Symmetry.check_mesh_symmetry()
      • Symmetry.dump_info()
    • check_mesh_symmetry()
    • get_Dmat()
    • get_Dmat_cart()
    • is_eye()
    • is_inversion()
    • make_Dmats()
    • make_rot_loc()
    • transform_1e_operator()
    • transform_dm()
    • transform_mo_coeff()
  • pyscf.pbc.symm.tables module
  • Module contents
• pyscf.pbc.tddft package
  • Module contents
• pyscf.pbc.tdscf package
  • Submodules
  • pyscf.pbc.tdscf.krhf module
    • CIS
    • KTDA
    • KTDBase
      • KTDBase.check_sanity()
      • KTDBase.conv_tol
      • KTDBase.dump_flags()
      • KTDBase.get_nto()
    • KTDHF
    • RPA
    • TDA
      • TDA.gen_vind()
      • TDA.get_ab()
      • TDA.init_guess()
      • TDA.kernel()
    • TDHF
      • TDHF.gen_vind()
      • TDHF.get_ab()
      • TDHF.get_precond()
      • TDHF.init_guess()
      • TDHF.kernel()
    • get_ab()
  • pyscf.pbc.tdscf.krks module
    • KTDA
    • KTDDFT
    • RPA
    • TDA
      • TDA.kernel()
    • TDDFT
      • TDDFT.kernel()
  • pyscf.pbc.tdscf.kuhf module
    • CIS
    • KTDA
    • KTDHF
    • RPA
    • TDA
      • TDA.gen_vind()
      • TDA.get_ab()
      • TDA.init_guess()
      • TDA.kernel()
    • TDHF
      • TDHF.gen_vind()
      • TDHF.get_ab()
      • TDHF.get_precond()
      • TDHF.init_guess()
      • TDHF.kernel()
    • get_ab()
  • pyscf.pbc.tdscf.kuks module
    • KTDA
    • KTDDFT
    • RPA
    • TDA
      • TDA.kernel()
    • TDDFT
      • TDDFT.kernel()
  • pyscf.pbc.tdscf.rhf module
    • CIS
    • RPA
    • TDA
      • TDA.gen_vind()
      • TDA.init_guess()
      • TDA.kernel()
    • TDBase
      • TDBase.analyze()
      • TDBase.get_ab()
      • TDBase.get_nto()
      • TDBase.nuc_grad_method()
      • TDBase.oscillator_strength()
      • TDBase.transition_dipole()
      • TDBase.transition_magnetic_dipole()
      • TDBase.transition_magnetic_quadrupole()
      • TDBase.transition_octupole()
      • TDBase.transition_quadrupole()
      • TDBase.transition_velocity_dipole()
      • TDBase.transition_velocity_octupole()
      • TDBase.transition_velocity_quadrupole()
    • TDHF
      • TDHF.gen_vind()
      • TDHF.init_guess()
      • TDHF.kernel()
    • TDRHF
    • get_ab()
  • pyscf.pbc.tdscf.rks module
    • CasidaTDDFT
      • CasidaTDDFT.gen_vind()
      • CasidaTDDFT.init_guess()
      • CasidaTDDFT.kernel()
    • TDDFTNoHybrid
    • tddft()
  • pyscf.pbc.tdscf.uhf module
    • CIS
    • RPA
    • TDA
      • TDA.gen_vind()
      • TDA.get_ab()
      • TDA.init_guess()
      • TDA.kernel()
      • TDA.singlet
    • TDHF
      • TDHF.gen_vind()
      • TDHF.get_ab()
      • TDHF.init_guess()
      • TDHF.kernel()
      • TDHF.singlet
    • TDUHF
    • get_ab()
  • pyscf.pbc.tdscf.uks module
    • CasidaTDDFT
      • CasidaTDDFT.gen_vind()
      • CasidaTDDFT.init_guess()
      • CasidaTDDFT.kernel()
    • TDDFTNoHybrid
    • tddft()
  • Module contents
    • KTD()
    • KTDA()
    • KTDDFT()
    • KTDHF()
    • TDA()
    • TDDFT()
    • TDHF()
• pyscf.pbc.tools package
  • Submodules
  • pyscf.pbc.tools.k2gamma module
    • double_translation_indices()
    • get_phase()
    • k2gamma()
    • kpts_to_kmesh()
    • mo_k2gamma()
    • to_supercell_ao_integrals()
    • to_supercell_mo_integrals()
    • translation_map()
    • translation_vectors_for_kmesh()
  • pyscf.pbc.tools.lattice module
    • get_ase_alkali_halide()
    • get_ase_atom()
    • get_ase_diamond_cubic()
    • get_ase_diamond_primitive()
    • get_ase_graphene()
    • get_ase_graphene_xxx()
    • get_ase_rocksalt()
    • get_ase_wurtzite()
    • get_ase_zincblende()
    • get_bandpath_fcc()
  • pyscf.pbc.tools.make_test_cell module
    • make_cell()
    • test_cell_cu_metallic()
    • test_cell_n0()
    • test_cell_n1()
    • test_cell_n2()
    • test_cell_n3()
    • test_cell_n3_diffuse()
  • pyscf.pbc.tools.pbc module
    • cell_plus_imgs()
    • cutoff_to_gs()
    • cutoff_to_mesh()
    • fft()
    • fftk()
    • get_coulG()
    • get_lattice_Ls()
    • get_monkhorst_pack_size()
    • gs_to_cutoff()
    • ifft()
    • ifftk()
    • madelung()
    • mesh_to_cutoff()
    • precompute_exx()
    • round_to_cell0()
    • super_cell()
  • pyscf.pbc.tools.print_funcs module
    • print_mo_energy_occ()
    • print_mo_energy_occ_kpts()
  • pyscf.pbc.tools.pyscf_ase module
  • pyscf.pbc.tools.pywannier90 module
  • pyscf.pbc.tools.tril module
    • tril_index()
    • unpack_tril()
  • Module contents
• pyscf.pbc.x2c package
  • Submodules
  • pyscf.pbc.x2c.sfx2c1e module
    • PBCX2CHelper
      • PBCX2CHelper.approx
      • PBCX2CHelper.basis
      • PBCX2CHelper.exp_drop
      • PBCX2CHelper.reset()
      • PBCX2CHelper.xuncontract
    • SFX2C1E_SCF
      • SFX2C1E_SCF.get_hcore()
    • SpinFreeX2CHelper
      • SpinFreeX2CHelper.dump_flags()
      • SpinFreeX2CHelper.get_hcore()
      • SpinFreeX2CHelper.get_xmat()
    • get_pnucp()
    • sfx2c()
    • sfx2c1e()
  • pyscf.pbc.x2c.x2c1e module
    • SpinOrbitalX2C1EHelper
      • SpinOrbitalX2C1EHelper.dump_flags()
      • SpinOrbitalX2C1EHelper.get_hcore()
    • X2C1E_GSCF
      • X2C1E_GSCF.get_hcore()
    • get_1c_pvxp()
    • get_pbc_pvxp()
    • x2c1e_gscf()
  • Module contents

Module contents