def spectrum_eigenstates_manager():
if params.managing_job_queue == 'P' or params.managing_job_queue == 'M':
JS.limit_num_threads(4)
if params.is_hilbert_space_small:
if params.is_magnetic_flux:
magnetic_flux_index = int(sys.argv[2])
params.setHamiltonianLabels(magnetic_flux_index)
lz_val, parameters = setting_external_lz_val_h_parameters(
1, params.is_magnetic_flux)
AMAS.get_low_lying_spectrum(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N, lz_val,
params.hamiltonian_labels, parameters,
params_filename, 0)
return 0
magnetic_flux_index = 'None'
if params.is_magnetic_flux:
magnetic_flux_index = int(sys.argv[2])
lz_val, parameters = setting_external_lz_val_h_parameters(
0, params.is_magnetic_flux)
AMASW.calc_low_lying_spectrum_from_scratch(params_filename,
magnetic_flux_index)
return 0
def send_job_full_spectrum(params_filename,
lz_val_middle=None,
parameters_external=None):
params = ParametersAnnulus(params_filename)
filename_spectrum_eigenstates = FM.filename_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.lz_val, params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_spectrum_eigenstates):
print("file " + filename_spectrum_eigenstates + " already created")
return 0
queue = params.managing_job_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.managing_job_mem,
params.managing_job_vmem)
args = [params_filename]
if lz_val_middle:
args = args + [lz_val_middle]
if parameters_external:
args = args + parameters_external
# args = args + ['calc_full_spectrum']
# calculates low lying spectrum
args = args + ['spectrum_eigenstates_manager']
jobname = 'full_spectrum_' + params.params_filename_no_path
jobname = EC.make_job_name_short_again(jobname)
JS.send_job(scriptNames.multiFile,
pbs_filename=jobname,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
return 0
def calc_lz_vals_for_spectrum_from_scratch(params_filename,
lz_val_external=None,
parameters_external=None):
params = ParametersAnnulus(params_filename)
if lz_val_external:
lz_val = lz_val_external
else:
lz_val = params.lz_val
if parameters_external:
parameters = parameters_external
else:
parameters = params.h_parameters
filename_lz_spectrum = FM.filename_spectrum_lz_total_vals(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.hamiltonian_labels, parameters)
if EC.does_file_really_exist(filename_lz_spectrum):
print("already created " + filename_lz_spectrum)
return filename_lz_spectrum
filename_spectrum = calc_low_lying_spectrum_from_scratch(
params_filename, lz_val_external, parameters_external)
while not EC.does_file_really_exist(filename_spectrum):
sleep(60)
matrix_name = 'total_angular_momentum'
matrix_label = params.total_ang_momentum_label
args = [
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
lz_val, matrix_label
]
AMAS.create_matrix_pieces(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N, lz_val,
matrix_label, matrix_name, params_filename)
filename_lz_matrix = FM.filename_complete_matrix(matrix_name, args)
while not EC.does_file_really_exist(filename_lz_matrix):
sleep(60)
queue = params.lz_spectrum_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.lz_spectrum_mem,
params.lz_spectrum_vmem)
args = [params_filename]
if lz_val_external:
args = args + [lz_val_external]
if parameters_external:
args = args + parameters_external
args = args + ['spectrum_lz_calc']
jobname = 'calc_lz_spectrum_' + '_'.join([str(a) for a in args])
jobname = EC.make_job_name_short_again(jobname)
JS.send_job(scriptNames.multiFile,
pbs_filename=jobname,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
return filename_lz_spectrum
def calc_low_lying_spectrum():
if params.spectrum_eigenstates_queue == 'P' or params.spectrum_eigenstates_queue == 'M':
JS.limit_num_threads(4)
lz_val, parameters = setting_external_lz_val_h_parameters()
AMAS.get_low_lying_spectrum(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N, lz_val,
params.hamiltonian_labels, parameters,
params_filename)
def rerun_failed_matrix_piece(job):
queue = 'N'
mem = '4gb'
vmem = '8gb'
filename = "-".join(job)
JS.send_job(scriptNames.piecesMBMatrix,
queue,
mem=mem,
vmem=vmem,
script_args=job,
pbs_filename=filename)
return 0
def calc_spectrum_eigenstates_with_flux():
if params.spectrum_eigenstates_queue == 'P' or params.spectrum_eigenstates_queue == 'M':
JS.limit_num_threads(4)
if params.spectrum_job_manager_queue == 'P' or params.spectrum_eigenstates_queue == 'M':
JS.limit_num_threads(4)
magnetic_flux_index = int(sys.argv[2])
params.setHamiltonianLabels(magnetic_flux_index)
AMAS.get_low_lying_spectrum(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N, params.lz_val,
params.hamiltonian_labels, params.h_parameters,
params_filename)
return
def create_relevant_basis_list():
"""
doesn't work with external set of lz_val
If necessary, will add later
:return:
"""
if params.basis_list_queue == 'P' or params.basis_list_queue == 'M':
JS.limit_num_threads(4)
if params.lz_val == 'not_fixed':
basis_list = GA.create_basis_annulus(Mmin, Mmax, params.N)
else:
basis_list = GA.create_basis_annulus_const_lz(Mmin, Mmax, params.N,
params.lz_val)
return 0
def spectrum_eigenstates_batch():
if params.spectrum_eigenstates_queue == 'P' or params.spectrum_eigenstates_queue == 'M':
JS.limit_num_threads(4)
min_magnetic_flux_index = int(sys.argv[2])
max_magnetic_flux_index = int(sys.argv[3])
for magnetic_flux_index in range(min_magnetic_flux_index,
max_magnetic_flux_index + 1):
params.setHamiltonianLabels(magnetic_flux_index)
AMAS.get_low_lying_spectrum(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N,
params.lz_val, params.hamiltonian_labels,
params.h_parameters, params_filename, 0)
return 0
def calc_low_lying_spectrum_from_scratch(params_filename,
magnetic_flux_index='None',
send_jobs=True,
wait=True):
params = ParametersAnnulus(params_filename)
if magnetic_flux_index != 'None':
params.setHamiltonianLabels(magnetic_flux_index)
create_basis_lists(params.params_full_filename)
create_two_particle_hamiltonian(params_filename, magnetic_flux_index)
all_matrices_filenames = AMAS.calc_hamiltonian_pieces(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.lz_val, params.hamiltonian_labels, params_filename, send_jobs)
if not wait and not EC.all_files_exist(all_matrices_filenames):
print("not all matrices written yet, and I'm not a patient woman")
return 0
while not EC.all_files_exist(all_matrices_filenames):
sleep(120)
# actual calculation of low lying spectrum
filename_spectrum = FM.filename_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.lz_val, params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_spectrum):
print("we did this spectrum calculation already")
return filename_spectrum
queue = params.spectrum_eigenstates_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.spectrum_eigenstates_mem,
params.spectrum_eigenstates_vmem)
args = [params_filename, magnetic_flux_index]
args = args + ['calc_spectrum_eigenstates_with_flux']
# jobname = 'spectrum_eigenstates_' + params.params_filename_no_path
jobname = 'spectrum_eigenstates_magnetic_flux_index=' + str(
magnetic_flux_index)
jobname = EC.make_job_name_short_again(jobname)
JS.send_job(scriptNames.multiFile,
pbs_filename=jobname,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem,
ppn=params.ppn)
return filename_spectrum
def calc_density_profile(params_filename):
params = ParametersAnnulus(params_filename)
args = [params_filename, 'calc_density_profile']
job_name = 'density_profile_N=' + str(params.N) + '_MminL=' + str(
params.MminLaughlin) + '_MmaxL=' + str(
params.MmaxLaughlin) + '_edges=' + str(params.edge_states)
job_name = EC.make_job_name_short_again(job_name)
queue = params.managing_job_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.managing_job_mem,
params.managing_job_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
return
def calc_hamiltonian_pieces():
if params.matrix_pieces_queue == 'P' or params.matrix_pieces_queue == 'M':
JS.limit_num_threads(4)
if len(sys.argv) == 4:
lz_val = sys.argv[2]
if lz_val != 'not_fixed':
lz_val = int(float(lz_val))
AMAS.calc_hamiltonian_pieces(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N, lz_val,
params.hamiltonian_labels,
params_filename)
else:
AMAS.calc_hamiltonian_pieces(params.MminLaughlin, params.MmaxLaughlin,
params.edge_states, params.N,
params.lz_val, params.hamiltonian_labels,
params_filename)
return 0
def create_basis_lists(params_filename, lz_val_external=None):
params = ParametersAnnulus(params_filename)
queue = params.basis_list_queue
mem, vmem = JS.get_mem_vmem_vals(params.basis_list_queue,
params.basis_list_mem,
params.basis_list_vmem)
Mmin = params.MminLaughlin - params.edge_states
Mmax = params.MmaxLaughlin + params.edge_states
if lz_val_external:
lz_val = lz_val_external
else:
lz_val = params.lz_val
if lz_val == 'not_fixed':
# basis_filename = FM.filename_basis_annulus(Mmin, Mmax, params.N)
basis_filename = FM.filename_basis_annulus(0, Mmax - Mmin, params.N)
else:
basis_filename = FM.filename_basis_annulus_const_lz(
0, Mmax - Mmin, params.N, lz_val - params.N * Mmin)
if not EC.does_file_really_exist(basis_filename):
print("writing basis lists")
if lz_val_external:
args = [
params.params_full_filename, lz_val, 'create_all_basis_lists'
]
else:
args = [params.params_full_filename, 'create_all_basis_lists']
# filename = 'create_basis_' + params.params_filename_no_path
filename = 'create_basis_Mmin=' + str(Mmin) + '_Mmax=' + str(
Mmax) + '_N=' + params.N
JS.send_job(scriptNames.multiFile,
pbs_filename=filename,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
while not EC.does_file_really_exist(basis_filename):
sleep(60)
print("done writing basis")
else:
print("basis already written")
return 0
def create_two_particle_hamiltonian(params_filename, magnetic_flux_index=None):
params = ParametersAnnulus(params_filename)
queue = params.two_particle_queue
mem = params.two_particle_mem
vmem = params.two_particle_vmem
mem, vmem = JS.get_mem_vmem_vals(queue, mem, vmem)
Mmin = params.MminLaughlin - params.edge_states
Mmax = params.MmaxLaughlin + params.edge_states
if magnetic_flux_index != None:
magnetic_flux = params.flux_range[magnetic_flux_index]
two_particle_ham_filename = FM.filename_two_particle_matrices(
Mmin, Mmax, params.potential_type + '_' + str(magnetic_flux))
else:
two_particle_ham_filename = FM.filename_two_particle_matrices(
Mmin, Mmax, params.potential_type)
if EC.does_file_really_exist(two_particle_ham_filename):
print("2-particle hamiltonian already exists")
else:
print("creating 2-particle hamiltonian")
if magnetic_flux_index != None:
args = [
params.params_full_filename, magnetic_flux,
'two_particle_hamiltonian'
]
else:
args = [params.params_full_filename, 'two_particle_hamiltonian']
pbs_filename = '2_particle_ham_Mmin=' + str(Mmin) + '_Mmax=' + str(
Mmax) + '_potential_type=' + params.potential_type
pbs_filename = EC.make_job_name_short_again(pbs_filename)
JS.send_job(scriptNames.multiFile,
pbs_filename=pbs_filename,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
two_particle_ham_filename = FM.filename_two_particle_matrices(
Mmin, Mmax, params.potential_type)
while not EC.does_file_really_exist(two_particle_ham_filename):
sleep(20)
print("done writing two-particle hamiltonian")
def calc_lz_spectrum_wrap_job(params_filename,
lz_val_external=None,
parameters_external=None,
magnetic_flux_index=0):
params = ParametersAnnulus(params_filename)
if lz_val_external:
lz_val = lz_val_external
else:
lz_val = params.lz_val
if parameters_external:
parameters = parameters_external
else:
parameters = params.h_parameters
if params.is_magnetic_flux:
params.setHamiltonianLabels(magnetic_flux_index)
filename_lz_spectrum = FM.filename_spectrum_lz_total_vals(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.hamiltonian_labels, parameters)
if EC.does_file_really_exist(filename_lz_spectrum):
print("already created " + filename_lz_spectrum)
return 0
queue = params.lz_spectrum_manager_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.lz_spectrum_manager_mem,
params.lz_spectrum_manager_vmem)
args = [params_filename]
if lz_val_external:
args = args + [lz_val_external]
if parameters_external:
args = args + parameters_external
args = args + ['spectrum_lz_vals_manager']
jobname = 'lz_spectrum_manager_params_file' + params.params_filename_no_path
jobname = EC.make_job_name_short_again(jobname)
JS.send_job(scriptNames.multiFile,
pbs_filename=jobname,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
return 0
def unite_and_write_full_matrix(MminL, MmaxL, edge_states, N, lz_val,
matrix_label, matrix_name, params_filename):
params = ParametersAnnulus(params_filename)
queue = params.write_unite_matrix_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.write_unite_matrix_mem,
params.write_unite_matrix_vmem)
args = [MminL, MmaxL, edge_states, N, lz_val, matrix_label]
filename_complete_matrix = FM.filename_complete_matrix(matrix_name, args)
if EC.does_file_really_exist(filename_complete_matrix):
print("matrix already written")
return 0
args = [matrix_name, MminL, MmaxL, edge_states, N, lz_val, matrix_label]
filename = 'writing_matrix_' + "_".join([str(a) for a in args])
filename = EC.make_job_name_short_again(filename)
JS.send_job(scriptNames.uniteMatrixPieces,
queue=queue,
mem=mem,
vmem=vmem,
pbs_filename=filename,
script_args=args)
return 0
def calc_luttinger_parameter(params_filename):
params = ParametersAnnulus(params_filename)
args = [params_filename, 'calc_luttinger_parameter']
filename_luttinger = FM.filename_spectrum_luttinger_parm(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
'all', params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_luttinger):
print("we did this luttinger spectrum already")
return
job_name = 'lutt_p_N=' + str(params.N) + '_MminL=' + str(
params.MminLaughlin) + '_MmaxL=' + str(
params.MmaxLaughlin) + '_edges=' + str(params.edge_states)
job_name = EC.make_job_name_short_again(job_name)
queue = params.luttinger_parm_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.luttinger_parm_mem,
params.luttinger_parm_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
def calc_luttinger_parameter():
if params.luttinger_parm_queue == 'P' or params.luttinger_parm_queue == 'M':
JS.limit_num_threads(4)
AMAS.calc_luttinger_parameter_from_scratch(params_filename,
params.lz_laughlin, False)
def calc_full_low_lying_spectrum(params_filename,
send_jobs=True,
wait=False,
lz_val_middle=None,
parameters_external=None,
window_of_lz='all'):
params = ParametersAnnulus(params_filename)
if not lz_val_middle:
lz_val = params.lz_laughlin
else:
lz_val = lz_val_middle
if parameters_external:
parameters = parameters_external
else:
parameters = params.h_parameters
filename_full_spectrum = FM.filename_full_spectrum(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
window_of_lz, params.hamiltonian_labels, parameters)
if EC.does_file_really_exist(filename_full_spectrum):
full_spectrum = graphData.plot_spectrum_graph_data_from_file(
filename_full_spectrum)
return full_spectrum
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
Mmin = params.MminLaughlin - params.edge_states
Mmax = params.MmaxLaughlin + params.edge_states
lz_total_vals = LCA.find_all_lz_total_values(Mmin, Mmax, params.N)
if window_of_lz == 'all':
lz_min = lz_total_vals[0]
lz_max = lz_total_vals[-1]
else:
lz_min = max(lz_val - window_of_lz, lz_total_vals[0])
lz_max = min(lz_val + window_of_lz, lz_total_vals[-1])
all_file_names = []
for lz in range(lz_min, lz_max + 1):
filename_lz_spectrum = FM.filename_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, parameters)
if EC.does_file_really_exist(filename_lz_spectrum):
spectrum = FM.read_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, parameters)
size_hilbert_space = GA.size_of_hilbert_space(
Mmin, Mmax, params.N, lz_val)
if len(
spectrum
) >= params.num_of_eigstates or size_hilbert_space <= params.num_of_eigstates:
print("we did this lz spectrum calculation already!")
else:
if send_jobs:
sleep(2)
print("finding the spectrum")
args = [params_filename, lz]
if parameters_external:
args = args + parameters_external
args = args + ['spectrum_eigenstates_manager']
# job_name = 'spectrum_job_manager_' + params.params_filename_no_path
job_name = 'full_spectrum_N=' + str(
params.N) + '_MminL=' + str(
params.MminLaughlin) + '_MmaxL=' + str(
params.MmaxLaughlin) + '_edges=' + str(
params.edge_states)
job_name = EC.make_job_name_short_again(job_name)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
all_file_names.append(filename_lz_spectrum)
else:
if send_jobs:
sleep(2)
print("finding the spectrum")
args = [params_filename, lz]
if parameters_external:
args = args + parameters_external
args = args + ['spectrum_eigenstates_manager']
# job_name = 'spectrum_job_manager_' + params.params_filename_no_path
job_name = 'full_spectrum_N=' + str(
params.N) + '_MminL=' + str(
params.MminLaughlin) + '_MmaxL=' + str(
params.MmaxLaughlin) + '_edges=' + str(
params.edge_states)
job_name = EC.make_job_name_short_again(job_name)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
all_file_names.append(filename_lz_spectrum)
while not EC.all_files_exist(all_file_names):
if not wait:
print("not done creating spectrum!")
return
sleep(100)
full_spectrum = {}
print(range(lz_min, lz_max + 1))
for lz in range(lz_min, lz_max + 1):
spec_states = FM.read_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, parameters)
spectrum = np.array(
[spec_states[i][0] for i in range(len(spec_states))])
print("***************")
print(spectrum)
full_spectrum[lz] = spectrum
title = 'low lying spectrum of system with N=' + str(
params.N) + ' MminL=' + str(params.MminLaughlin) + ' MmaxL=' + str(
params.MmaxLaughlin) + '\nham_lbls: ' + ' '.join(
params.hamiltonian_labels) + '\nLz laughlin at ' + str(
params.lz_laughlin)
xlabel = 'Lz total'
ylabel = 'Energy'
graphData.write_spectrum_data_to_file(filename_full_spectrum,
full_spectrum, title, xlabel, ylabel)
return full_spectrum
def calc_full_spectrum_magnetic_flux_range(params_filename,
wait=True,
send_jobs=True,
batch_size=None):
params = ParametersAnnulus(params_filename)
flux_range_size = len(params.flux_range)
params.setHamiltonianLabels()
filename_spectrum_vs_flux_range = FM.filename_spectrum_vs_magnetic_flux(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_spectrum_vs_flux_range):
spectrum = graphData.plot_spectrum_graph_data_from_file(
filename_spectrum_vs_flux_range)
print("file created!")
return spectrum
all_filename_to_create = []
if batch_size:
min_index = 0
max_index = 0
count = 0
for index in range(flux_range_size):
params.setHamiltonianLabels(index)
filename_spectrum_flux = FM.filename_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, params.lz_val, params.hamiltonian_labels,
params.h_parameters)
# print(filename_spectrum_flux)
if EC.does_file_really_exist(filename_spectrum_flux):
# print("we did this calculation already")
a = 1
else:
if send_jobs:
if not batch_size:
sleep(2)
print("finding the spectrum for flux index=" + str(index))
args = [params_filename, index]
args = args + ['spectrum_eigenstates_manager']
job_name = 'spectrum_job_manager_' + "magnetic_flux_index=" + str(
index) + "_FM_parameter=" + str(params.FM_parameter)
job_name = EC.make_job_name_short_again(job_name)
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(
queue, params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem,
ppn=params.ppn)
else:
count = count + 1
max_index = index
if count == 1:
min_index = index
if index == (flux_range_size - 1):
# max_index = index
sleep(2)
print("sending a batch with FM=" +
str(params.FM_parameter) +
" and max_index=" + str(max_index))
args = [params_filename, min_index, max_index]
args = args + ['spectrum_eigenstates_batch']
job_name = 'flux_spectrum_batch_' + "min_flux_index=" + str(
min_index) + "_FM_parameter=" + str(
params.FM_parameter)
job_name = EC.make_job_name_short_again(job_name)
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(
queue, params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
elif count == batch_size or index == (flux_range_size - 1):
# max_index = index
sleep(2)
print("sending a batch with FM=" +
str(params.FM_parameter) + " and max_index=" +
str(max_index))
args = [params_filename, min_index, max_index]
args = args + ['spectrum_eigenstates_batch']
job_name = 'flux_spectrum_batch_' + "min_flux_index=" + str(
min_index) + "_FM_parameter=" + str(
params.FM_parameter)
job_name = EC.make_job_name_short_again(job_name)
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(
queue, params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
count = 0
all_filename_to_create.append(filename_spectrum_flux)
if batch_size and count > 0:
sleep(2)
print("sending a batch with FM=" + str(params.FM_parameter) +
" and max_index=" + str(max_index))
args = [params_filename, min_index, max_index]
args = args + ['spectrum_eigenstates_batch']
job_name = 'flux_spectrum_batch_' + "min_flux_index=" + str(
min_index) + "_FM_parameter=" + str(params.FM_parameter)
job_name = EC.make_job_name_short_again(job_name)
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(queue,
params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
while not EC.all_files_exist(all_filename_to_create):
if not wait:
print("still must create #" + str(len(all_filename_to_create)) +
" files")
return
sleep(100)
full_spectrum = {}
print("writing spectrum into file " + filename_spectrum_vs_flux_range)
for index in range(flux_range_size):
# print(index)
# print(params.potential_type)
params.setHamiltonianLabels(index)
# print(params.hamiltonian_labels)
spec_states = FM.read_spectrum_eigenstates(params.MminLaughlin,
params.MmaxLaughlin,
params.edge_states,
params.N, params.lz_val,
params.hamiltonian_labels,
params.h_parameters)
spectrum = np.array(
[spec_states[i][0] for i in range(len(spec_states))])
# print("***************")
# print(spectrum)
full_spectrum[params.flux_range[index]] = spectrum
title = 'spectrum vs. magnetic flux of system with N=' + str(
params.N) + ' MminL=' + str(params.MminLaughlin) + ' MmaxL=' + str(
params.MmaxLaughlin) + '\nham_lbls: ' + ' '.join(
params.hamiltonian_labels) + '\nLz laughlin at ' + str(
params.lz_laughlin)
xlabel = 'Magnetic flux'
ylabel = 'Energy'
graphData.write_spectrum_data_to_file(filename_spectrum_vs_flux_range,
full_spectrum, title, xlabel, ylabel)
return full_spectrum
def create_matrix_pieces(MminL, MmaxL, edge_states, N, lz_val, matrix_label,
matrix_name, params_filename):
params = ParametersAnnulus(params_filename)
common_args = [MminL, MmaxL, edge_states, N, lz_val, matrix_label]
filename_complete_matrix = FM.filename_complete_matrix(
matrix_name, common_args)
if EC.does_file_really_exist(filename_complete_matrix):
print("already created " + filename_complete_matrix)
return 0
queue = params.matrix_pieces_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.matrix_pieces_mem,
params.matrix_pieces_vmem)
Mmin = MminL - edge_states
Mmax = MmaxL + edge_states
hilbert_space_size = GA.size_of_hilbert_space(Mmin, Mmax, N, lz_val)
if hilbert_space_size < 10000:
args = [matrix_name] + common_args
str_args = [str(a) for a in args]
str_args = '-'.join(str_args)
filename_job = str_args
JS.send_job(scriptNames.fullMBMatrix,
queue,
mem=mem,
vmem=vmem,
script_args=args,
pbs_filename=filename_job)
return 0
slice_size = int(hilbert_space_size / params.speeding_parameter)
last_slice_size = hilbert_space_size - params.speeding_parameter * slice_size
slice_start = 0
slice_end = slice_size
count_num_jobs_sent = 0
for i in range(params.speeding_parameter):
filename_args = [MminL, MmaxL, edge_states, N, lz_val, matrix_label]
filename_martix_piece = FM.filename_matrix_piece(
matrix_name, filename_args, [slice_start, slice_end - 1])
if EC.does_file_really_exist(filename_martix_piece):
print("matrix piece " + filename_martix_piece + " already exists!")
else:
count_num_jobs_sent = count_num_jobs_sent + 1
args = [matrix_name] + common_args + [slice_start, slice_end] + [
params.speeding_parameter, params_filename
]
str_args = [str(a) for a in args]
str_args = '-'.join(str_args[:-1])
filename_job = str_args
JS.send_job(scriptNames.piecesMBMatrix,
queue,
mem=mem,
vmem=vmem,
script_args=args,
pbs_filename=filename_job)
sleep(2)
slice_start = slice_start + slice_size
slice_end = slice_end + slice_size
# taking care of last slice
if last_slice_size > 0:
slice_end = slice_start + last_slice_size
filename_args = [MminL, MmaxL, edge_states, N, lz_val, matrix_label]
filename_martix_piece = FM.filename_matrix_piece(
matrix_name, filename_args, [slice_start, slice_end - 1])
if EC.does_file_really_exist(filename_martix_piece):
print("matrix piece " + filename_martix_piece + " already exists!")
else:
count_num_jobs_sent = count_num_jobs_sent + 1
args = [matrix_name] + common_args + [slice_start, slice_end] + [
params.speeding_parameter, params_filename
]
str_args = [str(a) for a in args]
str_args = '-'.join(str_args[:-1])
filename = str_args
JS.send_job(scriptNames.piecesMBMatrix,
queue,
mem=mem,
vmem=vmem,
script_args=args,
pbs_filename=filename)
if count_num_jobs_sent == 0:
AMASW.unite_and_write_full_matrix(MminL, MmaxL, edge_states, N, lz_val,
matrix_label, matrix_name,
params_filename)
return 0
MminL = int(sys.argv[2])
MmaxL = int(sys.argv[3])
edge_states = int(sys.argv[4])
N = int(sys.argv[5])
lz_val = sys.argv[6]
matrix_label = sys.argv[7]
slice_start = int(sys.argv[8])
slice_end = int(sys.argv[9])
speeding_parameter = int(sys.argv[10])
params_filename = sys.argv[11]
Mmin = MminL - edge_states
Mmax = MmaxL + edge_states
params = ParametersAnnulus(params_filename)
JS.limit_num_threads()
if params.matrix_pieces_queue == 'P' or params.matrix_pieces_queue == 'M':
JS.limit_num_threads(4)
"""
matrix_name in [interactions,FM_term,confining_potential,edge_correlation,density]
"""
if lz_val == 'not_fixed':
basis_list = GA.create_basis_annulus(Mmin, Mmax, N)
else:
lz_val = int(float(lz_val))
basis_list = GA.create_basis_annulus_const_lz(Mmin, Mmax, N, lz_val)
state2index = GA.state_index_dict(basis_list)
def calc_luttinger_spectrum_big(params_filename, send_jobs=True, wait=False):
params = ParametersAnnulus(params_filename)
window_of_lz = 'all'
filename_luttinger_spectrum = FM.filename_spectrum_luttinger_parm(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states, params.N,
window_of_lz, params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_luttinger_spectrum):
print("full lut spectrum created already!")
full_spectrum = graphData.plot_spectrum_graph_data_from_file(
filename_luttinger_spectrum)
return full_spectrum
queue = params.spectrum_job_manager_queue
mem, vmem = JS.get_mem_vmem_vals(queue, params.spectrum_job_manager_mem,
params.spectrum_job_manager_vmem)
Mmin = params.MminLaughlin - params.edge_states
Mmax = params.MmaxLaughlin + params.edge_states
first_arc_lz = np.array([params.lz_laughlin + i for i in range(params.N)])
umbrella_lz = np.array([
params.lz_laughlin - params.N * params.edge_states + params.N * i
for i in range(2 * params.edge_states + 1)
])
lz_vals_to_add_spectrum = np.concatenate((first_arc_lz, umbrella_lz))
all_file_names = []
for lz in lz_vals_to_add_spectrum:
lz = int(lz)
filename_lz_spectrum = FM.filename_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, params.h_parameters)
if EC.does_file_really_exist(filename_lz_spectrum):
spectrum = FM.read_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, params.h_parameters)
size_hilbert_space = GA.size_of_hilbert_space(
Mmin, Mmax, params.N, lz)
if len(
spectrum
) >= params.num_of_eigstates or size_hilbert_space <= params.num_of_eigstates:
# print("we did this lz spectrum calculation already!")
a = "do nothing"
else:
if send_jobs:
sleep(2)
print("finding the spectrum")
args = [params_filename, lz]
args = args + ['spectrum_eigenstates_manager']
# job_name = 'spectrum_job_manager_' + params.params_filename_no_path
job_name = 'lut_spectrum_N=' + str(
params.N) + '_MminL=' + str(
params.MminLaughlin) + '_edges=' + str(
params.edge_states) + '_lz=' + str(lz)
job_name = EC.make_job_name_short_again(job_name)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
all_file_names.append(filename_lz_spectrum)
else:
if send_jobs:
sleep(2)
print("finding the spectrum")
args = [params_filename, lz]
args = args + ['spectrum_eigenstates_manager']
# job_name = 'spectrum_job_manager_' + params.params_filename_no_path
job_name = 'lut_spectrum_N=' + str(params.N) + '_MminL=' + str(
params.MminLaughlin) + '_edges=' + str(
params.edge_states) + '_lz=' + str(lz)
job_name = EC.make_job_name_short_again(job_name)
JS.send_job(scriptNames.multiFile,
pbs_filename=job_name,
script_args=args,
queue=queue,
mem=mem,
vmem=vmem)
all_file_names.append(filename_lz_spectrum)
while not EC.all_files_exist(all_file_names):
if not wait:
print("not done creating spectrum! still must create " +
str(len(all_file_names)) + " out of " +
str(len(lz_vals_to_add_spectrum)))
return
sleep(100)
lut_spectrum = {}
for lz in lz_vals_to_add_spectrum:
lz = int(lz)
spec_states = FM.read_spectrum_eigenstates(
params.MminLaughlin, params.MmaxLaughlin, params.edge_states,
params.N, lz, params.hamiltonian_labels, params.h_parameters)
spectrum = np.array(
[spec_states[i][0] for i in range(len(spec_states))])
print("***************")
print(spectrum)
lut_spectrum[lz] = spectrum
title = 'Luttinger spectrum of system with N=' + str(
params.N) + ' MminL=' + str(params.MminLaughlin) + ' MmaxL=' + str(
params.MmaxLaughlin) + '\nham_lbls: ' + ' '.join(
params.hamiltonian_labels) + '\nLz laughlin at ' + str(
params.lz_laughlin)
xlabel = 'Lz total'
ylabel = 'Energy'
graphData.write_spectrum_data_to_file(filename_luttinger_spectrum,
lut_spectrum, title, xlabel, ylabel)
return lut_spectrum