def test_rotation_dipolar(self): theta = np.pi / 3 # Build two-atom system system_one_tmp = pi.SystemOne(self.system_one) system_one_tmp.setBfield([0, 0, 1]) system_one_tmp.diagonalize() system_two = pi.SystemTwo(system_one_tmp, system_one_tmp, self.cache) system_two.restrictEnergy(self.state_two.getEnergy() - 2, self.state_two.getEnergy() + 2) system_two.setConservedParityUnderPermutation(pi.ODD) system_two.setDistance(6) system_two.setAngle(theta) system_two.diagonalize() eigenvalues1 = system_two.getHamiltonian().diagonal() overlaps1 = system_two.getOverlap(self.state_two) system_one_tmp = pi.SystemOne(self.system_one) system_one_tmp.setBfield([0, 0, 1], 0, theta, 0) system_one_tmp.diagonalize() system_two = pi.SystemTwo(system_one_tmp, system_one_tmp, self.cache) system_two.restrictEnergy(self.state_two.getEnergy() - 2, self.state_two.getEnergy() + 2) system_two.setConservedParityUnderPermutation(pi.ODD) system_two.setDistance(6) system_two.diagonalize() eigenvalues2 = system_two.getHamiltonian().diagonal() overlaps2 = system_two.getOverlap(self.state_two, 0, theta, 0) system_two.rotate(0, -theta, 0) overlaps3 = system_two.getOverlap(self.state_two) # Check that everything is the same np.testing.assert_allclose(eigenvalues1, eigenvalues2, rtol=1e-6) np.testing.assert_allclose(overlaps1, overlaps2, rtol=1e-4, atol=1e-6) np.testing.assert_allclose(overlaps1, overlaps3, rtol=1e-4, atol=1e-6)
def test_diagonalization_full(self): # Setup states state_one = pi.StateOne("Cs", 60, 0, 0.5, 0.5) # Build one-atom system system_one = pi.SystemOne(state_one.getSpecies(), self.cache) system_one.restrictEnergy(state_one.getEnergy() - 30, state_one.getEnergy() + 30) system_one.restrictN(state_one.getN() - 1, state_one.getN() + 1) system_one.restrictL(state_one.getL() - 1, state_one.getL() + 1) system_one.setEfield([1, 0, 0]) system_one.setBfield([5, 50, 0]) # Diagonalize using the standard approach system_one_standard = pi.SystemOne(system_one) system_one_standard.diagonalize() evecs_standard = system_one_standard.getBasisvectors() # Diagonalize using FEAST system_one.diagonalize(-1e12, 1e12) evecs_feast = system_one.getBasisvectors() # Check results overlap = np.abs(np.dot(evecs_standard.conj().T, evecs_feast))**2 np.testing.assert_allclose(overlap.diagonal(), np.ones_like(overlap.diagonal()), rtol=1e-12) self.assertAlmostEqual(np.sum(overlap), system_one.getNumBasisvectors(), places=6)
def setUp(self): # Set up rotation angles self.alpha = 2.67 self.beta = 1.32 self.gamma = 0.83 # Get geometric interpretation of the rotation angles # The coordinate system is rotated by R_z(alpha)*R_y(beta)*R_z(gamma) where e.g. R_z is the elementary rotation # R_z(alpha) = [[cos(alpha), -sin(alpha), 0], [sin(alpha), cos(alpha), 0], [0,0,1]]. In the following, we calculate # the coordinate representations of the rotated z-axis and y-axis in the unrotated system. s, c = np.sin(self.gamma), np.cos(self.gamma) self.rotator = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]]) s, c = np.sin(self.beta), np.cos(self.beta) self.rotator = np.dot(np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]]), self.rotator) s, c = np.sin(self.alpha), np.cos(self.alpha) self.rotator = np.dot(np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]]), self.rotator) self.to_z_axis = np.dot(self.rotator, [0, 0, 1]) self.to_y_axis = np.dot(self.rotator, [0, 1, 0]) # Set up cache self.cache = pi.MatrixElementCache() # Setup states self.state_one = pi.StateOne("Rb", 61, 2, 1.5, 1.5) self.state_two = pi.StateTwo(self.state_one, self.state_one) # Build one-atom system self.system_one = pi.SystemOne(self.state_one.getSpecies(), self.cache) self.system_one.restrictEnergy(self.state_one.getEnergy() - 30, self.state_one.getEnergy() + 30) self.system_one.restrictN(self.state_one.getN() - 1, self.state_one.getN() + 1) self.system_one.restrictL(self.state_one.getL() - 1, self.state_one.getL() + 1)
def test_basisvectors(self): one_atom_basisvectors_indices = [[0, 0], [0, 1], [1, 0], [1, 1]] # Setup states state_one = pi.StateOne("Cs", 60, 0, 0.5, 0.5) # One-atom system system_one = pi.SystemOne(state_one.getSpecies(), self.cache) system_one.restrictEnergy(state_one.getEnergy() - 30, state_one.getEnergy() + 30) system_one.restrictN(state_one.getN() - 1, state_one.getN() + 1) system_one.restrictL(state_one.getL() - 1, state_one.getL() + 1) system_one.setEfield([5, 0, 0]) system_one.diagonalize() basisvectors_one = system_one.getBasisvectors().toarray() assert basisvectors_one.shape[0] == basisvectors_one.shape[1] # Two-atom system system_two = pi.SystemTwo(system_one, system_one, self.cache) system_two.setMinimalNorm(0) system_two.setOneAtomBasisvectors(one_atom_basisvectors_indices) basisvectors_two = system_two.getBasisvectors().toarray() assert basisvectors_two.shape[0] == (basisvectors_one.shape[0])**2 assert basisvectors_two.shape[1] == len(one_atom_basisvectors_indices) # Check results for n, [a, b] in enumerate(one_atom_basisvectors_indices): np.testing.assert_allclose( np.outer(basisvectors_one[:, a], basisvectors_one[:, b]).ravel(), basisvectors_two[:, n])
def test_permutation(self): ####################################################### ### Check permutation symmetry of two atom systems #### ####################################################### # Remark: calling restrictEnergy() would cause a small # deviation # TODO figure out exact reason (in case of # symmetrized basis states, the atom-atom interaction would # add energy to the diagonal) # Define states state_one = pi.StateOne("Rb", 61, 1, 0.5, 0.5) state_two = pi.StateTwo(state_one, state_one) # Build one atom system system_one = pi.SystemOne(state_one.element, self.path_cache) system_one.restrictEnergy(state_one.energy-20, state_one.energy+20) system_one.restrictN(state_one.n-1, state_one.n+1) system_one.restrictL(state_one.l-1, state_one.l+1) system_one.restrictJ(state_one.j-1, state_one.j+1) system_one.setBfield([100, 200, 300]) system_one.setEfield([1, 2, 3]) # Build two atom system system_two = pi.SystemTwo(system_one, system_one, self.path_cache) #system_two.restrictEnergy(state_two.energy-2, state_two.energy+2) # TODO system_two.setDistance(1) system_two.setOrder(3) # Diagonalize blockwise system_two_even = pi.SystemTwo(system_two) system_two_even.setConservedParityUnderPermutation(pi.EVEN) system_two_even.diagonalize() system_two_odd = pi.SystemTwo(system_two) system_two_odd.setConservedParityUnderPermutation(pi.ODD) system_two_odd.diagonalize() system_two_combined = system_two_even system_two_combined.add(system_two_odd) # Diagonalize altogether system_two.setConservedParityUnderPermutation(pi.NA) system_two.diagonalize() # Compare results w1 = np.sort(system_two_combined.diagonal) w2 = np.sort(system_two.diagonal) maxdiff = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff = np.max(maxdiff) print("Two-atom system with permutation symmetry, relative maximum deviation: ", maxdiff) self.assertAlmostEqual(maxdiff, 0, places=9)
def test_rotation_hamiltonian(self): # Hamiltonian (in canonical basis) and overlaps after rotating the system with/without atom-field interactions system_one_tmp = pi.SystemOne(self.system_one) system_one_tmp.setEfield([0.2, 0, 0.3]) system_one_tmp.setBfield([0, 1, 0]) system_one_tmp.rotate(self.alpha, self.beta, self.gamma) hamiltonian1 = system_one_tmp.getHamiltonian().todense() system_one_tmp.diagonalize() overlaps1 = system_one_tmp.getOverlap(pi.StateOne("Rb", 61, 2, 1.5, 1.5)) system_one_tmp = pi.SystemOne(self.system_one) # is of no importance for the overlaps, but for the hamiltonians system_one_tmp.rotate(self.alpha, self.beta, self.gamma) system_one_tmp.setEfield(np.dot(self.rotator.T, [0.2, 0, 0.3])) system_one_tmp.setBfield(np.dot(self.rotator.T, [0, 1, 0])) hamiltonian2 = system_one_tmp.getHamiltonian().todense() system_one_tmp.diagonalize() overlaps2 = system_one_tmp.getOverlap(pi.StateOne("Rb", 61, 2, 1.5, 1.5)) system_one_tmp = pi.SystemOne(self.system_one) # is of no importance for the overlaps, but for the hamiltonians system_one_tmp.rotate(self.alpha, self.beta, self.gamma) system_one_tmp.setEfield([0.2, 0, 0.3], self.alpha, self.beta, self.gamma) system_one_tmp.setBfield([0, 1, 0], self.alpha, self.beta, self.gamma) hamiltonian3 = system_one_tmp.getHamiltonian().todense() system_one_tmp.diagonalize() overlaps3 = system_one_tmp.getOverlap(pi.StateOne("Rb", 61, 2, 1.5, 1.5)) system_one_tmp = pi.SystemOne(self.system_one) system_one_tmp.setEfield([0.2, 0, 0.3]) system_one_tmp.setBfield([0, 1, 0]) system_one_tmp.diagonalize() overlaps4 = system_one_tmp.getOverlap(pi.StateOne("Rb", 61, 2, 1.5, 1.5), -self.gamma, -self.beta, -self.alpha) # Check that everything is the same np.testing.assert_allclose(overlaps1, overlaps2, rtol=1e-4, atol=1e-6) np.testing.assert_allclose(overlaps1, overlaps3, rtol=1e-4, atol=1e-6) np.testing.assert_allclose(overlaps1, overlaps4, rtol=1e-4, atol=1e-6) np.testing.assert_allclose(hamiltonian1, hamiltonian2, rtol=1e-4, atol=1e-6) np.testing.assert_allclose(hamiltonian1, hamiltonian3, rtol=1e-4, atol=1e-6)
def test_rotation_derotate(self): # Add interaction to the Hamiltonian and diagonalize it system_one_interacting = pi.SystemOne(self.system_one) system_one_interacting.setEfield([0, 0, 0.1]) system_one_interacting.setBfield([0, 1, 0]) system_one_interacting.diagonalize() # Original eigen pairs eigenvectors1 = system_one_interacting.getBasisvectors() eigenvalues1 = system_one_interacting.getHamiltonian().diagonal() # Eigen pairs after rotating and derotating system_one_tmp = pi.SystemOne(system_one_interacting) system_one_tmp.rotate(self.alpha, self.beta, self.gamma) system_one_tmp.rotate(-self.gamma, -self.beta, -self.alpha) eigenvectors2 = system_one_tmp.getBasisvectors() eigenvalues2 = system_one_tmp.getHamiltonian().diagonal() # Check that everything is the same np.testing.assert_allclose(eigenvalues1, eigenvalues2, rtol=1e-6) np.testing.assert_allclose(eigenvectors1.A, eigenvectors2.A, rtol=1e-6)
def test_rotation_phase(self): angle = 0.84 # Phase due to rotation phases1 = self.system_one.getBasisvectors().todense() system_one_tmp = pi.SystemOne(self.system_one) system_one_tmp.rotate(angle, 0, 0) phases2 = system_one_tmp.getBasisvectors().todense() # Check diagonality np.testing.assert_allclose(phases1, np.diag(np.diag(phases1)), rtol=1e-4, atol=1e-6) np.testing.assert_allclose(phases2, np.diag(np.diag(phases2)), rtol=1e-4, atol=1e-6) # Check absolute value np.testing.assert_allclose(np.abs(phases1), np.abs(phases2), rtol=1e-4, atol=1e-6) # Check phases array_M = (np.angle(np.diag(phases2)) - np.angle(np.diag(phases1))) / angle for state, M in zip(system_one_tmp.getStates(), array_M): self.assertAlmostEqual(state.getM(), M)
def test_exception(self): one_atom_basisvectors_indices = [[0, 0], [0, 0]] # Setup states state_one = pi.StateOne("Cs", 60, 0, 0.5, 0.5) # One-atom system system_one = pi.SystemOne(state_one.getSpecies(), self.cache) system_one.restrictEnergy(state_one.getEnergy() - 30, state_one.getEnergy() + 30) system_one.restrictN(state_one.getN() - 1, state_one.getN() + 1) system_one.restrictL(state_one.getL() - 1, state_one.getL() + 1) system_one.setEfield([5, 0, 0]) system_one.diagonalize() basisvectors_one = system_one.getBasisvectors().toarray() # Two-atom system system_two = pi.SystemTwo(system_one, system_one, self.cache) system_two.setMinimalNorm(0) with self.assertRaises(RuntimeError) as context: system_two.setOneAtomBasisvectors(one_atom_basisvectors_indices) self.assertTrue('not unique' in str(context.exception))
def test_diagonalization_bounded(self): # Setup states state_one = pi.StateOne("Cs", 60, 0, 0.5, 0.5) # Build one-atom system system_one = pi.SystemOne(state_one.getSpecies(), self.cache) system_one.restrictEnergy(state_one.getEnergy() - 100, state_one.getEnergy() + 100) system_one.restrictN(state_one.getN() - 1, state_one.getN() + 1) system_one.restrictL(state_one.getL() - 1, state_one.getL() + 1) system_one.restrictM(state_one.getM(), state_one.getM()) system_one.setEfield([0, 0, 1]) system_one.setBfield([0, 0, 50]) # Determine energy bounds energy_lower_bound = state_one.getEnergy() - 20 energy_upper_bound = state_one.getEnergy() + 20 # Diagonalize using FEAST system_one.diagonalize(energy_lower_bound, energy_upper_bound, 0.01) # Check results self.assertEqual(system_one.getNumStates(), 9) self.assertEqual(system_one.getNumBasisvectors(), 4)
def test_rotation_overlap(self): states_to_calculate_overlap_with = [ pi.StateOne("Rb", 61, 2, pi.ARB, 1.5), pi.StateOne("Rb", 60, 2, 1.5, 1.5) ] # Add interaction to the Hamiltonian and diagonalize it system_one_interacting = pi.SystemOne(self.system_one) system_one_interacting.setEfield([0, 0, 0.1]) system_one_interacting.setBfield([0, 1, 0]) system_one_interacting.diagonalize() # Overlap with rotated system system_one_tmp = pi.SystemOne(system_one_interacting) system_one_tmp.rotate(self.to_z_axis, self.to_y_axis) overlap_rotated_system1 = system_one_tmp.getOverlap(states_to_calculate_overlap_with) system_one_tmp = pi.SystemOne(system_one_interacting) system_one_tmp.rotate(self.alpha, self.beta, self.gamma) overlap_rotated_system2 = system_one_tmp.getOverlap(states_to_calculate_overlap_with) system_one_tmp = pi.SystemOne(system_one_interacting) # gamma can be arbitrary, it just leads to a phase system_one_tmp.rotate(self.alpha, self.beta, self.gamma + 0.8342) overlap_rotated_system3 = system_one_tmp.getOverlap(states_to_calculate_overlap_with) # Overlap with rotated states system_one_tmp = pi.SystemOne(system_one_interacting) overlap_rotated_states1 = system_one_tmp.getOverlap( states_to_calculate_overlap_with, -self.gamma, -self.beta, -self.alpha) system_one_tmp = pi.SystemOne(system_one_interacting) overlap_rotated_states2 = system_one_tmp.getOverlap( states_to_calculate_overlap_with, -self.gamma + 0.8342, -self.beta, -self.alpha) # Check that everything is the same np.testing.assert_allclose(overlap_rotated_system1, overlap_rotated_system2, rtol=1e-6) np.testing.assert_allclose(overlap_rotated_system1, overlap_rotated_system3, rtol=1e-6) np.testing.assert_allclose(overlap_rotated_system1, overlap_rotated_states1, rtol=1e-6) np.testing.assert_allclose(overlap_rotated_system1, overlap_rotated_states2, rtol=1e-6)
def test_combined(self): ####################################################### ### Check combined binary symmetries ################## ####################################################### # Remark: calling restrictEnergy() would cause a small # deviation # TODO figure out exact reason (in case of # symmetrized basis states, the atom-atom interaction would # add energy to the diagonal) # Define states state_one = pi.StateOne("Rb", 61, 1, 0.5, 0.5) state_two = pi.StateTwo(state_one, state_one) # Build one atom system system_one = pi.SystemOne(state_one.element, self.path_cache) system_one.restrictEnergy(state_one.energy-20, state_one.energy+20) system_one.restrictN(state_one.n-1, state_one.n+1) system_one.restrictL(state_one.l-1, state_one.l+1) system_one.restrictJ(state_one.j-1, state_one.j+1) system_one.setBfield([0, 100, 0]) system_one_combined = pi.SystemOne(system_one) system_one_combined.setConservedParityUnderReflection(pi.EVEN) system_one_combined.diagonalize() system_one_inverse = pi.SystemOne(system_one) system_one_inverse.setConservedParityUnderReflection(pi.ODD) system_one_inverse.diagonalize() system_one_combined.add(system_one_inverse) system_one.setConservedParityUnderReflection(pi.NA) system_one.diagonalize() # Build two atom system system_two = pi.SystemTwo(system_one, system_one, self.path_cache) system_two.setDistance(1) system_two.setOrder(3) system_two.diagonalize() # Note: it is important to use system_one_combined system_two_from_combined = pi.SystemTwo(system_one_combined, system_one_combined, self.path_cache) system_two_from_combined.setDistance(1) system_two_from_combined.setOrder(3) system_two_combined = None for sym_reflection, sym_inversion, sym_permutation in product([pi.EVEN, pi.ODD], [pi.EVEN, pi.ODD], [pi.EVEN, pi.ODD]): system_two_tmp = pi.SystemTwo(system_two_from_combined) system_two_tmp.setConservedParityUnderReflection(sym_reflection) system_two_tmp.setConservedParityUnderInversion(sym_inversion) system_two_tmp.setConservedParityUnderPermutation(sym_permutation) system_two_tmp.diagonalize() if system_two_combined is None: system_two_combined = system_two_tmp else: system_two_combined.add(system_two_tmp) system_two_combined.diagonalize() # Compare results w1 = np.sort(system_two_combined.diagonal) w2 = np.sort(system_two.diagonal) maxdiff = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff = np.max(maxdiff) print("Two-atom system with combined binary symmetries, relative maximum deviation: ", maxdiff) self.assertAlmostEqual(maxdiff, 0, places=9)
def test_rotation(self): ####################################################### ### Check rotation symmetry of one atom systems ####### ####################################################### # Define state state_one = pi.StateOne("Rb", 61, 1, 0.5, 0.5) # Build one atom system system_one = pi.SystemOne(state_one.element, self.path_cache) system_one.restrictEnergy(state_one.energy-40, state_one.energy+40) system_one.restrictN(state_one.n-1, state_one.n+1) system_one.restrictL(state_one.l-1, state_one.l+1) system_one.restrictJ(state_one.j-1, state_one.j+1) system_one.setBfield([0, 0, 100]) system_one.setEfield([0, 0, 1]) momenta_one = np.arange(-(state_one.j+1), (state_one.j+1)+1) # Diagonalize blockwise system_one_momentum = {} for m in momenta_one: system_one_momentum[m] = pi.SystemOne(system_one) system_one_momentum[m].setConservedMomentaUnderRotation([m]) system_one_momentum[m].diagonalize() system_one_combined = pi.SystemOne(system_one_momentum[momenta_one[0]]) for m in momenta_one[1:]: system_one_combined.add(system_one_momentum[m]) # Diagonalize altogether system_one_alternative = pi.SystemOne(system_one) system_one_alternative.setConservedMomentaUnderRotation(momenta_one) system_one_alternative.diagonalize() system_one.setConservedMomentaUnderRotation([pi.ARB]) system_one.diagonalize() # Compare results w1 = np.sort(system_one_combined.diagonal) w2 = np.sort(system_one.diagonal) w3 = np.sort(system_one_alternative.diagonal) maxdiff12 = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff23 = np.abs((w3-w2)/(np.max([w3,w2],axis=0))) maxdiff12[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff23[np.abs(w3-w2)<1e-14] = np.abs(w3-w2)[np.abs(w3-w2)<1e-14] maxdiff12 = np.max(maxdiff12) maxdiff23 = np.max(maxdiff23) print("One-atom system with rotation symmetry, relative maximum deviation: ", maxdiff12, " (between alternatives: ", maxdiff23,")") self.assertAlmostEqual(maxdiff12, 0, places=9) self.assertAlmostEqual(maxdiff23, 0, places=9) ####################################################### ### Check rotation symmetry of two atom systems ####### ####################################################### # Define state state_two = pi.StateTwo(state_one, state_one) # Diagonalize blockwise system_two_momentum = {} for m1 in momenta_one: for m2 in momenta_one: if m1+m2 in system_two_momentum: tmp = pi.SystemTwo(system_one_momentum[m1], system_one_momentum[m2]) tmp.restrictEnergy(state_two.energy-2, state_two.energy+2) system_two_momentum[m1+m2].add(tmp) else: system_two_momentum[m1+m2] = pi.SystemTwo(system_one_momentum[m1], system_one_momentum[m2]) system_two_momentum[m1+m2].restrictEnergy(state_two.energy-2, state_two.energy+2) momenta_two = list(system_two_momentum.keys()) for m in momenta_two: system_two_momentum[m].setDistance(1) system_two_momentum[m].setOrder(5) system_two_momentum[m].diagonalize() system_two_combined = pi.SystemTwo(system_two_momentum[momenta_two[0]]) for m in momenta_two[1:]: system_two_combined.add(system_two_momentum[m]) # Diagonalize blockwise, alternative system_two_momentum_alternative = {} for m in momenta_two: system_two_momentum_alternative[m] = pi.SystemTwo(system_one, system_one) system_two_momentum_alternative[m].restrictEnergy(state_two.energy-2, state_two.energy+2) system_two_momentum_alternative[m].setConservedMomentaUnderRotation([int(m)]) system_two_momentum_alternative[m].setDistance(1) system_two_momentum_alternative[m].setOrder(5) system_two_momentum_alternative[m].diagonalize() system_two_combined_alternative = pi.SystemTwo(system_two_momentum_alternative[momenta_two[0]]) for m in momenta_two[1:]: system_two_combined_alternative.add(system_two_momentum_alternative[m]) # Diagonalize altogether system_two = pi.SystemTwo(system_one, system_one, self.path_cache) system_two.restrictEnergy(state_two.energy-2, state_two.energy+2) system_two.setDistance(1) system_two.setOrder(5) system_two.diagonalize() # Compare results w1 = np.sort(system_two_combined.diagonal) w2 = np.sort(system_two.diagonal) w3 = np.sort(system_two_combined_alternative.diagonal) maxdiff12 = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff23 = np.abs((w3-w2)/(np.max([w3,w2],axis=0))) maxdiff12[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff23[np.abs(w3-w2)<1e-14] = np.abs(w3-w2)[np.abs(w3-w2)<1e-14] maxdiff12 = np.max(maxdiff12) maxdiff23 = np.max(maxdiff23) print("Two-atom system with rotation symmetry, relative maximum deviation: ", maxdiff12, " (between alternatives: ", maxdiff23,")") self.assertAlmostEqual(maxdiff12, 0, places=9) self.assertAlmostEqual(maxdiff23, 0, places=9)
def test_reflection(self): ####################################################### ### Check reflection symmetry of one atom systems ##### ####################################################### # Define state state_one = pi.StateOne("Rb", 61, 1, 0.5, 0.5) # Build one atom system system_one = pi.SystemOne(state_one.element, self.path_cache) system_one.restrictEnergy(state_one.energy-20, state_one.energy+20) system_one.restrictN(state_one.n-1, state_one.n+1) system_one.restrictL(state_one.l-1, state_one.l+1) system_one.restrictJ(state_one.j-1, state_one.j+1) system_one.setBfield([0, 100, 0]) system_one.setEfield([1, 0, 2]) # Diagonalize blockwise system_one_even = pi.SystemOne(system_one) system_one_even.setConservedParityUnderReflection(pi.EVEN) system_one_even.diagonalize() system_one_odd = pi.SystemOne(system_one) system_one_odd.setConservedParityUnderReflection(pi.ODD) system_one_odd.diagonalize() system_one_combined = pi.SystemOne(system_one_even) system_one_combined.add(system_one_odd) # Diagonalize altogether system_one.setConservedParityUnderReflection(pi.NA) system_one.diagonalize() # Compare results w1 = np.sort(system_one_combined.diagonal) w2 = np.sort(system_one.diagonal) maxdiff = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff = np.max(maxdiff) print("One-atom system with reflection symmetry, relative maximum deviation: ", maxdiff) self.assertAlmostEqual(maxdiff, 0, places=9) ####################################################### ### Check reflection symmetry of two atom systems ##### ####################################################### # Remark: calling restrictEnergy() would cause a small deviation # Define state state_two = pi.StateTwo(state_one, state_one) # Diagonalize blockwise # Note: it is called odd in order to fit to the notion of the paper system_two_odd = pi.SystemTwo(system_one_even, system_one_even, self.path_cache) system_two_odd.add(pi.SystemTwo(system_one_odd, system_one_odd, self.path_cache)) system_two_odd.setDistance(1) system_two_odd.setOrder(5) system_two_odd.diagonalize() system_two_even = pi.SystemTwo(system_one_even, system_one_odd, self.path_cache) system_two_even.add(pi.SystemTwo(system_one_odd, system_one_even, self.path_cache)) system_two_even.setDistance(1) system_two_even.setOrder(5) system_two_even.diagonalize() system_two_combined = pi.SystemTwo(system_two_even) system_two_combined.add(system_two_odd) # Diagonalize blockwise alternative # Note: it is important to use system_one_combined system_two_alternative= pi.SystemTwo(system_one_combined, system_one_combined, self.path_cache) system_two_alternative.setDistance(1) system_two_alternative.setOrder(5) system_two_even_alternative = pi.SystemTwo(system_two_alternative) system_two_even_alternative.setConservedParityUnderReflection(pi.EVEN) system_two_even_alternative.diagonalize() system_two_odd_alternative = pi.SystemTwo(system_two_alternative) system_two_odd_alternative.setConservedParityUnderReflection(pi.ODD) system_two_odd_alternative.diagonalize() # Diagonalize altogether system_two = pi.SystemTwo(system_one, system_one, self.path_cache) system_two.setDistance(1) system_two.setOrder(5) system_two.diagonalize() # Compare results w1 = np.sort(system_two_combined.diagonal) w2 = np.sort(system_two.diagonal) w3 = np.sort(system_two_even.diagonal) w4 = np.sort(system_two_odd.diagonal) w5 = np.sort(system_two_even_alternative.diagonal) w6 = np.sort(system_two_odd_alternative.diagonal) maxdiff12 = np.abs((w1-w2)/(np.max([w1,w2],axis=0))) maxdiff35 = np.abs((w3-w5)/(np.max([w3,w5],axis=0))) maxdiff46 = np.abs((w4-w6)/(np.max([w4,w6],axis=0))) maxdiff12[np.abs(w1-w2)<1e-14] = np.abs(w1-w2)[np.abs(w1-w2)<1e-14] maxdiff35[np.abs(w3-w5)<1e-14] = np.abs(w3-w5)[np.abs(w3-w5)<1e-14] maxdiff46[np.abs(w4-w6)<1e-14] = np.abs(w4-w6)[np.abs(w4-w6)<1e-14] maxdiff12 = np.max(maxdiff12) maxdiff35 = np.max(maxdiff35) maxdiff46 = np.max(maxdiff46) print("Two-atom system with reflection symmetry, relative maximum deviation: ", maxdiff12, " (between alternatives: ", maxdiff35,", ", maxdiff46, ")") self.assertAlmostEqual(maxdiff12, 0, places=9) self.assertAlmostEqual(maxdiff35, 0, places=9) self.assertAlmostEqual(maxdiff46, 0, places=9)
def test_integration(self): # Build one-atom system system_one = pi.SystemOne(self.state_one.getSpecies(), self.cache) system_one.restrictEnergy( self.state_one.getEnergy() - 40, self.state_one.getEnergy() + 40) system_one.restrictN(self.state_one.getN() - 1, self.state_one.getN() + 1) system_one.restrictL(self.state_one.getL() - 1, self.state_one.getL() + 1) system_one.setEfield([0, 0, 0.1]) system_one.setBfield([0, 0, 1]) # Check for correct dimensions self.assertEqual(system_one.getNumBasisvectors(), 64) self.assertEqual(system_one.getNumStates(), 64) # Compare current results to the reference data (the results have to be # compared before diagonalization as the order of the eigenvectors is not # fixed) hamiltonian_one = system_one.getHamiltonian() basis_one = system_one.getBasisvectors() # without pruning, max_diff_hamiltonian might be infinity due to # division by zero hamiltonian_one.data *= (abs(hamiltonian_one).data > self.tolerance) hamiltonian_one.eliminate_zeros() basis_one.data *= (abs(basis_one).data > self.tolerance) basis_one.eliminate_zeros() if self.dump_new_reference_data: self.hamiltonian_one = hamiltonian_one.copy() self.basis_one = basis_one.copy() else: with open("integration_test_referencedata.pickle", "rb") as f: hamiltonian_one_reference, basis_one_reference, _, _ = pickle.load( f) np.testing.assert_allclose(hamiltonian_one.A, hamiltonian_one_reference.A, rtol=self.tolerance) np.testing.assert_allclose(basis_one.A, basis_one_reference.A, rtol=self.tolerance) # Diagonalize one-atom system system_one.diagonalize() # Build one-atom system (for this test, system_one has to be diagonal by # itself because diagonalization can lead to different order of # eigenvectors) system_one = pi.SystemOne(self.state_one.getSpecies(), self.cache) system_one.restrictEnergy( self.state_one.getEnergy() - 40, self.state_one.getEnergy() + 40) system_one.restrictN(self.state_one.getN() - 1, self.state_one.getN() + 1) system_one.restrictL(self.state_one.getL() - 1, self.state_one.getL() + 1) # Build two-atom system system_two = pi.SystemTwo(system_one, system_one, self.cache) system_two.restrictEnergy( self.state_two.getEnergy() - 2, self.state_two.getEnergy() + 2) system_two.setConservedParityUnderPermutation(pi.ODD) system_two.setDistance(6) system_two.setAngle(0.9) # Check for correct dimensions self.assertEqual(system_two.getNumBasisvectors(), 239) self.assertEqual(system_two.getNumStates(), 468) # Compare current results to the reference data (the results have to be # compared before diagonalization as the order of the eigenvectors is not # fixed) hamiltonian_two = system_two.getHamiltonian() basis_two = system_two.getBasisvectors() # without pruning, max_diff_hamiltonian might be infinity due to # division by zero hamiltonian_two.data *= (abs(hamiltonian_two).data > self.tolerance) hamiltonian_two.eliminate_zeros() basis_two.data *= (abs(basis_two).data > self.tolerance) basis_two.eliminate_zeros() if self.dump_new_reference_data: self.hamiltonian_two = hamiltonian_two.copy() self.basis_two = basis_two.copy() else: with open("integration_test_referencedata.pickle", "rb") as f: _, _, hamiltonian_two_reference, basis_two_reference = pickle.load( f) np.testing.assert_allclose(hamiltonian_two.A, hamiltonian_two_reference.A, rtol=self.tolerance) np.testing.assert_allclose(basis_two.A, basis_two_reference.A, rtol=self.tolerance) # Diagonalize two-atom system system_two.diagonalize()