def test_write_split_at(): with state.State(INPUT_FILE, QUIET) as p_state: configuration.plus_z(p_state) chain.image_to_clipboard(p_state) noi = 10 chain.set_length(p_state, noi) for idx_image in range(noi): configuration.skyrmion(p_state, radius=2*idx_image, idx_image=idx_image) # Test write split_at filenames = [ os.path.join(SCRIPT_DIR, n) for n in ["output_1.ovf", "output_2.ovf"] ] idx_list = [2,3,9] idx_pairs = [[2,3], [3,9]] old_spin_directions = [] for p in idx_pairs: old_spin_directions.append([]) for idx in range(p[0], p[1]+1): old_spin_directions[-1].append( np.array(system.get_spin_directions(p_state, idx_image=idx)) ) chain_io.chain_write_split_at(p_state, idx_list=idx_list, filename_list=filenames) for j,(f,p) in enumerate(zip(filenames, idx_pairs)): chain.set_length(p_state, 1) io.chain_read(p_state, f) idx_1 = p[0] idx_2 = p[1] for i, idx in enumerate(range(idx_1, idx_2 + 1)): new_spin_directions = np.array( np.array(system.get_spin_directions(p_state, idx_image=i)) ) print( "Testing image {}, original idx {}".format(i, idx) ) res = np.max( np.ravel(old_spin_directions[j][i] ) - np.ravel(new_spin_directions ) ) print( res ) assert( res < 1e-10 )
def helper(p_state, node): node.log(" collecting...") # Make sure the number of images matches our current simulation state chain.image_to_clipboard(p_state) noi = io.n_images_in_file(p_state, node.chain_file) chain.set_length(p_state, noi) io.chain_read(p_state, node.chain_file) noi = chain.get_noi(p_state) i = 0 while i < noi: # First we check if this images is within any of the ranges covered by the children is_child = False for idx_c, (i1, i2) in enumerate(node.child_indices): if i >= i1 and i <= i2: is_child = True idx_child = idx_c break # If the current idx is covered by a child node, we open up another level of recursion, else we append the image if is_child: helper(p_state, node.children[idx_child]) # After collecting the child we advance the current iteration idx, so that we continue one past the last child index i = node.child_indices[idx_child][1] + 1 # We also need to read the chain file again to return to our previous state chain.image_to_clipboard(p_state) chain.set_length(p_state, noi) io.chain_read(p_state, node.chain_file) else: io.image_append(p_state, output_file, idx_image=i) i += 1
def test_write_between(): OUTPUT_FILE = os.path.join(SCRIPT_DIR, "output_test_chain_io.ovf") with state.State(INPUT_FILE, QUIET) as p_state: configuration.plus_z(p_state) chain.image_to_clipboard(p_state) noi = 10 chain.set_length(p_state, noi) for idx_image in range(noi): configuration.skyrmion(p_state, radius=2*idx_image, idx_image=idx_image) # Test write between idx_1 = 2 idx_2 = 5 old_spin_directions = [] for idx in range(idx_1, idx_2+1): old_spin_directions.append( np.array(system.get_spin_directions(p_state, idx_image=idx)) ) chain_io.chain_write_between(p_state, OUTPUT_FILE, idx_1, idx_2) chain.set_length(p_state, 1) io.chain_read(p_state, OUTPUT_FILE) for i, idx in enumerate(range(idx_1, idx_2 + 1)): new_spin_directions = np.array( np.array(system.get_spin_directions(p_state, idx_image=i)) ) print( "Testing image {}, original idx {}".format(i, idx) ) res = np.max( np.ravel(old_spin_directions[i] ) - np.ravel(new_spin_directions ) ) print( res ) assert( res < 1e-10 )
def chain_append_from_file(p_state, filename): # TODO: chain_read with insert_idx seems to be broken raise NotImplementedError() from spirit import io, chain noi_file = io.n_images_in_file(p_state, filename) noi = chain.get_noi(p_state) chain.image_to_clipboard(p_state) chain.set_length(p_state, noi + noi_file) io.chain_read(p_state, filename, insert_idx=noi) chain.update_data(p_state)
def chain_append_to_file_from_file(p_state, filename_out, filename_in): """Reads the chain from `filename_in` and appends it to `filename_out`""" from spirit import io, chain noi_file = io.n_images_in_file(p_state, filename_in) chain.image_to_clipboard(p_state) chain.set_length(p_state, noi_file) io.chain_read(p_state, filename_in) # TODO: io.chain_append seems to be broken, so we use image_append... for i in range(noi_file): io.image_append(p_state, filename_out, idx_image=i)
def test_append_to_file_from_file(): FILE_IN = os.path.join(SCRIPT_DIR, "in.ovf") FILE_OUT = os.path.join(SCRIPT_DIR, "out.ovf") if os.path.exists(FILE_OUT): os.remove(FILE_OUT) with state.State(INPUT_FILE, QUIET) as p_state: configuration.plus_z(p_state) chain.image_to_clipboard(p_state) noi = 2 chain.set_length(p_state, noi) for idx_image in range(noi): configuration.skyrmion(p_state, radius=2*idx_image, idx_image=idx_image) old_spin_directions = [] for idx in range(noi): old_spin_directions.append( np.array(system.get_spin_directions(p_state, idx_image=idx)) ) io.chain_write(p_state, FILE_IN) chain.set_length(p_state, 1) configuration.random(p_state) chain_io.chain_append_to_file_from_file(p_state, FILE_OUT, FILE_IN) chain_io.chain_append_to_file_from_file(p_state, FILE_OUT, FILE_IN) chain_io.chain_append_to_file_from_file(p_state, FILE_OUT, FILE_IN) chain_io.chain_append_to_file_from_file(p_state, FILE_OUT, FILE_IN) chain.set_length(p_state, 1) io.chain_read(p_state, FILE_OUT) for i in range(4): print( "Testing image {}, original idx {}".format(i, idx) ) new_spin_directions = np.array( np.array(system.get_spin_directions(p_state, idx_image=2*i)) ) res = np.max( np.ravel(old_spin_directions[0] ) - np.ravel(new_spin_directions ) ) print( res ) assert( res < 1e-10 ) new_spin_directions = np.array( np.array(system.get_spin_directions(p_state, idx_image=2*i+1)) ) res = np.max( np.ravel(old_spin_directions[1] ) - np.ravel(new_spin_directions ) ) print( res ) assert( res < 1e-10 )
def _prepare_state(self, p_state): """Prepares the state and reads in the chain.""" from spirit import parameters, io # Set the output folder for the files created by spirit set_output_folder(p_state, self.output_folder, self.output_tag) # Set the gneb convergence parameter parameters.gneb.set_convergence(p_state, self.convergence) if self.moving_endpoints is not None: parameters.gneb.set_moving_endpoints(p_state, self.moving_endpoints) if self.translating_endpoints is not None: parameters.gneb.set_translating_endpoints( p_state, self.translating_endpoints) if self.delta_Rx_left is not None and self.delta_Rx_right is not None: parameters.gneb.set_equilibrium_delta_Rx( p_state, self.delta_Rx_left, self.delta_Rx_right) # The state prepare callback can be used to change the state before execution of any other commands # One could e.g. use the hamiltonian API to change interaction parameters instead of relying only on the input file if self.state_prepare_callback: self.state_prepare_callback(self, p_state) # Before we run we must make sure that the chain.ovf file exists now if not os.path.exists(self.chain_file): raise Exception("Chain file does not exist!") if self.path_shortening_constant > 0: parameters.gneb.set_path_shortening_constant( p_state, self.path_shortening_constant) # Read the file io.chain_read(p_state, self.chain_file) # Set image types for idx_image, image_type in self.image_types: self.log("Set type of image {} to {}".format( idx_image, image_type)) parameters.gneb.set_climbing_falling(p_state, image_type, idx_image)
def run_simulation(i_state, Mtd, Slvr, convThr, tS, K, Kdir, Exchange, DMI, Dij, alphaD, x_size, y_size, read_config, lc): Skyrmion_size = 0 calc_ittr = 0 js = 0 # current value STTdir = [0, 0, 0] # polarization direction hdir = [0.0, 0.0, 1.0] # magnetic Field direction hval = 0 sim_count = 0 load_fname = 'start.ovf' startup = True while True: clear_screen() if startup: # load initial state or set up new state #initialize ddi usr_in = collect_input(int, 'Load state from file (0/1)?: ') if usr_in == 1: load_fname = collect_input(str, 'Enter filename to load: ') print('\nLoading {:s}...\n'.format(load_fname)) io.chain_read(i_state, load_fname) print('Done!\n') startup = False continue #end if startup block usr_in = collect_input( str, 'Enter command:\nl to load\nm to minimize\nr to run simulation\np to plot\nmtd for set method\nq to quit\n' ) print('\n') if usr_in == 'l': clear_screen() usr_in = collect_input( int, 'Create or ammend to state, Load state from file, or exit (0/1/-1)?: ' ) if usr_in == 1: load_fname = collect_input(str, 'Enter filename to load: ') print('\nLoading {:s}...\n'.format(load_fname)) io.chain_read(i_state, load_fname) print('Done!\n') elif usr_in == 0: usr_in = collect_input( int, 'Set state None, Random, skyrmion, plus-z, minus-z, other settings (0/1/2/3/4/5): ' ) #initialize initial conditions of simulation print('Setting up initial state...\n') if not read_config: #if config file was set, dont set custom lattice size or BC hamiltonian.set_dmi(i_state, 1, [DMI], 1) geometry.set_n_cells(i_state, [x_size, y_size, 1]) hamiltonian.set_boundary_conditions(i_state, [1, 1, 0]) parameters.llg.set_temperature(i_state, 0.0) parameters.llg.set_damping(i_state, alphaD) parameters.llg.set_convergence(i_state, convThr) parameters.llg.set_output_configuration(i_state, True, True, 4) hamiltonian.set_field(i_state, hval, hdir) parameters.llg.set_stt(i_state, True, 0, STTdir) parameters.llg.set_timestep(i_state, tS) parameters.llg.set_iterations(i_state, 1, 1) #hamiltonian.set_dmi(i_state,1,[40],chirality=2) if usr_in == 1: print('Initilizing random state...\n') configuration.random(i_state) #initialize random pass elif usr_in == 2: Skyrmion_size = collect_input(int, "Enter Skyrmion size: ") phase = collect_input(float, 'Enter Skyrmion phase: ') anti = collect_input(int, 'Antiskyrmion or skyrmion (0/1)?: ') pos = [0, 0, 0] for i in range(len(pos)): pos[i] = collect_input( int, 'Enter position {:d} for skyrmion (keep z = 0): '. format(i + 1)) print('Initilizing Skyrmion...\n') configuration.skyrmion(i_state, Skyrmion_size, 1, phase, False, anti, pos) #initialize skyrmion if os.path.isfile("start.ovf"): os.remove("start.ovf") pass pass elif usr_in == 3: print('Setting all spins to +z...\n') configuration.plus_z(i_state) pass elif usr_in == 4: print('Setting all spins to -z...\n') configuration.minus_z(i_state) elif usr_in == 5: convThr = collect_input( float, 'enter Value for convergance threshold (default is 1e-12): ' ) #end load block elif usr_in == 'p': usr_in = 1 while usr_in == 1: usr_in = collect_input(int, '-1 to exit, 1 to plot.') if usr_in == 1: usr_in = input("enter file name to plot: ") xs = collect_input(int, 'x = ') ys = collect_input(int, 'y = ') plot_out.Plot_Lattice(usr_in, xs, ys) usr_in = 1 #end plotting block elif usr_in == 'm': clear_screen() sim_count = 0 usr_in = 0 while usr_in != -1: usr_in = collect_input(int, 'preform minimization?(-1/1): ') if usr_in == 1: sim_time = collect_input(float, 'set minimize time in fs: ') calc_ittr = int(sim_time * 0.001 / tS) #n_fs * fs/(dt*ps) hval = collect_input( float, 'enter H field strength: ') # magnetic Field direction js = 0 hval = convert_from_dimcord_j(DMI, Exchange, js, hval, x_size, y_size, lc)[1] print('H = {:f}T'.format(hval)) parameters.llg.set_temperature(i_state, 0.0) parameters.llg.set_damping(i_state, alphaD) parameters.llg.set_convergence(i_state, convThr) parameters.llg.set_timestep(i_state, tS) hamiltonian.set_field(i_state, hval, hdir) parameters.llg.set_stt(i_state, True, 0, [0, 0, 0]) #minimize print('Minimizing\n') parameters.llg.set_iterations(i_state, calc_ittr, calc_ittr) simulation.start(i_state, simulation.METHOD_LLG, simulation.SOLVER_VP) cur_fname = 'min_{:d}.ovf'.format(sim_count) if os.path.isfile(cur_fname): os.remove(cur_fname) pass io.chain_write(i_state, cur_fname) simulation.stop_all(i_state) plot_out.Plot_Lattice(cur_fname, x_size, y_size) print('Done!\n') sim_count += 1 continue #end minimize block elif usr_in == 'mtd': clear_screen() #set values divider = 2 current_time = collect_input(float, "amount of time to apply current: ") relax_time = collect_input(float, "amount of time to relax: ") begin = collect_input(float, 'enter begining: ') end = collect_input(float, 'enter end: ') count = collect_input(float, 'enter step size: ') current_time = int(current_time * 0.001 / tS) relax_time = int(relax_time * 0.001 / tS) for i, sim_num in enumerate( np.linspace(begin, end, (end - begin) / count, endpoint=True)): configuration.plus_z(i_state) hval = sim_num temp = convert_from_dimcord_j(DMI, Exchange, 0.883, hval, x_size, y_size, lc) hval = temp[1] current = temp[0] print('running set method...\n') #set per-run parameters parameters.llg.set_temperature(i_state, 0) parameters.llg.set_damping(i_state, alphaD) parameters.llg.set_convergence(i_state, convThr) parameters.llg.set_timestep(i_state, tS) #apply current block parameters.llg.set_stt(i_state, True, current, [0, -1, 0]) hamiltonian.set_field(i_state, hval, [0, 0, 1]) calc_ittr = int(6000 * 0.001 / tS) parameters.llg.set_iterations(i_state, calc_ittr / divider, 0) start = time.time() for i in range(1, divider + 1): simulation.start(i_state, Mtd, Slvr) io.chain_write( i_state, '{:d}of{:d}_current_{:4.2f}.ovf'.format( i, divider, hval)) simulation.stop_all(i_state) end = time.time() print(end - start) #turn off current and relax parameters.llg.set_stt(i_state, True, 0, [0, 0, 0]) hamiltonian.set_field(i_state, 16, [0, 0, 1]) calc_ittr = int(6000 * 0.001 / tS) parameters.llg.set_iterations(i_state, relax_time, 0) simulation.start(i_state, Mtd, Slvr) simulation.stop_all(i_state) io.chain_write(i_state, 'current_off_{:4.2f}.ovf'.format(hval)) #end set method elif usr_in == 'r': clear_screen() sim_count = 0 sim_time = 0 prev_ittr = 0 prev_sim_time = 0 calc_ittr = 0 #set per-run parameters parameters.llg.set_temperature(i_state, 0) parameters.llg.set_damping(i_state, alphaD) parameters.llg.set_convergence(i_state, convThr) parameters.llg.set_timestep(i_state, tS) while True: sim_time = collect_input( float, 'set time to run in fs, 0 to use last used values, -1 to exit simulation mode: ' ) if isclose(sim_time, -1, 1e-8): break elif isclose(sim_time, 0, 1e-8): if sim_count == 0: print('Run one simulation first!\n') continue calc_ittr = prev_ittr print( 'H = {:f}T\nJ = {:f}microAmps\nP = ({:f},{:f},{:f})\nItterations = {:d} = {:f}fs' .format(hval, 1e+6 * js, STTdir[0], STTdir[1], STTdir[2], int(prev_ittr), prev_sim_time)) elif (sim_time < (tS / 0.001)) and (not isclose(sim_time, (tS / 0.001), (tS / 0.001) / 10.0)): print('Enter a larger value!\n') continue else: calc_ittr = int(float(sim_time) * 0.001 / tS) #n_fs * fs/(dt*ps) prev_ittr = calc_ittr prev_sim_time = sim_time hval = collect_input( float, 'enter H field strength: ') # magnetic Field direction js = collect_input( float, 'enter current val: ' ) # Spin Torque magnitude EDIT SET TO 0 norm 3e-04 temp = convert_from_dimcord_j(DMI, Exchange, js, hval, x_size, y_size, lc) if isclose(0, js, 1e-7): js = 0.0 else: js = temp[0] hval = temp[1] for i in range(len(STTdir)): STTdir[i] = collect_input( float, 'input Polerization element {:d}: '.format(i + 1)) print( 'H = {:f}T\nJ = {:f}microAmps\nP = ({:f},{:f},{:f})\nItterations = {:d} = {:f}fs' .format(hval, 1e+6 * js, STTdir[0], STTdir[1], STTdir[2], int(prev_ittr), sim_time)) #end quit/re-run/new-sim block print('Running simulation...\n') cur_fname = 'r_{:d}.ovf'.format(sim_count) if os.path.isfile(cur_fname): #if current filename already exists within directory #remove it os.remove(cur_fname) parameters.llg.set_stt(i_state, True, js, STTdir) hamiltonian.set_field(i_state, hval, hdir) parameters.llg.set_iterations(i_state, calc_ittr, 0) start = time.time() simulation.start(i_state, Mtd, Slvr) end = time.time() io.chain_write(i_state, cur_fname) simulation.stop_all(i_state) print('Done! Elapsed time: {:f}\n'.format(end - start)) plot_out.Plot_Lattice(cur_fname, x_size, y_size) sim_count += 1 continue #while not (sim_time == -1): #end run simulation block elif usr_in == 'q': #break and exit loop to quit program break clear_screen() return (0) #run_simulation