def test(): INPUT_FILE = os.path.join(SCRIPT_DIR, "inputs/test_plotting.cfg") from spirit import state, configuration with state.State(INPUT_FILE) as p_state: configuration.plus_z(p_state) configuration.hopfion(p_state, 7) # configuration.skyrmion(p_state, 7) system = data.spin_system_from_p_state(p_state) plotter = pyvista_plotting.Spin_Plotter(system) plotter.camera_position = 'yz' plotter.camera_azimuth = 45 plotter.camera_elevation = 50 # plotter.compute_delaunay() # plotter.save_delaunay("delaunay.vtk") plotter.load_delaunay("delaunay.vtk") # plotter.add_preimage([1,0,0], tol=0.02) plotter.isosurface(0, "spins_z") # plotter.show() plotter.render_to_png("test")
def prepare_moving_endpoints(self, idx_mid=-1): from spirit import chain, io, state, parameters self.log("Preparing for moving endpoints") self.target_noi = 3 self.moving_endpoints = True self.image_types = [[1, parameters.gneb.IMAGE_CLIMBING]] with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.update_energy_path(p_state) noi = chain.get_noi(p_state) if idx_mid < 0: E = chain.get_energy(p_state) idx_mid = np.argmax(E) self.log("idx_mid = {}".format(idx_mid)) if (idx_mid >= 1 and idx_mid < noi - 1): for i in range(idx_mid - 1): chain.delete_image(p_state, idx_image=0) for i in range(noi - idx_mid - 2): chain.pop_back(p_state) self.update_energy_path(p_state) self.save_chain(p_state)
def run(enable_output = True): passed = True field_center = [] E = [] for size in system_sizes: with state.State("") as p_state: parameters.llg.set_output_general(p_state, any=False) #turn ddi on hamiltonian.set_ddi(p_state, 1) #turn everything else off hamiltonian.set_exchange(p_state, 0, []) hamiltonian.set_dmi(p_state, 0, []) hamiltonian.set_anisotropy(p_state, 0, [0,0,1]) hamiltonian.set_boundary_conditions(p_state, [0,0,0]) hamiltonian.set_field(p_state, 0, [0,0,1]) geometry.set_n_cells(p_state, [size, size, 1]) configuration.plus_z(p_state) nos = system.get_nos(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_VP, n_iterations = 1) Gradient_Spirit = np.array(system.get_effective_field(p_state)).reshape(nos, 3) E_Spirit = system.get_energy(p_state) field_center.append(Gradient_Spirit[int(size/2 + size/2 * size)]) E.append(E_Spirit) if enable_output: with open(outputfile, 'w') as out: out.write("#system_size, field_center_z, energy\n") for i in range(len(E)): out.write("{0}, {1}, {2}\n".format(system_sizes[i], field_center[i][2], E[i]))
def run(self): passed = True with state.State(self.inputfile, quiet=True) as p_state: configuration.plus_z(p_state) # simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) system.update_data(p_state) E_Bf, E_Spirit = self.test_energy(p_state) Gradient_Bf, Gradient_Spirit = self.test_gradient(p_state) passed = True print('>>> Result 1: plus_z') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis=0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis=0)) if np.abs(E_Bf - E_Spirit) > 1e-4: passed = False configuration.random(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) system.update_data(p_state) E_Bf, E_Spirit = self.test_energy(p_state) Gradient_Bf, Gradient_Spirit = self.test_gradient(p_state) passed = True print('\n>>> Result 2: random') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis=0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis=0)) if np.abs(E_Bf - E_Spirit) > 1e-4: passed = False configuration.hopfion(p_state, 4) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) system.update_data(p_state) E_Bf, E_Spirit = self.test_energy(p_state) Gradient_Bf, Gradient_Spirit = self.test_gradient(p_state) passed = True print('\n>>> Result 3: hopfion') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis=0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis=0)) if np.abs(E_Bf - E_Spirit) > 1e-4: passed = False return passed
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 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 backup_chain(self, path): """Saves the chain to a file""" from spirit import state, io with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.log("Writing chain to {}".format(path)) io.chain_write(p_state, path, fileformat=self.chain_write_fileformat)
def run(): with state.State("input/input_brute_force.cfg", quiet = True) as p_state: #turn ddi on hamiltonian.set_ddi(p_state, hamiltonian.DDI_METHOD_FFT, [4,4,4], 20) #turn everything else off hamiltonian.set_exchange(p_state, 0, []) hamiltonian.set_dmi(p_state, 0, []) hamiltonian.set_anisotropy(p_state, 0, [0,0,1]) hamiltonian.set_boundary_conditions(p_state, [0,0,0]) hamiltonian.set_field(p_state, 0, [0,0,1]) #set a reasonable amount of basis cells geometry.set_n_cells(p_state, [5,5,5]) configuration.plus_z(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) E_Bf, E_Spirit = test_energy(p_state) Gradient_Bf, Gradient_Spirit = test_gradient(p_state) passed = True print('>>> Result 1: plus_z') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis = 0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis = 0)) if np.abs(E_Bf - E_Spirit) > tolerance: passed = False configuration.random(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) E_Bf, E_Spirit = test_energy(p_state) Gradient_Bf, Gradient_Spirit = test_gradient(p_state) passed = True print('\n>>> Result 2: random') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis = 0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis = 0)) if np.abs(E_Bf - E_Spirit) > tolerance: passed = False configuration.hopfion(p_state, 4) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) E_Bf, E_Spirit = test_energy(p_state) Gradient_Bf, Gradient_Spirit = test_gradient(p_state) passed = True print('\n>>> Result 3: hopfion') print('E (Brute Force) = ', E_Bf) print('E (Spirit) = ', E_Spirit) print('Avg. Grad (Brute Force) = ', np.mean(Gradient_Bf, axis = 0)) print('Avg. Grad (Spirit) = ', np.mean(Gradient_Spirit, axis = 0)) if np.abs(E_Bf - E_Spirit) > tolerance: passed = False return passed
def run(self): passed = True with state.State(self.inputfile1, quiet=True) as p_state: configuration.plus_z(p_state) system.update_data(p_state) E_1 = system.get_energy(p_state) print('>>> Result 1: mu_s = 1') print('E_DDI = ', E_1) with state.State(self.inputfile2, quiet=True) as p_state: configuration.plus_z(p_state) system.update_data(p_state) E_2 = system.get_energy(p_state) print('\n>>> Result 2: mu_s = 2') print('E_DDI = ', E_2) if np.abs(E_1 * 2**2 - E_2) > 1e-1: passed = False return passed
def add_child(self, i1, i2, p_state=None): def _helper(p_state): self.log("Adding child with indices {} and {}".format(i1, i2)) # Attributes that change due to tree structure child_name = self.name + "_{}".format(len(self.children)) child_input_file = self.input_file child_output_folder = self.output_folder + "/{}".format( len(self.children)) self.children += (GNEB_Node( name=child_name, input_file=child_input_file, output_folder=child_output_folder, gneb_workflow_log_file=self.gneb_workflow_log_file, parent=self), ) self.children[ -1].current_energy_path = self.current_energy_path.split( i1, i2 + 1) # Copy the other attributes self.children[-1].target_noi = self.target_noi self.children[-1].convergence = self.convergence self.children[ -1].path_shortening_constant = self.path_shortening_constant self.children[-1].max_total_iterations = self.max_total_iterations self.children[ -1].state_prepare_callback = self.state_prepare_callback self.children[-1].gneb_step_callback = self.gneb_step_callback self.children[-1].exit_callback = self.exit_callback self.children[-1].before_gneb_callback = self.before_gneb_callback self.children[-1].before_llg_callback = self.before_llg_callback self.children[-1].n_iterations_check = self.n_iterations_check self.children[-1].n_checks_save = self.n_checks_save self.children[-1].allow_split = self.allow_split self.children[ -1].chain_write_fileformat = self.chain_write_fileformat self.child_indices.append([i1, i2]) # Write the chain file chain_write_between(p_state, self.children[-1].chain_file, i1, i2, fileformat=self.chain_write_fileformat) if p_state: _helper(p_state) else: from spirit import state with state.State(self.input_file) as p_state: self._prepare_state(p_state) _helper(p_state) return self.children[ -1] # Return a reference to the child that has just been added
def test(self): with state.State(cfgfile) as p_state: # Noise configuration.Random(p_state) configuration.Add_Noise_Temperature(p_state, 5) # Homogeneous configuration.PlusZ(p_state) configuration.MinusZ(p_state) configuration.Domain(p_state, [1,1,1]) # Skyrmion configuration.Skyrmion(p_state, 5) # Hopfion configuration.Hopfion(p_state, 5) # Spin Spiral configuration.SpinSpiral(p_state, "Real Lattice", [0,0,0.1], [0,0,1], 30)
def test(self): with state.State(cfgfile) as p_state: # Noise configuration.random(p_state) configuration.add_noise(p_state, 5) # Homogeneous configuration.plus_z(p_state) configuration.minus_z(p_state) configuration.domain(p_state, [1, 1, 1]) # Skyrmion configuration.skyrmion(p_state, 5) # Hopfion configuration.hopfion(p_state, 5) # Spin Spiral configuration.spin_spiral(p_state, "Real Lattice", [0, 0, 0.1], [0, 0, 1], 30)
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 run(self): passed = True l_cube = 100 radius = l_cube / 4 with state.State(self.inputfile, quiet=True) as p_state: configuration.plus_z(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_SIB, n_iterations=1) system.update_data(p_state) #query some quantities nos = system.get_nos(p_state) field = np.array(system.get_effective_field(p_state)).reshape( nos, 3) pos = np.array(geometry.get_positions(p_state)).reshape(nos, 3) spins = np.array(system.get_spin_directions(p_state)).reshape( nos, 3) #get quantitities in sphere center = np.array([l_cube / 2, l_cube / 2, l_cube / 2], dtype=int) idx_in_sphere = np.linalg.norm(pos - center, axis=1) <= radius mu_s = np.array([1 if idx_in_sphere[i] else 0 for i in range(nos)]) # field_bf = self.Gradient_DDI_BF(pos, spins, mu_s) # field_bf_in_sphere = field_bf[idx_in_sphere] field_in_sphere = field[idx_in_sphere] # deviation_sphere = np.std(field_in_sphere - mean_grad_sphere, axis=0) theory = np.array( [0, 0, 1]) * 2 / 3 * self.mu_0 * self.mu_B * self.mu_B * 1e30 print("Mean field = ", np.mean(field / self.mu_B, axis=0)) # print("Mean field (BF) = ", np.mean(field_bf/self.mu_B, axis=0)) print("Mean field in sphere = ", np.mean(field_in_sphere / self.mu_B, axis=0)) # print("Mean field in sphere (BF) = ", np.mean(field_bf_in_sphere/self.mu_B, axis=0)) print("Theory = ", theory) return passed
def collect_chain(self, output_file): from spirit import state, io, chain self.log("Collecting chain in file {}".format(output_file)) if os.path.exists(output_file): os.remove(output_file) 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 with state.State(self.input_file) as p_state: self._prepare_state(p_state) helper(p_state, self) self.log("Done collecting chain in file")
def update_energy_path(self, p_state=None): """Updates the current energy path. If p_state is given we just use that, otherwise we have to construct it first""" self._log = False if p_state: self.current_energy_path = energy_path_from_p_state(p_state) self.noi = self.current_energy_path.noi() else: from spirit import state, chain, simulation with state.State(self.input_file) as p_state: chain.update_data(p_state) self._prepare_state(p_state) simulation.start( p_state, simulation.METHOD_GNEB, self.solver_gneb, n_iterations=1 ) # One iteration of GNEB to get interpolated quantities self.update_energy_path(p_state) self._log = True
def increase_noi(self, p_state=None): """Increases the noi by (roughly) a factor of two until the number of images is at least as large as target_noi""" from spirit import state, chain, transition, io with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.noi = chain.get_noi(p_state) if (self.noi < self.target_noi): self.log( "Too few images ({}). Inserting additional interpolated images" .format(self.noi)) while (self.noi < self.target_noi): transition.homogeneous_insert_interpolated(p_state, 1) self.noi = chain.get_noi(p_state) self.log("Number of images = {}".format(self.noi)) self.save_chain(p_state)
def run(self, enable_output=True): passed = True self.inputfile = "test_cases/input/input_saturated_film.cfg" theory = 0.5 N_ITERATIONS = 1 system_sizes = [10 * (i + 1) for i in range(5)] field_center = [] E = [] for size in system_sizes: with state.State(self.inputfile) as p_state: parameters.llg.set_output_general(p_state, any=False) geometry.set_n_cells(p_state, [size, size, 1]) configuration.plus_z(p_state) nos = system.get_nos(p_state) simulation.start(p_state, simulation.METHOD_LLG, simulation.SOLVER_VP, n_iterations=1) Gradient_Spirit = np.array( system.get_effective_field(p_state)).reshape(nos, 3) E_Spirit = system.get_energy(p_state) field_center.append(Gradient_Spirit[int(size / 2 + size / 2 * size)]) E.append(E_Spirit) if enable_output: with open('output_' + self.name + '.txt', 'w') as out: out.write("#system_size, field_center_z, energy\n") for i in range(len(E)): out.write("{0}, {1}, {2}\n".format(system_sizes[i], field_center[i][2], E[i]))
def prepare_dimer(self, idx_left, idx_right=None): from spirit import chain, io, state, parameters if idx_right is None: idx_right = idx_left + 1 self.log("Preparing for dimer endpoints") self.target_noi = 2 self.moving_endpoints = True self.translating_endpoints = True self.image_types = [] with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.update_energy_path(p_state) noi = chain.get_noi(p_state) self.log("idx_left = {}, idx_right = {}".format( idx_left, idx_right)) # Delete all images to the right of idx right for i in range(noi - idx_right - 1): chain.pop_back(p_state) # Delete all images to the left of idx_left for i in range(idx_left): chain.delete_image(p_state, idx_image=0) # Delete images between idx_left and idx_right for i in range(idx_right - idx_left - 1): chain.delete_image(p_state, idx_image=1) self.update_energy_path(p_state) self.save_chain(p_state)
sample_temperatures, np.linspace(Ta + 0.5 * T_step, Tb - 0.5 * T_step, num=int(n_temperatures - (n_temperatures / 4) * 2))) sample_temperatures = np.append( sample_temperatures, np.linspace(Tb + 0.5 * T_step, T_end, num=int(n_temperatures / 4))) energy_samples = [] magnetization_samples = [] susceptibility_samples = [] specific_heat_samples = [] binder_cumulant_samples = [] cfgfile = "ui-python/input.cfg" # Input File with state.State(cfgfile) as p_state: # State setup # Set parameters hamiltonian.set_field(p_state, 0.0, [0, 0, 1]) hamiltonian.set_exchange(p_state, Jij, [1.0]) hamiltonian.set_dmi(p_state, 0, []) parameters.mc.set_output_general(p_state, any=False) # Disallow any output geometry.set_mu_s(p_state, 1.0) geometry.set_n_cells(p_state, [system_size, system_size, system_size]) NOS = system.get_nos(p_state) # Ferromagnet in z-direction configuration.plus_z(p_state) # configuration.Random(p_state)
def clamp_and_refine(self, convergence=None, max_total_iterations=None, idx_max_list=None, apply_ci=True, target_noi=5): """One step of clamp and refine algorithm""" if target_noi % 2 == 0: raise Exception("target_noi must be uneven!") if not convergence: convergence = self.convergence if not max_total_iterations: max_total_iterations = self.max_total_iterations try: from spirit import state if (len(self.children) != 0): # If not a leaf node call recursively on children for c in self.children: c.clamp_and_refine(convergence, max_total_iterations, idx_max_list, apply_ci, target_noi) return self.update_energy_path() # To get a list of the "interesting" images we compute the second derivative of the energy wrt to Rx # We initialize these lists with a dummy element so the idx counting is not offset by one second_deriv = [0] # second derivative first_deriv_fw = [0] # first derivative forward first_deriv_bw = [0] # first derivative backward E = self.current_energy_path.total_energy Rx = self.current_energy_path.reaction_coordinate for idx in range(1, self.current_energy_path.noi() - 1): # idx=0 and idx=noi-1 excluded! grad_forward = (E[idx + 1] - E[idx]) / (Rx[idx + 1] - Rx[idx]) grad_backward = (E[idx] - E[idx - 1]) / (Rx[idx] - Rx[idx - 1]) second = 2 * (grad_forward - grad_backward) / (Rx[idx + 1] - Rx[idx - 1]) first_deriv_fw.append(grad_forward) first_deriv_bw.append(grad_backward) second_deriv.append(second) # If not specified, build the idx_max list if not idx_max_list: idx_max_list = [] idx = 1 while idx < self.current_energy_path.noi() - 1: if first_deriv_fw[idx] < 0 and first_deriv_bw[ idx] > 0.01 * first_deriv_fw[idx]: idx_max_list.append(idx) idx += 1 # If we add something to idx_max list we increment the idx so that we do not also add the point right after that idx += 1 self.log("Clamp and refine! idx_list = {}".format(idx_max_list)) for idx_max in idx_max_list: if (idx_max == 0 or idx_max == self.noi - 1): self.log( "Cannot clamp and refine, since idx_max (= {}) is either 0 or noi-1" .format(idx_max)) return with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.add_child(idx_max - 1, idx_max + 1, p_state) # Attributes, that we dont copy self.children[ -1].allow_split = False # Dont allow splitting for clamp and refine self.children[ -1].path_shortening_constant = -1 # No path shortening for clamp and refine self.children[-1].target_noi = target_noi self.children[-1].convergence = convergence self.children[ -1].max_total_iterations = max_total_iterations if apply_ci and not self._ci: def before_gneb_cb(gnw, p_state): from spirit import parameters self.before_gneb_callback(gnw, p_state) gnw.log("Setting image type") parameters.gneb.set_climbing_falling( p_state, parameters.gneb.IMAGE_CLIMBING, idx_image=int((target_noi - 1) / 2)) self.children[-1]._ci = True else: def before_gneb_cb(gnw, p_state): self.before_gneb_callback(gnw, p_state) self.children[-1].before_gneb_callback = before_gneb_cb self.run_children() except Exception as e: self.log("Exception during 'clamp_and_refine': {}".format( str(e))) # Log the exception and re-raise self.log(traceback.format_exc()) raise e
from subprocess import call call("cp data_x.txt data.txt", shell=True) Run_PovRay_Script("Show_Spins", 1000, 1000) call("cp Show_Spins.png spins_x.png", shell=True) call("cp data_y.txt data.txt", shell=True) Run_PovRay_Script("Show_Spins", 1000, 1000) call("cp Show_Spins.png spins_y.png", shell=True) call("cp data_z.txt data.txt", shell=True) Run_PovRay_Script("Show_Spins", 1000, 1000) call("cp Show_Spins.png spins_z.png", shell=True) call("rm -f Data.txt Show_Spins.png", shell=True) cfgfile = "input/input.cfg" # cfgfile = "input/markus-paper.cfg" # cfgfile = "input/gideon-master-thesis-anisotropic.cfg" # cfgfile = "input/daniel-master-thesis-isotropic.cfg" with state.State(cfgfile) as p_state: ### Setup initial configurations configurations(p_state) ### Run simulations simulations(p_state) ### Evaluate the results # evaluations(p_state) ### Create snapshots of the system # snapshots(p_state)
def main(): in_var = 0 config_fname = '' #initial parameters x_size = 0 y_size = 0 Mtd = 1 convThr = 1e-12 # Convergence condition tS = 1e-4 # LLG time step k_val = 0.0 # Anisotropy Kdir = [0.0, 0.0, 1.0] # Anisotropy direction Exchange_mm = 18.16 DMI_mm = 1.87 Dij = [] lc = 6.0 symmetry = 4 print('Welcome to spirit sandbox.\n') while in_var != -1: # TODO: remove from loop read_config = collect_input(int, 'read in a config file?(0/1): ') if read_config == 1: config_fname = input('enter config your_file_name.txt: ') in_var = collect_input( int, 'Generate new r_pos, h, and anisotropy file (0/1)?: ') if in_var == 1: x_size = collect_input(int, 'x lattice size: ') y_size = collect_input(int, 'y lattice size: ') #set lattice constant with file_parser.Parse_File('gen_config.txt') as fp: lc = fp.file_readline(None, 'lattice_constant') lc = float(lc.split()[1]) #update bravis vector with file_parser.Parse_File('gen_config.txt') as fp: line_num = fp.find_line_number('bravais_vectors') fp.write_to_file('bravais_vectors\n', line_num) fp.write_to_file('{:d} 0 0\n'.format(x_size)) fp.write_to_file('0 {:d} 0\n'.format(y_size)) fp.write_to_file('0 0 1\n') generate_configs.gen_r_pos(x_size, y_size) in_var = collect_input(int, 'Use a custom DMI (0/1)?: ') if in_var == 1: # TODO: add lc / 10 for dmi and exchange for lattice scale DMI_mm = collect_input(float, 'Enter value for DMI: ') DMI_atom = float( DMI_mm * 1.602e+04 * lc / 10.0) / float(symmetry) Exchange_mm = collect_input(float, 'Enter value for Exchange: ') Exchange_atom = float(Exchange_mm * 1.602e+13 * lc / 10.0) / float(2 * symmetry) print('DMI = {:5f}\nExchange = {:9.8f}'.format( DMI_atom, Exchange_atom)) with file_parser.Parse_File('gen_config.txt') as fp: fp.set_config_var('#DMI', '{:<8.5f}\n'.format(DMI_mm)) fp.set_config_var('#EXCHANGE', '{:<18.17f}\n'.format(Exchange_mm)) fp.set_config_var('interaction_pairs_file', 'h.txt\n') #read periodic boundary conditions with file_parser.Parse_File(config_fname) as fp: bc = fp.file_readline(None, 'boundary_conditions').split() generate_configs.gen_h_file(x_size, y_size, Exchange_atom, DMI_atom, int(bc[1]), int(bc[2])) else: with file_parser.Parse_File('gen_config.txt') as fp: fp.set_config_var('interaction_pairs_file', '.\n') in_var = collect_input(int, 'Use a custom anis (0/1)?: ') if in_var == 1: in_var = collect_input( int, 'Use random or pattern generated anisotropy (0/1)?: ') if in_var == 1: pattern = input( 'Enter math expression here in terms of x\nEnter an integer for a box: ' ) width = collect_input(int, 'Enter width of pattern: ') k_val = collect_input(float, 'Enter K value: ') generate_configs.gen_anis_pattern( x_size, y_size, pattern, width, 0.9) elif in_var == 0: k_val = collect_input(float, 'Enter value for K: ') #convert K k_val = k_val * DMI_mm**2 / (4 * Exchange_mm) k_val = k_val * 1.6021766e-05 # J/m^3 -> meV print('K = {:f}\n'.format(k_val)) sigma = collect_input( float, 'Enter value for sigma in percent of K: ') generate_configs.gen_anis_random( x_size, y_size, k_val, sigma) with file_parser.Parse_File('gen_config.txt') as fp: fp.set_config_var('anisotropy_file', 'anisotropy.txt\n') else: with file_parser.Parse_File('gen_config.txt') as fp: fp.set_config_var('anisotropy_file', '.\n') file_parser.concatenate_files('gen_config.txt', 'r_pos.txt', config_fname) #generate new config file #read a config file elif in_var == 0: prev_vals = [] #TODO: complete functionality #Load previously used values to current values from old #config file. Can be modified to add as many values as needed. search = ['#DMI', '#EXCHANGE', 'lattice_constant'] with file_parser.Parse_File(config_fname) as fp: for searchterm in search: cur_line = (fp.file_readline(None, searchterm)).split() prev_vals.append(float(cur_line[1])) # TODO: add object to assign each value in loop and not by name after loop DMI_mm = prev_vals[0] Exchange_mm = prev_vals[1] lc = prev_vals[2] cur_line = fp.file_readline(None, 'bravais_vectors', True) cur_line = cur_line.split() x_size = int(cur_line[0]) cur_line = fp.file_readline() cur_line = cur_line.split() y_size = int(cur_line[1]) print( 'loaded values:\nlattice size: {:f}x{:f}\nDMI_mm: {:f}\nExchange_mm: {:18.17f}\nlattice constant: {:f}\n' .format(x_size, y_size, DMI_mm, Exchange_mm, lc)) #if read_config == 1 alphaD = collect_input(float, 'enter alpha: ') # Damping if read_config: betaD = collect_input(float, 'enter beta: ') with file_parser.Parse_File(config_fname) as fp: fp.set_config_var('llg_beta', str(betaD)) pass else: x_size = collect_input(int, 'x lattice size: ') y_size = collect_input(int, 'y lattice size: ') Slvr = collect_input(int, 'enter solver num(1-4): ') #running quiet = true for less text with state.State(configfile=config_fname, quiet=False) as i_state: sim_script.run_simulation(i_state, Mtd, Slvr, convThr, tS, k_val, Kdir, Exchange_mm, DMI_mm, Dij, alphaD, x_size, y_size, read_config, lc) return (0) #main() TODO: fix this so its not in a loop
def test(self): with state.State(cfgfile) as p_state: pass
def run(self): """Run GNEB with checks after a certain number of iterations""" if (len(self.children) != 0): # If not a leaf node call recursively on children self.run_children() return try: self.log("Running") from spirit import state, simulation, io self._converged = False self.increase_noi() with state.State(self.input_file) as p_state: self._prepare_state(p_state) self.update_energy_path(p_state) # Another callback at which the chain actually exists now, theoretically one could set image types here if self.before_gneb_callback: self.before_gneb_callback(self, p_state) try: self.log("Starting GNEB iterations") n_checks = 0 while (self.check_run_condition()): info = simulation.start( p_state, simulation.METHOD_GNEB, self.solver_gneb, n_iterations=self.n_iterations_check) self.update_energy_path(p_state) self.check_for_minima( ) # Writes the intermediate minima list n_checks += 1 self.total_iterations += info.total_iterations # Log some information self.log("Total iterations = {}".format( self.total_iterations)) self.log(" max.torque = {}".format( info.max_torque)) self.log(" ips = {}".format( info.total_ips)) self.log(" Delta E = {}".format( self.current_energy_path.barrier())) self._converged = info.max_torque < self.convergence self.history.append( [self.total_iterations, info.max_torque]) # Step callback to e.g plot chains if (self.gneb_step_callback): self.gneb_step_callback(self, p_state) # Save the chain periodically if (n_checks % self.n_checks_save == 0): self.save_chain(p_state) # Rebalancing # self.chain_rebalance(p_state) except KeyboardInterrupt as e: self.log("Interrupt during run loop") self.save_chain(p_state) if (self.exit_callback): self.exit_callback(self, p_state) raise e if self.before_llg_callback: self.before_llg_callback(self, p_state) self.update_energy_path(p_state) self.spawn_children(p_state) self.save_chain(p_state) if (self.exit_callback): self.exit_callback(self, p_state) # p_state gets deleted here, it does not have to persist to run the child nodes self.run_children() self.log("Finished!") except Exception as e: self.log("Exception during 'run': {}".format( str(e))) # Log the exception and re-raise self.log(traceback.format_exc()) raise e
def test_log_message(self): with state.State() as p_state: log.send(p_state, log.LEVEL_SEVERE, log.SENDER_ALL, "Test Message")
def test_log_message(self): with state.State() as p_state: log.Send(p_state, 1, 0, "Test Message")
sample_temperatures, np.linspace(6 + 0.5 * T_step, 10 - 0.5 * T_step, num=n_temperatures - (n_temperatures / 4) * 2)) sample_temperatures = np.append( sample_temperatures, np.linspace(10 + 0.5 * T_step, T_end, num=n_temperatures / 4)) energy_samples = [] magnetization_samples = [] susceptibility_samples = [] specific_heat_samples = [] binder_cumulant_samples = [] cfgfile = "ui-python/input.cfg" # Input File with state.State(cfgfile, quiet=True) as p_state: # State setup # Set parameters parameters.mc.setOutputGeneral(p_state, False) # Disallow any output geometry.setNCells(p_state, [system_size, system_size, system_size]) NOS = system.Get_NOS(p_state) # Ferromagnet in z-direction configuration.PlusZ(p_state) # configuration.Random(p_state) # Loop over temperatures for iT, T in enumerate(sample_temperatures): parameters.mc.setTemperature(p_state, T) # Cumulative average variables
### This is only needed if you did not install the package spirit_py_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), "../core/python")) sys.path.insert(0, spirit_py_dir) ### Import Spirit modules from spirit import state from spirit import configuration from spirit import simulation from spirit import hamiltonian from spirit import io cfgfile = "../input/input.cfg" quiet = False with state.State(cfgfile, quiet) as p_state: ### Read Image from file # spinsfile = "input/spins.ovf" # io.image_from_file(state.get(), spinsfile, idx_image=0); ### First image is homogeneous with a skyrmion in the center configuration.plus_z(p_state, idx_image=0) configuration.skyrmion(p_state, 200.0, phase=0.0, idx_image=0) configuration.set_region(p_state, region_id=1, pos=[0, 0, 0], border_rectangular=[100, 100, 1], idx_image=0) hamiltonian.set_field_m(p_state, 200, [0, 0, 1], 0) hamiltonian.set_field_m(p_state, 200, [0, 0, -1], 1) ### LLG dynamics simulation