def __init__(self, mol_list, spectratype, temperature, freq_reg, m_max, eta, icompress_config=None, ievolve_config=None, insteps=None, method='1site', procedure_cv=None, dump_dir: str = None, job_name=None, cores=1): super().__init__(mol_list, spectratype, freq_reg, m_max, eta, method, procedure_cv, cores) self.temperature = temperature self.evolve_config = ievolve_config self.compress_config = icompress_config if self.evolve_config is None: self.evolve_config = \ EvolveConfig() if self.compress_config is None: self.compress_config = \ CompressConfig(CompressCriteria.fixed, max_bonddim=m_max) self.compress_config.set_bonddim(len(mol_list.pbond_list)) self.insteps = insteps self.job_name = job_name self.dump_dir = dump_dir
def __init__( self, model, spectratype, m_max, eta, temperature, h_mpo=None, method='1site', procedure_cv=None, rtol=1e-5, b_mps=None, cv_mps=None, icompress_config=None, ievolve_config=None, insteps=None, dump_dir: str = None, job_name=None, ): self.temperature = temperature self.evolve_config = ievolve_config self.compress_config = icompress_config if self.evolve_config is None: self.evolve_config = \ EvolveConfig() if self.compress_config is None: self.compress_config = \ CompressConfig(CompressCriteria.fixed, max_bonddim=m_max) self.compress_config.set_bonddim(len(model.pbond_list)) self.insteps = insteps self.job_name = job_name self.dump_dir = dump_dir super().__init__( model, spectratype, m_max, eta, h_mpo=h_mpo, method=method, procedure_cv=procedure_cv, rtol=rtol, b_mps=b_mps, cv_mps=cv_mps, ) self.cv_mpo = self.cv_mps self.b_mpo = self.b_mps self.a_oper = None
def __init__( self, mol_list: MolList, temperature=Quantity(0, "K"), compress_config=None, evolve_config=None, stop_at_edge=True, init_electron=InitElectron.relaxed, rdm=False, dissipation=0 ): self.mol_list: MolList = mol_list self.temperature = temperature self.mpo = None self.init_electron = init_electron self.dissipation = dissipation if compress_config is None: self.compress_config: CompressConfig = CompressConfig() else: self.compress_config: CompressConfig = compress_config super(ChargeTransport, self).__init__(evolve_config) assert self.mpo is not None self.energies = [self.tdmps_list[0].expectation(self.mpo)] self.reduced_density_matrices = [] if rdm: self.reduced_density_matrices.append( self.tdmps_list[0].calc_reduced_density_matrix() ) self.elocalex_arrays = [] self.j_arrays = [] self.custom_dump_info = OrderedDict() self.stop_at_edge = stop_at_edge
def __init__(self): # XXX: when modify theses codes, keep in mind to update `metacopy` method # set to a list of None upon metacopy self._mp: List[Union[Matrix, None]] = [] self.dtype = backend.real_dtype # in mpo.quasi_boson, mol_list is not set, then _ephtable and _pbond_list should be used self.mol_list: MolList = None self._ephtable: EphTable = None self._pbond_list: List[int] = None # mpo also need to be compressed sometimes self.compress_config: CompressConfig = CompressConfig() # QN related self.use_dummy_qn: bool = False # self.use_dummy_qn = True self.qn: List[List[int]] = [] self.qnidx: int = None self._qntot: int = None # sweeping from left? self.left: bool = None # compress after add? self.compress_add: bool = False
def test_pyr_4mode(multi_e, translator): order, basis, vibronic_model = construct_vibronic_model(multi_e) if translator is ModelTranslator.vibronic_model: model = vibronic_model elif translator is ModelTranslator.general_model: model = vibronic_to_general(vibronic_model) else: assert False mol_list2 = MolList2(order, basis, model, model_translator=translator) mpo = Mpo(mol_list2) logger.info(f"mpo_bond_dims:{mpo.bond_dims}") mps = Mps.hartree_product_state(mol_list2, condition={"e_1": 1}) # for multi-e case the `expand bond dimension` routine is currently not working # because creation operator is not defined yet mps.use_dummy_qn = True mps.build_empty_qn() compress_config = CompressConfig(CompressCriteria.fixed, max_bonddim=10) evolve_config = EvolveConfig(EvolveMethod.tdvp_ps) job = VibronicModelDynamics(mol_list2, mps0=mps, h_mpo=mpo, compress_config=compress_config, evolve_config=evolve_config) time_step_fs = 2 job.evolve(evolve_dt=time_step_fs * fs2au, nsteps=59) from renormalizer.vibronic.tests.mctdh_data import mctdh_data assert np.allclose(mctdh_data[::round(time_step_fs / 0.5)][:, 1:], job.e_occupations_array, atol=5e-2)
def __init__(self, mol_list, temperature: Quantity, insteps: int = None, ievolve_config=None, compress_config=None, evolve_config=None, dump_dir: str = None, job_name: str = None): self.mol_list = mol_list self.h_mpo = Mpo(mol_list) self.j_oper = self._construct_flux_operator() self.temperature = temperature # imaginary time evolution config if ievolve_config is None: self.ievolve_config = EvolveConfig() if insteps is None: self.ievolve_config.adaptive = True # start from a small step self.ievolve_config.evolve_dt = temperature.to_beta() / 1e5j self.ievolve_config.d_energy = 1 else: self.ievolve_config = ievolve_config self.insteps = insteps if compress_config is None: logger.debug("using default compress config") self.compress_config = CompressConfig() else: self.compress_config = compress_config self.impdm = None super().__init__(evolve_config, dump_dir, job_name)
def test_pyr_4mode(multi_e, dvr): basis, ham_terms = construct_vibronic_model(multi_e, dvr) model = Model(basis, ham_terms) mpo = Mpo(model) logger.info(f"mpo_bond_dims:{mpo.bond_dims}") # same form whether multi_e is True or False init_condition = {"s2": 1} if dvr: for dof in model.v_dofs: idx = model.order[dof] init_condition[dof] = basis[idx].dvr_v[0] mps = Mps.hartree_product_state(model, condition=init_condition) compress_config = CompressConfig(CompressCriteria.fixed, max_bonddim=10) evolve_config = EvolveConfig(EvolveMethod.tdvp_ps) job = VibronicModelDynamics(model, mps0=mps, h_mpo=mpo, compress_config=compress_config, evolve_config=evolve_config, expand=True) time_step_fs = 2 job.evolve(evolve_dt=time_step_fs * fs2au, nsteps=60) from renormalizer.vibronic.tests.mctdh_data import mctdh_data assert np.allclose(mctdh_data[::round(time_step_fs / 0.5)][:61, 1:], job.e_occupations_array, atol=2e-2)
def __init__(self, model: Model, temperature: Quantity, distance_matrix: np.ndarray = None, insteps: int=1, ievolve_config=None, compress_config=None, evolve_config=None, dump_dir: str=None, job_name: str=None, properties: Property = None): self.model = model self.distance_matrix = distance_matrix self.h_mpo = Mpo(model) logger.info(f"Bond dim of h_mpo: {self.h_mpo.bond_dims}") self._construct_current_operator() if temperature == 0: raise ValueError("Can't set temperature to 0.") self.temperature = temperature # imaginary time evolution config if ievolve_config is None: self.ievolve_config = EvolveConfig() if insteps is None: self.ievolve_config.adaptive = True # start from a small step self.ievolve_config.guess_dt = temperature.to_beta() / 1e5j insteps = 1 else: self.ievolve_config = ievolve_config self.insteps = insteps if compress_config is None: logger.debug("using default compress config") self.compress_config = CompressConfig() else: self.compress_config = compress_config self.properties = properties self._auto_corr = [] self._auto_corr_deomposition = [] super().__init__(evolve_config=evolve_config, dump_dir=dump_dir, job_name=job_name)
def __init__( self, mol_list, spectratype, temperature, insteps, offset, evolve_config=None, icompress_config=None, ievolve_config=None, gs_shift=0, dump_dir: str = None, job_name=None, ): self.temperature = temperature self.insteps = insteps self.gs_shift = gs_shift self.icompress_config = icompress_config self.ievolve_config = ievolve_config if self.icompress_config is None: self.icompress_config = CompressConfig() if self.ievolve_config is None: self.ievolve_config = EvolveConfig() self.dump_dir = dump_dir self.job_name = job_name super(SpectraFiniteT, self).__init__(mol_list, spectratype, temperature, evolve_config=evolve_config, offset=offset, dump_dir=dump_dir, job_name=job_name)
def test_FT_dynamics_hybrid_TDDMRG_TDH(n_dmrg_phs, scheme): mol_list = parameter_PBI.construct_mol(4, n_dmrg_phs, 10 - n_dmrg_phs).switch_scheme(scheme) mpdm = MpDm.max_entangled_gs(mol_list) tentative_mpo = Mpo(mol_list) temperature = Quantity(2000, "K") tp = ThermalProp(mpdm, tentative_mpo, exact=True, space="GS") tp.evolve(None, 1, temperature.to_beta() / 2j) mpdm = ( Mpo.onsite(mol_list, r"a^\dagger", mol_idx_set={0}).apply(tp.latest_mps).normalize(1.0) ) mpdm.compress_config = CompressConfig(threshold=5e-4) offset = mpdm.expectation(tentative_mpo) mpo = Mpo(mol_list, offset=Quantity(offset, "a.u.")) # do the evolution # nsteps = 90 # too many steps, may take hours to finish nsteps = 40 dt = 10.0 occ = [mpdm.e_occupations] for i in range(nsteps): mpdm = mpdm.evolve(mpo, dt) occ.append(mpdm.e_occupations) # make it compatible with std data occ = np.array(occ[:nsteps]).transpose() with open(os.path.join(cur_dir, "FT_occ" + str(n_dmrg_phs) + ".npy"), "rb") as f: std = np.load(f) assert np.allclose(occ[:, :nsteps], std[:, :nsteps], atol=1e-3, rtol=1e-3)
def test_autocorr(scheme, mollist2): ph = Phonon.simple_phonon(Quantity(1), Quantity(1), 2) mol = Mol(Quantity(0), [ph]) mol_list1 = MolList([mol] * 5, Quantity(1), scheme) if mollist2: mol_list = MolList2.MolList_to_MolList2(mol_list1) else: mol_list = mol_list1 temperature = Quantity(50000, 'K') compress_config = CompressConfig(CompressCriteria.fixed, max_bonddim=24) evolve_config = EvolveConfig(EvolveMethod.tdvp_ps, adaptive=True, guess_dt=0.5, adaptive_rtol=1e-3) ievolve_config = EvolveConfig(EvolveMethod.tdvp_ps, adaptive=True, guess_dt=-0.1j) ac = TransportAutoCorr(mol_list, temperature, compress_config=compress_config, ievolve_config=ievolve_config, evolve_config=evolve_config) ac.evolve(nsteps=5, evolve_time=5) corr_real = ac.auto_corr.real exact_real = get_exact_autocorr(mol_list1, temperature, ac.evolve_times_array).real atol = 1e-2 # direct comparison may fail because of different sign assert np.allclose(corr_real, exact_real, atol=atol) or np.allclose( corr_real, -exact_real, atol=atol)
def test_dynamics(dissipation, dt, nsteps): tentative_mpo = Mpo(band_limit_mol_list) gs_mp = MpDm.max_entangled_gs(band_limit_mol_list) # subtract the energy otherwise might cause numeric error because of large offset * dbeta energy = Quantity(gs_mp.expectation(tentative_mpo)) mpo = Mpo(band_limit_mol_list, offset=energy) tp = ThermalProp(gs_mp, mpo, exact=True, space="GS") tp.evolve(None, 50, low_t.to_beta() / 2j) gs_mp = tp.latest_mps center_mol_idx = band_limit_mol_list.mol_num // 2 creation_operator = Mpo.onsite( band_limit_mol_list, r"a^\dagger", mol_idx_set={center_mol_idx} ) mpdm = creation_operator.apply(gs_mp) mpdm_full = MpDmFull.from_mpdm(mpdm) # As more compression is involved higher threshold is necessary mpdm_full.compress_config = CompressConfig(threshold=1e-4) liouville = SuperLiouville(mpo, dissipation) r_square_list = [calc_r_square(mpdm_full.e_occupations)] time_series = [0] for i in range(nsteps - 1): logger.info(mpdm_full) mpdm_full = mpdm_full.evolve(liouville, dt) r_square_list.append(calc_r_square(mpdm_full.e_occupations)) time_series.append(time_series[-1] + dt) time_series = np.array(time_series) if dissipation == 0: assert np.allclose(get_analytical_r_square(time_series), r_square_list, rtol=1e-2, atol=1e-3) else: # not much we can do, just basic sanity check assert (np.array(r_square_list)[1:] < get_analytical_r_square(time_series)[1:]).all()
def test_dump(method, dt): mps = init_mps.copy() mps.evolve_config = EvolveConfig(method) # dump all matrices mps.compress_config = CompressConfig(CompressCriteria.fixed, dump_matrix_size=1) evolved_mps = check_result(mps, mpo, dt, 5) # check all matrices are actually dumped for mt in evolved_mps._mp: assert isinstance(mt, str)
def test_gaussian_bond_dim(): compress_config = CompressConfig( criteria=CompressCriteria.fixed, bonddim_distri=BondDimDistri.center_gauss, max_bonddim=10, ) evolve_config = EvolveConfig(guess_dt=0.1, adaptive=True) ct = ChargeTransport( band_limit_mol_list, compress_config=compress_config, evolve_config=evolve_config, ) ct.stop_at_edge = True ct.evolve(evolve_dt=2.) assert_band_limit(ct, 1e-2)
def test_ft_emi(model): with open(os.path.join(cur_dir, "emi_ft.npy"), "rb") as fin: standard_value = np.load(fin) # the standard value is plotted over np.arange(-0.11, -0.05, 5.e-4) freq_reg = np.arange(-0.11, -0.05, 5.e-4).tolist() test_freq = [freq_reg[52]] T = Quantity(298, unit='K') standard_value = [standard_value[52]] evolve_config = EvolveConfig(method=EvolveMethod.tdvp_ps) compress_config = CompressConfig(criteria=CompressCriteria.fixed, max_bonddim=10) spectra = SpectraFtCV(model, "emi", 10, 5.e-3, T, ievolve_config=evolve_config, icompress_config=compress_config, insteps=10, rtol=1e-3) result = batch_run(test_freq, 1, spectra) assert np.allclose(result, standard_value, rtol=1.e-2)
def compare(): dt_list = [0.01, 0.02, 0.05, 0.1, 0.2, 0.4] method_list = [EvolveMethod.prop_and_compress, EvolveMethod.tdvp_mu_vmf, EvolveMethod.tdvp_mu_cmf, EvolveMethod.tdvp_ps] all_values = [] for method in method_list: values = [] for dt in dt_list: mps = init_mps.copy() mps.compress_config = CompressConfig(CompressCriteria.fixed) mps.evolve_config = EvolveConfig(method) mps.evolve_config._adjust_bond_dim_counter = True mps.evolve_config.force_ovlp = True values.append(check_result(mps, mpo, dt, 2)) print(values) all_values.append(values) print(mps.bond_dims) print(all_values)
def test_autocorr(insteps, atol): ph = Phonon.simple_phonon(Quantity(1), Quantity(1), 2) mol = Mol(Quantity(0), [ph]) mol_list = MolList([mol] * 5, Quantity(1), 3) temperature = Quantity(50000, 'K') compress_config = CompressConfig(threshold=1e-3) ac = TransportAutoCorr(mol_list, temperature, insteps, compress_config=compress_config) ac.evolve(0.2, 50) corr_real = ac.auto_corr.real exact_real = get_exact_autocorr(mol_list, temperature, ac.evolve_times_array).real # direct comparison may fail because of different sign assert np.allclose(corr_real, exact_real, atol=atol) or np.allclose( corr_real, -exact_real, atol=atol)
def test_sbm_zt(alpha): raw_delta = Quantity(1) raw_omega_c = Quantity(20) n_phonons = 3 mol_list = param2mollist(alpha, raw_delta, raw_omega_c, 5, n_phonons) compress_config = CompressConfig(threshold=1e-4) evolve_config = EvolveConfig(adaptive=True, evolve_dt=0.1) sbm = SpinBosonModel(mol_list, Quantity(0), compress_config=compress_config, evolve_config=evolve_config) sbm.evolve(evolve_time=20) spin1 = sbm.sigma_z spin2 = get_exact_zt(mol_list[0], sbm.evolve_times) assert np.allclose(spin1, spin2, atol=1e-3)
def __init__( self, mol_list, temperature: Quantity, j_oper: Mpo = None, insteps: int = 1, ievolve_config=None, compress_config=None, evolve_config=None, dump_dir: str = None, job_name: str = None, properties: Property = None, ): self.mol_list = mol_list self.h_mpo = Mpo(mol_list) logger.info(f"Bond dim of h_mpo: {self.h_mpo.bond_dims}") if j_oper is None: self.j_oper = self._construct_flux_operator() else: self.j_oper = j_oper self.temperature = temperature # imaginary time evolution config if ievolve_config is None: self.ievolve_config = EvolveConfig() if insteps is None: self.ievolve_config.adaptive = True # start from a small step self.ievolve_config.guess_dt = temperature.to_beta() / 1e5j insteps = 1 else: self.ievolve_config = ievolve_config self.insteps = insteps if compress_config is None: logger.debug("using default compress config") self.compress_config = CompressConfig() else: self.compress_config = compress_config self.properties = properties self._auto_corr = [] super().__init__(evolve_config=evolve_config, dump_dir=dump_dir, job_name=job_name)
def test_zt(): mol = get_mol() mol_list = MolList([mol], Quantity(0)) mps = Mps.gs(mol_list, False) mps.compress_config = CompressConfig(threshold=1e-6) mps.evolve_config = EvolveConfig(adaptive=True, guess_dt=0.1) mps.use_dummy_qn = True mpo = Mpo(mol_list) time_series = [0] spin = [1] for i in range(30): dt = mps.evolve_config.guess_dt mps = mps.evolve(mpo, evolve_dt=dt) time_series.append(time_series[-1] + dt) spin.append(1 - 2 * mps.e_occupations[0]) exact = get_exact_zt(mol, time_series) assert np.allclose(exact, spin, atol=1e-3)
def test_zt(): model = get_model() mps = Mps.ground_state(model, False) mps.compress_config = CompressConfig(threshold=1e-6) mps.evolve_config = EvolveConfig(adaptive=True, guess_dt=0.1) mps.use_dummy_qn = True mpo = Mpo(model) time_series = [0] spin = [1] sigma_z_oper = Mpo(model, Op("sigma_z", "spin")) for i in range(30): dt = mps.evolve_config.guess_dt mps = mps.evolve(mpo, evolve_dt=dt) time_series.append(time_series[-1] + dt) spin.append(mps.expectation(sigma_z_oper)) qutip_res = get_qutip_zt(model, time_series) assert np.allclose(qutip_res, spin, atol=1e-3)
def __init__( self, mol_list: MolList, temperature: Quantity = Quantity(0, "K"), compress_config: CompressConfig = None, evolve_config: EvolveConfig = None, stop_at_edge: bool = True, init_electron=InitElectron.relaxed, rdm: bool = False, dissipation: float = 0, dump_dir: str = None, job_name: str = None, ): self.mol_list: MolList = mol_list self.temperature = temperature self.mpo = None self.init_electron = init_electron self.dissipation = dissipation if compress_config is None: self.compress_config: CompressConfig = CompressConfig() else: self.compress_config: CompressConfig = compress_config self.energies = [] self.r_square_array = [] self.e_occupations_array = [] self.ph_occupations_array = [] self.reduced_density_matrices = [] if rdm else None self.k_occupations_array = [] # von Neumann entropy between e and ph self.eph_vn_entropy_array = [] # entropy at each bond self.bond_vn_entropy_array = [] self.coherent_length_array = [] super(ChargeTransport, self).__init__(evolve_config=evolve_config, dump_dir=dump_dir, job_name=job_name) assert self.mpo is not None self.elocalex_arrays = [] self.j_arrays = [] self.custom_dump_info = OrderedDict() self.stop_at_edge = stop_at_edge
def test_2site(): ph = Phonon.simple_phonon(Quantity(1), Quantity(1), 2) m = Mol(Quantity(0), [ph]) mol_list = MolList([m] * 2, Quantity(1), scheme=3) gs_mp = Mpo.onsite(mol_list, opera=r"a^\dagger", mol_idx_set={0}).apply(Mps.gs(mol_list, max_entangled=False)) mpdm = MpDm.from_mps(gs_mp) mpdm_full = MpDmFull.from_mpdm(mpdm) mpdm_full.compress_config = CompressConfig(threshold=1e-4) liouville = SuperLiouville(Mpo(mol_list), dissipation=1) ph_occupations_array = [] energies = [] for i in range(51): logger.info(mpdm_full) logger.info(mpdm_full.ph_occupations) ph_occupations_array.append(mpdm_full.ph_occupations) logger.info(mpdm_full.expectation(liouville)) energies.append(mpdm_full.expectation(liouville)) mpdm_full = mpdm_full.evolve(liouville, 0.4) ph_occupations_array = np.array(ph_occupations_array) assert energies[-1] == pytest.approx(-0.340162, rel=1e-2) assert np.allclose(ph_occupations_array[-1], [0.0930588, 0.099115], rtol=1e-2)
def __init__(self): # XXX: when modify theses codes, keep in mind to update `metacopy` method # set to a list of None upon metacopy. String is used when the matrix is # stored in disks self._mp: List[Union[Matrix, None, str]] = [] self.dtype = backend.real_dtype self.model: Model = None # mpo also need to be compressed sometimes self.compress_config: CompressConfig = CompressConfig() # QN related self.qn: List[List[int]] = [] self.qnidx: int = None self.qntot: int = None # if sweeping to right: True else False self.to_right: bool = None # compress after add? self.compress_add: bool = False
def __init__(self, mol_list: MolList, temperature: Quantity, compress_config=None, evolve_config=None, dump_dir=None, job_name=None): self.mol_list = mol_list self.h_mpo = Mpo(mol_list) self.temperature = temperature if compress_config is None: self.compress_config = CompressConfig() else: self.compress_config = compress_config self.sigma_x = [] self.sigma_z = [] super().__init__(evolve_config=evolve_config, dump_dir=dump_dir, job_name=job_name)
def __init__( self, model: Model, compress_config: CompressConfig = None, evolve_config: EvolveConfig = None, h_mpo = None, mps0 = None, properties: Property = None, init_condition = None, dump_mps: bool = False, dump_dir: str = None, job_name: str = None, expand: bool = False ): self.model = model if compress_config is None: self.compress_config = CompressConfig() else: self.compress_config = compress_config if h_mpo is None: self.h_mpo = Mpo(model) else: self.h_mpo = h_mpo self.mps0 = mps0 self.init_condition = init_condition self.properties = properties self.expand = expand self.e_occupations_array = [] self.autocorr_array = [] self.energies = [] self.autocorr_time = [] super().__init__(evolve_config=evolve_config, dump_mps=dump_mps, dump_dir=dump_dir, job_name=job_name)
def test_ft(): model = get_model() mpo = Mpo(model) impdm = MpDm.max_entangled_gs(model) impdm.compress_config = CompressConfig(threshold=1e-6) temperature = Quantity(3) evolve_config = EvolveConfig(adaptive=True, guess_dt=-0.001j) tp = ThermalProp(impdm, mpo, evolve_config=evolve_config) tp.evolve(nsteps=1, evolve_time=temperature.to_beta() / 2j) mpdm = tp.latest_mps mpdm = Mpo(model, Op("sigma_x", "spin")).contract(mpdm) mpdm.evolve_config = EvolveConfig(adaptive=True, guess_dt=0.1) time_series = [0] sigma_z_oper = Mpo(model, Op("sigma_z", "spin")) spin = [mpdm.expectation(sigma_z_oper)] for i in range(29): dt = mpdm.evolve_config.guess_dt mpdm = mpdm.evolve(mpo, evolve_dt=dt) time_series.append(time_series[-1] + dt) spin.append(mpdm.expectation(sigma_z_oper)) qutip_res = get_qutip_ft(model, temperature, time_series) assert np.allclose(qutip_res, spin, atol=1e-3)
def test_holstein_kubo(scheme): ph = Phonon.simple_phonon(Quantity(1), Quantity(1), 2) mol = Mol(Quantity(0), [ph]) model = HolsteinModel([mol] * 5, Quantity(1), scheme) temperature = Quantity(50000, 'K') compress_config = CompressConfig(CompressCriteria.fixed, max_bonddim=24) evolve_config = EvolveConfig(EvolveMethod.tdvp_ps, adaptive=True, guess_dt=0.5, adaptive_rtol=1e-3) ievolve_config = EvolveConfig(EvolveMethod.tdvp_ps, adaptive=True, guess_dt=-0.1j) kubo = TransportKubo(model, temperature, compress_config=compress_config, ievolve_config=ievolve_config, evolve_config=evolve_config) kubo.evolve(nsteps=5, evolve_time=5) qutip_res = get_qutip_holstein_kubo(model, temperature, kubo.evolve_times_array) rtol = 5e-2 assert np.allclose(kubo.auto_corr, qutip_res, rtol=rtol)
def test_ft(): mol = get_mol() mol_list = MolList([mol], Quantity(0)) mpo = Mpo(mol_list) impdm = MpDm.max_entangled_gs(mol_list) impdm.compress_config = CompressConfig(threshold=1e-6) impdm.use_dummy_qn = True temperature = Quantity(3) evolve_config = EvolveConfig(adaptive=True, guess_dt=-0.001j) tp = ThermalProp(impdm, mpo, evolve_config=evolve_config) tp.evolve(nsteps=1, evolve_time=temperature.to_beta() / 2j) mpdm = tp.latest_mps mpdm = Mpo.onsite(mol_list, r"sigma_x").contract(mpdm) mpdm.evolve_config = EvolveConfig(adaptive=True, guess_dt=0.1) time_series = [0] spin = [1 - 2 * mpdm.e_occupations[0]] for i in range(30): dt = mpdm.evolve_config.guess_dt mpdm = mpdm.evolve(mpo, evolve_dt=dt) time_series.append(time_series[-1] + dt) spin.append(1 - 2 * mpdm.e_occupations[0]) exact = get_exact_ft(mol, temperature, time_series) assert np.allclose(exact, spin, atol=1e-3)
lams = hr_factors * omegas_au phonons = [ Phonon.simplest_phonon(Quantity(o), Quantity(l), lam=True) for o, l in zip(omegas_au, lams) ] j_matrix_au = j_matrix_cm * cm2au mlist = [] for j in np.diag(j_matrix_au): m = Mol(Quantity(j), phonons) mlist.append(m) # starts from 1 mol_arangement = np.array([7, 5, 3, 1, 2, 4, 6]) - 1 mol_list = MolList(list(np.array(mlist)[mol_arangement]), j_matrix_au[mol_arangement][:, mol_arangement]) evolve_dt = 40 evolve_config = EvolveConfig(evolve_dt=evolve_dt) compress_config = CompressConfig(CompressCriteria.fixed, max_bonddim=16) ct = ChargeTransport(mol_list, evolve_config=evolve_config, compress_config=compress_config) ct.dump_dir = "./fmo" ct.job_name = 'hybrid' ct.stop_at_edge = False ct.evolve(evolve_dt=evolve_dt, nsteps=10) new_evolve_config = EvolveConfig(EvolveMethod.tdvp_mctdh_new) ct.latest_mps.evolve_config = ct.evolve_config = new_evolve_config ct.evolve(evolve_dt=evolve_dt, nsteps=100000)