def MakeOperator(coefficients, terms, verbose=False):
# Initialize.
n_terms = len(coefficients)
one_percent = numpy.rint(numpy.ceil(n_terms / 100.))
start = time.clock()
n_orbitals = commutators.OrbitalCount(terms)
jw_terms = GetJordanWignerTerms(n_orbitals)
# Loop over terms.
operator = 0
for i, (coefficient, term) in enumerate(zip(coefficients, terms)):
operator = operator + MatrixForm(coefficient, term, jw_terms)
# Report progress.
if verbose and not (i + 1) % one_percent:
percent_complete = numpy.rint(100. * (i + 1) / n_terms)
elapsed = time.clock() - start
rate = elapsed / percent_complete
eta = rate * (100 - percent_complete)
print(
'%s. Computation %i%% complete. Approximately %i '
'minute(s) remaining.' %
(time.strftime('%B %d at %H:%M:%S', time.localtime()),
percent_complete, round(eta / 60)))
assert IsHermitian(operator)
return operator
def __init__(self, terms, reference_state, hamiltonian, cc_form=False):
# Initialize dictionary of unitaries.
self.terms = terms
self.hamiltonian = hamiltonian
self.reference_state = reference_state
n_orbitals = commutators.OrbitalCount(terms)
jw_terms = GetJordanWignerTerms(n_orbitals)
self.matrices = {}
for term in terms:
self.matrices[tuple(term)] = MatrixForm(1.,
term,
jw_terms,
add_conjugates=True,
anti_hermitian=cc_form)
assert IsHermitian(self.matrices[tuple(term)])
self.min_energy = numpy.inf
self.calls = 0
def main():
# Test parameters.
molecule = str(argv[1])
basis = str(argv[2])
try:
cc_form = bool(argv[3])
except:
cc_form = False
try:
run_type = str(argv[4])
except:
run_type = 'ucc'
try:
dirpath = str(argv[5])
except:
dirpath = None
# Get Hamiltonian
print 'dirpath', dirpath
fci_hamiltonian = GetHamiltonian(molecule, basis, n_excitations='FCI')
cisd_hamiltonian = GetHamiltonian(molecule, basis, n_excitations=2)
repulsion, coefficients, ham_terms = commutators.GetHamiltonianTerms(
molecule, basis)
print 'Number of terms %i' % len(ham_terms)
print "terms:", ham_terms
n_electrons = commutators.ElectronCount(molecule)
n_orbitals = commutators.OrbitalCount(ham_terms)
print "n orbitals:", n_orbitals
basis_parsed = basis.split('-')
print basis_parsed
print basis_parsed[0]
energies = []
# Get states and energies.
#fci_state = SparseDiagonalize(fci_hamiltonian)
#print fci_state
cisd_state = SparseDiagonalize(cisd_hamiltonian)
#print cisd_state
hf_state = HartreeFockState(n_electrons, n_orbitals)
#fci_energy = Expectation(fci_hamiltonian, fci_state)
#cisd_energy = Expectation(fci_hamiltonian, cisd_state)
hf_energy = Expectation(fci_hamiltonian, hf_state)
print basis_parsed
# energies=[basis_parsed[0],str(hf_energy+repulsion),str(cisd_energy+repulsion),str(fci_energy+repulsion)]
energies = [basis_parsed[0], str(hf_energy + repulsion)]
# Get terms
initial_guess = []
terms = []
# JRF
jw_terms = GetJordanWignerTerms(n_orbitals)
counter = 0
coeffs = []
thres = 1E-08
if run_type == 'troyer':
for coefficient, term in zip(coefficients, ham_terms):
# JRF
counter = counter + 1
hterm = MatrixForm(1.,
term,
jw_terms,
add_conjugates=True,
anti_hermitian=cc_form)
hcontribution = Expectation(hterm, cisd_state)
initial_guess += [hcontribution]
terms += [term]
elif run_type == 'troyer-wc':
# JRF
for coefficient, term in zip(coefficients, ham_terms):
# JRF
hterm = MatrixForm(1.,
term,
jw_terms,
add_conjugates=True,
anti_hermitian=cc_form)
hcontribution = Expectation(hterm, cisd_state)
if commutators.GetConjugate(term):
counter = counter + 1
initial_guess += [hcontribution]
terms += [term]
elif run_type == 'ucc':
opt = 1
if opt == 1:
n_excitations = 2
print 'electrons:', n_electrons
ncore = 0
occ = range(ncore + 1, n_electrons + 1)
vir = range(n_electrons + 1, n_orbitals + 1)
operators = []
for n in range(1, n_excitations + 1):
for cosa1 in combinations(occ, n):
for cosa2 in combinations(vir, n):
cosita = []
cosita.extend(cosa2[::-1])
cosita.extend([x * -1 for x in cosa1[::-1]])
operators.append(cosita)
else:
operators = [[3, 4, -2, -1], [6, 5, -2, -1]]
# JRF
for term in operators:
# JRF
hterm = MatrixForm(1.,
term,
jw_terms,
add_conjugates=True,
anti_hermitian=False)
hcontribution = Expectation(hterm, cisd_state)
# print "hamiltonian terms"
# print ham_terms
# location=ham_terms.index(term)
# hcontribution=coefficients[location]
counter = counter + 1
initial_guess += [hcontribution]
terms += [term]
print initial_guess
filename1 = molecule + basis + '.out'
output1 = open(filename1, 'a')
# output2=open('OptimalParameters_H3pd__CCD.out','a')
print 'This is the number of terms for VQE:', counter
ncalls, solution, variational_energy = VariationallyMinimize(
terms, hf_state, initial_guess, fci_hamiltonian, cc_form)
print 'Variationally optimal energy is %s.\n' % repr(
float(variational_energy + repulsion))
diff = variational_energy - fci_energy
print 'Data %f %s %i %s.\n' % (thres, repr(
float(variational_energy)), counter, repr(float(diff)))
print 'Optimal parameters \n'
for t, ov in zip(terms, solution):
if abs(ov) > 1E-6:
print t, ov
print energies
# Obtain variational solution.
print 'Analyzing %s in the %s basis.\n' % (molecule, basis)
print 'Hartree-Fock energy is %s.' % repr(float(hf_energy))
print '\nExact (FCI) energy is %s.' % repr(float(fci_energy))
print 'CISD energy is %s.' % repr(float(cisd_energy))
print 'Hartree-Fock energy is %s.' % repr(float(hf_energy))
# writing results
energies.append(str(variational_energy + repulsion))
energies.append(str(diff))
energies.append(ncalls)
energies.append(counter)
output1.write((" ".join(str(i) for i in energies) + '\n'))
output1.close()