def prepare_hamiltonian_and_states_for_optimization(num_spins,
total_j=None,
symmetry_sector='first'):
H0 = LMG_free_term(num_spins,
total_j=total_j,
symmetry_sector=symmetry_sector)
H1 = LMG_interaction_term(num_spins,
g_value=1.,
total_j=total_j,
symmetry_sector=symmetry_sector)
initial_state = ground_state(H0)
target_state = ground_state(H0 + H1)
return dict(H0=H0,
H1=H1,
initial_state=initial_state,
target_state=target_state)
def evolve_adiabatically(initial_hamiltonian,
final_hamiltonian,
tlist,
return_all_states=False):
"""Evolve the gs of an Hamiltonian towards that of another."""
if isinstance(tlist, numbers.Number):
tlist = np.linspace(0, tlist, 40)
delta_ham = final_hamiltonian - initial_hamiltonian
def linear_ramp(t, *args):
return t / tlist[-1]
H = [initial_hamiltonian, [delta_ham, linear_ramp]]
initial_state = ground_state(initial_hamiltonian)
return evolve_state(hamiltonian=H,
initial_state=initial_state,
tlist=tlist,
return_all_states=return_all_states)
import qutip
if '../../' not in sys.path:
sys.path.append('../../')
import src.optimization as optimization
import src.lmg_model as lmg_model
import src.protocol_ansatz as protocols
from src.utils import ground_state
num_spins = 50
tf_list = np.linspace(0, 1, 200)
time_ratios_list = np.linspace(0, 1, 400)
bound = [-100, 100]
lmg = lmg_model.LMGModel(num_spins=num_spins)
initial_state = ground_state(lmg.H0)
target_state = ground_state(lmg.hamiltonian(g_value=1.))
# ------ set up logger
output_file_name = 'scan_{}spins_bound{}.csv'.format(num_spins, bound[1])
logFormatter = logging.Formatter("%(asctime)s [%(threadName)-12.12s]"
"[%(levelname)-5.5s] %(message)s")
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.DEBUG)
fileHandler = logging.FileHandler(output_file_name[:-4] + '.log')
fileHandler.setFormatter(logFormatter)
fileHandler.setLevel(logging.DEBUG)
rootLogger.addHandler(fileHandler)
logging.info('Output file name will be "{}"'.format(output_file_name))
if '../../' not in sys.path:
sys.path.append('../../')
import src.rabi_model as rabi_model
import src.optimization as optimization
from src.utils import ground_state
# model parameters
N = 100
Omega = 100
omega_0 = 1
lambda_c = np.sqrt(Omega * omega_0) / 2.
# build Hamiltonians
H0 = rabi_model.QRM_free_term(N, Omega, omega_0)
H1 = rabi_model.QRM_interaction_term(N)
# compute initial and target states
initial_state = ground_state(H0)
target_state = ground_state(H0 + lambda_c * H1)
# run optimization
times_to_try = np.linspace(0.1, 4, 100)
num_frequencies = 2
num_CRAB_pars = 3 * num_frequencies
results = np.zeros(shape=[len(times_to_try), 2 + num_CRAB_pars])
for idx, tf in enumerate(times_to_try):
# crab hyperparameters
nuk = np.random.rand(num_frequencies)
parametrized_model = functools.partial(
optimization.make_CRAB_final_ramp_fun,
nuk=nuk,
tf=tf,
if '../../' not in sys.path:
sys.path.append('../../')
import src.optimization as optimization
import src.rabi_model as rabi_model
import src.protocol_ansatz as protocols
from src.utils import ground_state
N = 100
Omega = N
tf_list = np.linspace(0, 2, 200)
time_ratios_list = np.linspace(0, 1, 200)
heights_list = np.linspace(0, 20, 21)
rabi = rabi_model.RabiModel(N=N, Omega=Omega)
initial_state = ground_state(rabi.H0)
target_state = ground_state(rabi.hamiltonian(lambda_=np.sqrt(Omega) / 2.))
# ------ set up logger
output_file_name = 'scan_' + os.path.basename(__file__)[7:-3]
logFormatter = logging.Formatter("%(asctime)s [%(threadName)-12.12s]"
"[%(levelname)-5.5s] %(message)s")
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.INFO)
fileHandler = logging.FileHandler(output_file_name + '.log')
fileHandler.setFormatter(logFormatter)
fileHandler.setLevel(logging.INFO)
rootLogger.addHandler(fileHandler)
logging.info('Output file name will be "{}"'.format(output_file_name))
def critical_ground_state(self):
return ground_state(self.critical_hamiltonian)
def ground_state(self, parameter):
return ground_state(self.hamiltonian(parameter))
