Skip to content
Snippets Groups Projects
Commit 7dae3d0d authored by Koerber, Lukas (FWIN-C) - 108045's avatar Koerber, Lukas (FWIN-C) - 108045
Browse files

Optimize imports.

parent 8500bb7d
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/tetrax/core/experimental_setup.py
+ 72
− 56
View file @ 7dae3d0d
import numpy as np
import k3d
from ..experiments.relax import minimize_gibbs_free_energy
from ..experiments.eigen import calculate_normal_modes
from ..experiments.calculate_absorption import calculate_absorption
from ..helpers.math import h_U, h_hom, h_CPW, h_strip
import numpy as np
import pygmsh
from ..experiments.calculate_absorption import calculate_absorption
from ..experiments.relax import minimize_gibbs_free_energy
from ..helpers.math import h_hom, h_CPW, h_strip
B_ext_color = 0xED4B42
......@@ -13,7 +13,7 @@ class ExperimentalSetup:
def __init__(self, sample, name="my_experiment"):
self.sample = sample
self._Bext = np.zeros(3*sample.nx)
self._Bext = np.zeros(3 * sample.nx)
self.name = name
self._antenna = None
self._modes_available = False
......@@ -29,7 +29,7 @@ class ExperimentalSetup:
else:
if np.array_equal(self.sample.xyz.shape, np.shape(value)):
self._Bext = value
elif np.shape(value)==(3,):
elif np.shape(value) == (3,):
self._Bext = np.array([value for i in range(self.sample.nx)])
else:
print("You are trying to set an external field which does not match the shape of the mesh.")
......@@ -45,8 +45,6 @@ class ExperimentalSetup:
else:
raise ValueError(f'Input {value} is not of type "MicrowaveAntenna"')
def show(self, comp="vec", scale=5, show_antenna=True):
plot = k3d.plot()
plt_mesh = k3d.mesh(np.float32(self.sample.mesh.points), np.uint32(self.sample.mesh.get_cells_type("triangle")))
......@@ -60,48 +58,62 @@ class ExperimentalSetup:
hx = self._Bext.T[0]
hy = self._Bext.T[1]
hz = self._Bext.T[2]
colors = np.repeat(np.array([(np.uint32(B_ext_color), np.uint32(B_ext_color))]),self.sample.nx)
if comp=="vec":
m_mesh = k3d.vectors(np.float32(self.sample.mesh.points), np.float32(scale*(np.vstack([hx, hy, hz] )).T), head_size=2.5*scale,line_width=0.05*scale,colors=colors)
colors = np.repeat(np.array([(np.uint32(B_ext_color), np.uint32(B_ext_color))]), self.sample.nx)
if comp == "vec":
m_mesh = k3d.vectors(np.float32(self.sample.mesh.points),
np.float32(scale * (np.vstack([hx, hy, hz])).T), head_size=2.5 * scale,
line_width=0.05 * scale, colors=colors)
else:
comp_dict = {"x": hx, "y": hy, "z" : hz, "phi" : np.arctan2(hy,hx), "abs" : np.sqrt(hx**2 + hy**2 + hz**2)}
color_dict = {"abs" : k3d.colormaps.matplotlib_color_maps.Inferno,"x": k3d.colormaps.matplotlib_color_maps.RdBu, "y": k3d.colormaps.matplotlib_color_maps.RdBu, "z" : k3d.colormaps.matplotlib_color_maps.RdBu, "phi" : k3d.colormaps.matplotlib_color_maps.Twilight_shifted}
comp_dict = {"x": hx, "y": hy, "z": hz, "phi": np.arctan2(hy, hx),
"abs": np.sqrt(hx ** 2 + hy ** 2 + hz ** 2)}
color_dict = {"abs": k3d.colormaps.matplotlib_color_maps.Inferno,
"x": k3d.colormaps.matplotlib_color_maps.RdBu,
"y": k3d.colormaps.matplotlib_color_maps.RdBu,
"z": k3d.colormaps.matplotlib_color_maps.RdBu,
"phi": k3d.colormaps.matplotlib_color_maps.Twilight_shifted}
# TODO check if comp is valid key
m_mesh = k3d.mesh(np.float32(self.sample.mesh.points), np.uint32(self.sample.mesh.get_cells_type("triangle")),attribute=comp_dict[comp],color_map=color_dict[comp],interpolation=False, side="double", flat_shading=True, name="$m_{{}}$".format(comp))
m_mesh = k3d.mesh(np.float32(self.sample.mesh.points),
np.uint32(self.sample.mesh.get_cells_type("triangle")), attribute=comp_dict[comp],
color_map=color_dict[comp], interpolation=False, side="double", flat_shading=True,
name="$m_{{}}$".format(comp))
plot += m_mesh
else:
anchor = 1.5* np.max(self.sample.xyz)
anchor = 1.5 * np.max(self.sample.xyz)
plt_text = k3d.text2d('B_{ext} = 0',
position=[0,0],
color=B_ext_color, size=1)
position=[0, 0],
color=B_ext_color, size=1)
plot += plt_text
if self._antenna is not None and show_antenna:
span = np.max(np.abs(self.sample.xyz.T[0]))*2
span = np.max(np.abs(self.sample.xyz.T[0])) * 2
antenna_mesh = self._antenna.get_mesh(span)
plot += k3d.mesh(np.float32(antenna_mesh.points), np.uint32(antenna_mesh.get_cells_type("triangle")),color=0xFFD700, side="double")
plot += k3d.mesh(np.float32(antenna_mesh.points), np.uint32(antenna_mesh.get_cells_type("triangle")),
color=0xFFD700, side="double")
plot.display()
def relax(self, tol=1e-12,continue_least_with_squares=False, return_last=False):
def relax(self, tol=1e-12, continue_least_with_squares=False, return_last=False):
# TODO check if sample has magnetization
if self.sample.mag is None:
print("Your sample does not have a magnetization field yet.")
else:
self.sample.mag = minimize_gibbs_free_energy(self.sample, self._Bext, tol_cg=tol,return_last=return_last, continue_least_with_squares=continue_least_with_squares)
self.sample.mag = minimize_gibbs_free_energy(self.sample, self._Bext, tol_cg=tol, return_last=return_last,
continue_least_with_squares=continue_least_with_squares)
def eigenmodes(self,kmin=-40e6, kmax=40e6, Nk=81, num_modes=20, k=None, no_dip=False,num_cpus=1, save_modes=True,save_local=False, save_magphase=False):
def eigenmodes(self, kmin=-40e6, kmax=40e6, Nk=81, num_modes=20, k=None, no_dip=False, num_cpus=1, save_modes=True,
save_local=False, save_magphase=False):
if self.sample.mag is None:
print("Your sample does not have a magnetization field yet.")
else:
dispersion = self.sample.eigensolver(self.sample,self.Bext, self.name, kmin, kmax, Nk, num_modes, k, no_dip,num_cpus,save_modes,save_local, save_magphase)
dispersion = self.sample.eigensolver(self.sample, self.Bext, self.name, kmin, kmax, Nk, num_modes, k,
no_dip, num_cpus, save_modes, save_local, save_magphase)
self._modes_available = save_modes
self.dispersion = dispersion
return dispersion
def absorption(self, auto_eigenmodes=False, fmin=0, fmax=30, Nf=200, k = None):
def absorption(self, auto_eigenmodes=False, fmin=0, fmax=30, Nf=200, k=None):
if self.sample.mag is None:
print("Your sample does not have a magnetization field yet.")
else:
......@@ -112,9 +124,10 @@ class ExperimentalSetup:
if self._modes_available is False and auto_eigenmodes is True:
print("Calculating eigenmodes first.")
self.dispersion = self.eigenmodes(save_modes=True, k = k)
self.dispersion = self.eigenmodes(save_modes=True, k=k)
print("Calculating absorption.")
power_map = calculate_absorption(self.sample, self.name, self.dispersion, self._antenna, fmin, fmax,Nf,k)
power_map = calculate_absorption(self.sample, self.name, self.dispersion, self._antenna, fmin, fmax, Nf,
k)
print("Done.")
return power_map
if self._modes_available is True and auto_eigenmodes is True:
......@@ -122,7 +135,8 @@ class ExperimentalSetup:
if self._modes_available is True and auto_eigenmodes is False:
print("Calculating absorption.")
power_map = calculate_absorption(self.sample, self.name, self.dispersion, self._antenna, fmin, fmax,Nf,k)
power_map = calculate_absorption(self.sample, self.name, self.dispersion, self._antenna, fmin, fmax, Nf,
k)
print("Done.")
return power_map
......@@ -160,19 +174,20 @@ class StriplineAntenna(MicrowaveAntenna):
self.spacing = spacing
self.k_spectrum = h_strip
def get_mesh(self,span):
x0 = [-span/2, self.spacing-2.5,-self.width/2]
def get_mesh(self, span):
x0 = [-span / 2, self.spacing - 2.5, -self.width / 2]
with pygmsh.occ.Geometry() as geom:
geom.add_box(x0, [span,5,self.width],self.width)
geom.add_box(x0, [span, 5, self.width], self.width)
mesh = geom.generate_mesh()
return mesh
def get_microwave_field_function(self,xyz):
def get_microwave_field_function(self, xyz):
x_ = xyz.T[0]
antenna_func = lambda k: h_strip(k, 1, self.width, np.abs(x_ - self.spacing))
antenna_field_func = lambda k : np.array([np.zeros_like(x_), antenna_func(k), antenna_func(k)]).flatten()
antenna_field_func = lambda k: np.array([np.zeros_like(x_), antenna_func(k), antenna_func(k)]).flatten()
return antenna_field_func
class CPWAntenna(MicrowaveAntenna):
def __init__(self, width, gap, spacing):
......@@ -182,24 +197,24 @@ class CPWAntenna(MicrowaveAntenna):
self.spacing = spacing
self.k_spectrum = h_CPW
def get_mesh(self,span):
def get_mesh(self, span):
with pygmsh.occ.Geometry() as geom:
geom.add_box([-span/2, self.spacing-2.5,-self.width*1.5-self.gap],
[span,5,self.width],
geom.add_box([-span / 2, self.spacing - 2.5, -self.width * 1.5 - self.gap],
[span, 5, self.width],
self.width)
geom.add_box([-span/2, self.spacing-2.5,-self.width/2],
[span,5,self.width],
geom.add_box([-span / 2, self.spacing - 2.5, -self.width / 2],
[span, 5, self.width],
self.width)
geom.add_box([-span/2, self.spacing-2.5,self.width/2+self.gap],
[span,5,self.width],
geom.add_box([-span / 2, self.spacing - 2.5, self.width / 2 + self.gap],
[span, 5, self.width],
self.width)
mesh = geom.generate_mesh()
return mesh
def get_microwave_field_function(self,xyz):
def get_microwave_field_function(self, xyz):
x_ = xyz.T[0]
antenna_func = lambda k: h_CPW(k, 1, self.width, self.gap, np.abs(x_ - self.spacing))
antenna_field_func = lambda k : np.array([np.zeros_like(x_), antenna_func(k), antenna_func(k)]).flatten()
antenna_field_func = lambda k: np.array([np.zeros_like(x_), antenna_func(k), antenna_func(k)]).flatten()
return antenna_field_func
......@@ -207,21 +222,21 @@ class HomogeneousAntenna(MicrowaveAntenna):
def __init__(self, theta=0, phi=0):
self.type = "homogeneous"
self.theta = theta/180 * np.pi
self.phi = phi/180 * np.pi
self.theta = theta / 180 * np.pi
self.phi = phi / 180 * np.pi
def get_mesh(self):
with pygmsh.occ.Geometry() as geom:
#geom.add_box(x0, [span, 5, self.width], self.width)
# geom.add_box(x0, [span, 5, self.width], self.width)
mesh = geom.generate_mesh()
return mesh
def get_microwave_field_function(self, xyz):
x_ = xyz.T[0]
antenna_func = lambda k: h_hom(k, np.ones_like(x_))
antenna_field_func = lambda k: np.array([np.sin(self.theta)*np.cos(self.phi)*antenna_func(k),
np.sin(self.theta)*np.sin(self.phi)*antenna_func(k),
np.cos(self.theta)*antenna_func(k)]).flatten()
antenna_field_func = lambda k: np.array([np.sin(self.theta) * np.cos(self.phi) * antenna_func(k),
np.sin(self.theta) * np.sin(self.phi) * antenna_func(k),
np.cos(self.theta) * antenna_func(k)]).flatten()
return antenna_field_func
......@@ -234,10 +249,10 @@ class CurrentLoopAntenna(MicrowaveAntenna):
def get_mesh(self, span):
with pygmsh.occ.Geometry() as geom:
geom.characteristic_length_min = self.radius*np.pi / 30
geom.characteristic_length_max = self.radius*np.pi / 20
cylinder1 = geom.add_cylinder([0,0,-self.width/2], [0,0,self.width], self.radius+2.5,2*np.pi)
cylinder2 = geom.add_cylinder([0,0,-self.width/2], [0,0,self.width], self.radius-2.5,2*np.pi)
geom.characteristic_length_min = self.radius * np.pi / 30
geom.characteristic_length_max = self.radius * np.pi / 20
cylinder1 = geom.add_cylinder([0, 0, -self.width / 2], [0, 0, self.width], self.radius + 2.5, 2 * np.pi)
cylinder2 = geom.add_cylinder([0, 0, -self.width / 2], [0, 0, self.width], self.radius - 2.5, 2 * np.pi)
geom.boolean_difference(cylinder1, cylinder2)
mesh = geom.generate_mesh()
return mesh
......@@ -245,11 +260,12 @@ class CurrentLoopAntenna(MicrowaveAntenna):
def get_microwave_field_function(self, xyz):
x_ = xyz.T[0]
y_ = xyz.T[1]
rho_ = np.sqrt(x_**2 + y_**2)
rho_ = np.sqrt(x_ ** 2 + y_ ** 2)
phi_ = np.arctan2(y_, x_)
antenna_func = lambda k: h_strip(k, 1, self.width, np.abs(rho_ - self.radius))
#antenna_field_func = lambda k: np.array([np.zeros_like(x_), np.zeros_like(x_), antenna_func(k)]).flatten()
# antenna_field_func = lambda k: np.array([np.zeros_like(x_), np.zeros_like(x_), antenna_func(k)]).flatten()
antenna_field_func = lambda k: np.array([antenna_func(k)*np.cos(phi_), antenna_func(k)*np.sin(phi_), antenna_func(k)]).flatten()
return antenna_field_func
\ No newline at end of file
antenna_field_func = lambda k: np.array(
[antenna_func(k) * np.cos(phi_), antenna_func(k) * np.sin(phi_), antenna_func(k)]).flatten()
return antenna_field_func
src/tetrax/core/operators.py
+ 8
− 7
View file @ 7dae3d0d
from scipy.sparse.linalg import spsolve, LinearOperator, gmres, lgmres, cgs
from scipy.sparse import csr_matrix, dia_matrix, coo_matrix, identity, csc_matrix, diags, bmat
import numpy as np
from scipy.constants import mu_0
import logging
from scipy.constants import mu_0
from scipy.sparse import csr_matrix, diags
from scipy.sparse.linalg import spsolve, LinearOperator, lgmres
from .fem_core.cythoncore import computedensematrix_kdep_py
from ..helpers.math import *
......@@ -148,14 +148,14 @@ class UniAxialAnisotropyOperator(LinearOperator):
self.dtype = np.complex128
def make_sparse_mat(self):
sparse_mat = csr_matrix((3*self.nx, 3*self.nx))
sparse_mat = csr_matrix((3 * self.nx, 3 * self.nx))
# iterate over all anisotropies.
for i, Ku1 in enumerate(self.Ku1_list):
# make a flattened mesh vector Ku1*ones(3*nx) from Ku1 if it is a single number,
# tile (Ku1, Ku1, Ku1) to mesh vector if inhomogeneous (array).
Ku1_array = np.tile(Ku1, 3) if isinstance(Ku1, np.ndarray) else Ku1 * np.ones(3*self.nx)
Ku1_array = np.tile(Ku1, 3) if isinstance(Ku1, np.ndarray) else Ku1 * np.ones(3 * self.nx)
e_u = self.e_u_list[i]
......@@ -171,7 +171,8 @@ class UniAxialAnisotropyOperator(LinearOperator):
# TODO this could be faster by switching the order of things
e_u_normalized = normalize_single_3d_vec(np.array([e_u for i in range(self.nx)])).T.flatten()
sparse_mat += flattened_mesh_vec_tensor_product(-2 * Ku1_array / (mu_0 * self.Msat ** 2) * e_u_normalized, e_u_normalized)
sparse_mat += flattened_mesh_vec_tensor_product(-2 * Ku1_array / (mu_0 * self.Msat ** 2) * e_u_normalized,
e_u_normalized)
return sparse_mat
......
src/tetrax/core/sample.py
+ 10
− 8
View file @ 7dae3d0d
import numpy as np
import meshio
import k3d
from abc import ABC, abstractmethod
import k3d
import meshio
import numpy as np
from .fem_core.cythoncore import get_matrices
from .operators import ExchangeOperator, DipolarOperator, UniAxialAnisotropyOperator, BulkDMIOperator, \
InterfacialDMIOperator
from ..helpers.math import normalize_single_3d_vec
from ..helpers.io import get_mesh_dimension
from ..helpers.io import check_mesh_shape
from ..experiments.eigen import calculate_normal_modes, not_implemented_eigensolver
from ..helpers.io import check_mesh_shape
from ..helpers.io import get_mesh_dimension
from ..helpers.math import normalize_single_3d_vec
class AbstractSample(ABC):
......@@ -65,7 +67,6 @@ class AbstractSample(ABC):
print("Setting geometry and calculating discretized differential operators on mesh.")
self.mesh = mesh
self.xyz = self.mesh.points
self.nx = len(self.xyz)
......@@ -152,7 +153,6 @@ class FerromagnetMixin:
"mesh shape: {}\n".format(self.xyz.shape) + \
"value shape: {}\n".format(np.shape(value)))
def get_magnetic_tensors(self):
self.N_exc = ExchangeOperator(self)
self.N_dip = DipolarOperator(self)
......@@ -303,6 +303,7 @@ class AntiferromagnetMixin:
def show(self):
pass
class PropagatingWaveEigensolverMixin:
def get_eigensolver(self):
self.eigensolver = calculate_normal_modes
......@@ -312,6 +313,7 @@ class ConfinedWaveEigensolverMixin:
def get_eigensolver(self):
self.eigensolver = not_implemented_eigensolver
class ConfinedSampleFM(ConfinedWaveEigensolverMixin, FerromagnetMixin, AbstractSample):
def description(self):
print("I am a ferromagnetic confined sample.")
......
src/tetrax/experiments/eigen.py
+ 8
− 21
View file @ 7dae3d0d
import multiprocessing as mp
import os
from functools import partial
import meshio
import numpy as np
from scipy.sparse import csr_matrix, dia_matrix, coo_matrix, identity, csc_matrix
from scipy.sparse.linalg import LinearOperator, eigsh, aslinearoperator, lgmres, spilu, eigs
from scipy.constants import mu_0
from scipy.optimize import minimize_scalar
import matplotlib
matplotlib.use('Agg')
from scipy.linalg import block_diag
import matplotlib.pyplot as plt
import argparse
import subprocess
import logging
from pathlib import Path
#from tetraeigen_cy import DemagOperator, call_eigensolver
import pandas as pd
import glob
import os
import time
import tqdm
from functools import partial, partialmethod
import multiprocessing as mp
import logging
import meshio
from scipy.constants import mu_0
from scipy.sparse import csc_matrix
from scipy.sparse.linalg import spilu, eigs
from ..core.operators import cross_operator, TotalDynMat, SuperLUInv, InvTotalDynMat
from ..core.fem_core.cythoncore import rotation_matrix_py
from ..core.operators import cross_operator, TotalDynMat, SuperLUInv, InvTotalDynMat
from ..helpers.math import flattened_mesh_vec_scalar_product, diag_matrix_from_vec
......
src/tetrax/experiments/relax.py
+ 30
− 29
View file @ 7dae3d0d
import time
import numpy as np
from scipy.optimize import minimize
from scipy.constants import mu_0
import time
from ..helpers.math import flattened_mesh_vec_scalar_product, spherical_angles_to_mesh_vector
from scipy.optimize import minimize
from scipy.sparse import csr_matrix
from ..helpers.math import flattened_mesh_vec_scalar_product, spherical_angles_to_mesh_vector
def not_implemented_minimizer(sample, Bext,tol_cg, return_last=False, continue_least_with_squares=False):
def not_implemented_minimizer(sample, Bext, tol_cg, return_last=False, continue_least_with_squares=False):
print("This energy minimizer will be implemented in a future release.")
def energy_per_length_spherical(mag_spherical, nx, dA, h_ext, N, N_cub):
# TODO include faster scalar product!
......@@ -17,22 +20,22 @@ def energy_per_length_spherical(mag_spherical, nx, dA, h_ext, N, N_cub):
phi = mag_spherical[-nx:]
# convert to carthesian coordinates
m_x = np.sin(theta)*np.cos(phi)
m_y = np.sin(theta)*np.sin(phi)
m_x = np.sin(theta) * np.cos(phi)
m_y = np.sin(theta) * np.sin(phi)
m_z = np.cos(theta)
mag = np.concatenate((m_x, m_y, m_z))
#print(mag.shape)
#print((h_ext - 0.5 * N.dot(mag)).shape)
#energy_per_volume = -tetramagvec_scalar_product(mag, h_ext + 0.5*N_cub.nonlinear_field(mag) - 0.5 * N.dot(mag)).real
# print(mag.shape)
# print((h_ext - 0.5 * N.dot(mag)).shape)
# energy_per_volume = -tetramagvec_scalar_product(mag, h_ext + 0.5*N_cub.nonlinear_field(mag) - 0.5 * N.dot(mag)).real
energy_per_volume = -flattened_mesh_vec_scalar_product(mag, h_ext - 0.5 * N.dot(mag)).real
return (energy_per_volume*dA).sum()
return (energy_per_volume * dA).sum()
def jac_spherical(mag_spherical, nx, dA, h_ext, N, N_cub):
# TODO include faster scalar product!
#e_per_V = -tetramagvec_scalar_product(mag, h_ext)
# e_per_V = -tetramagvec_scalar_product(mag, h_ext)
# unpack
theta = mag_spherical[:nx]
......@@ -44,35 +47,33 @@ def jac_spherical(mag_spherical, nx, dA, h_ext, N, N_cub):
ct = np.cos(theta)
cp = np.cos(phi)
m_x = np.sin(theta)*np.cos(phi)
m_y = np.sin(theta)*np.sin(phi)
m_x = np.sin(theta) * np.cos(phi)
m_y = np.sin(theta) * np.sin(phi)
m_z = np.cos(theta)
mag = np.concatenate((m_x, m_y, m_z))
h_eff = h_ext - N.dot(mag).real #+ N_cub.nonlinear_field(mag)
h_eff = h_ext - N.dot(mag).real # + N_cub.nonlinear_field(mag)
# TODO include again!
h_x = h_eff[:nx]
h_y = h_eff[nx:-nx]
h_z = h_eff[-nx:]
dm00 = cp*ct
dm01 = -sp*st
dm10 = sp*ct
dm11 = cp*st
dm00 = cp * ct
dm01 = -sp * st
dm10 = sp * ct
dm11 = cp * st
dm20 = -st
dm21 = 0.0
dw_theta = -1*(h_x*dm00 + h_y*dm10 + h_z*dm20)
dw_phi = -1*(h_x*dm01 + h_y*dm11 + h_z*dm21)
dw_theta = -1 * (h_x * dm00 + h_y * dm10 + h_z * dm20)
dw_phi = -1 * (h_x * dm01 + h_y * dm11 + h_z * dm21)
return np.concatenate((dw_theta, dw_phi))
def minimize_gibbs_free_energy(sample, Bext,tol_cg, return_last=False, continue_least_with_squares=False):
#read_tmv_from_project("area.bin", conf)
def minimize_gibbs_free_energy(sample, Bext, tol_cg, return_last=False, continue_least_with_squares=False):
# read_tmv_from_project("area.bin", conf)
nx = sample.nx
# area associated with each node
dA = sample.dA
......@@ -97,8 +98,7 @@ def minimize_gibbs_free_energy(sample, Bext,tol_cg, return_last=False, continue_
N_cub = csr_matrix([])
fac = (sample.Msat * sample.scale) ** 2 * mu_0
#tol_cg = 1e-12
# tol_cg = 1e-12
print_current_spherical = lambda x: print(
"Current energy length density: {:.15e} J/m mx = {:.2f} my = {:.2f} mz = {:.2f}\r".format(
......@@ -111,7 +111,8 @@ def minimize_gibbs_free_energy(sample, Bext,tol_cg, return_last=False, continue_
print(f"Minimizing in using '{starting_method}' (tolerance {tol_cg}) ...")
t_start = time.time()
result = minimize(energy_per_length_spherical, m_ini_spherical, (nx, dA, h_ext, N_tot, N_cub), jac=jac_spherical,
callback=print_current_spherical, method=starting_method, options={"ftol": tol_cg, "gtol": tol_cg})
callback=print_current_spherical, method=starting_method,
options={"ftol": tol_cg, "gtol": tol_cg})
t_end = time.time()
if result.success:
theta = result.x[:nx]
......@@ -120,8 +121,8 @@ def minimize_gibbs_free_energy(sample, Bext,tol_cg, return_last=False, continue_
# convert to carthesian coordinates
m_final = spherical_angles_to_mesh_vector(theta, phi)
#print(m_final.shape)
#print(sample.xyz.shape)
# print(m_final.shape)
# print(sample.xyz.shape)
print("\nSuccess!\n")
return m_final
else:
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

A HIFIS Service | Privacy | Imprint | Support | Documentation | Changelog