def comp_force_nodal(self, output, axes_dict):
"""Run the nodal forces calculation based on a tensor.
from publications:
Parameters
----------
self : ForceTensor
A ForceTensor object
output : Output
an Output object (to update)
"""
dim = 2
Time = axes_dict["Time"]
Nt_tot = Time.get_length() # Number of time step
meshsolution_mag = output.mag.meshsolution # Comes from FEMM simulation
# Select the target group (stator, rotor ...)
meshsolution_group = meshsolution_mag.get_group(self.group)
# TODO before: Check if is_same_mesh is True
mesh = meshsolution_group.get_mesh()
# New meshsolution object for output, that could be different from the one inputed
meshsolution = MeshSolution(mesh=[mesh.copy()],
is_same_mesh=True,
dimension=dim)
# Load magnetic flux B and H and mu objects
B_sol = meshsolution_group.get_solution(label="B")
H_sol = meshsolution_group.get_solution(label="H")
mu_sol = meshsolution_group.get_solution(label="\mu")
# Import time vector from Time Data object
if self.is_periodicity_t is not None:
is_periodicity_t = self.is_periodicity_t
is_periodicity_t, is_antiper_t = Time.get_periodicity()
time = Time.get_values(
is_oneperiod=is_periodicity_t,
is_antiperiod=is_antiper_t and is_periodicity_t,
)
# Load magnetic flux B and H of size (Nt_tot, nb_elem, dim) and mu (Nt_tot, nb_elem)
resultB = B_sol.field.get_xyz_along(
"indice",
"time=axis_data",
axis_data={"time": time},
)
indice = resultB["indice"] # Store elements indices
Bx = resultB["comp_x"]
By = resultB["comp_y"]
B = np.stack((Bx, By), axis=2)
resultH = H_sol.field.get_xyz_along(
"indice",
"time=axis_data",
axis_data={"time": time},
)
Hx = resultH["comp_x"]
Hy = resultH["comp_y"]
H = np.stack((Hx, Hy), axis=2)
resultmu = mu_sol.field.get_along(
"indice",
"time=axis_data",
axis_data={"time": time},
)
mu = resultmu["\\mu"]
# Move time axis at the end for clarity purpose
B = np.moveaxis(B, 0, -1)
H = np.moveaxis(H, 0, -1)
mu = np.moveaxis(mu, 0, -1)
# Loop on elements and nodes for nodal forces
f, connect = self.element_loop(mesh, B, H, mu, indice, dim, Nt_tot)
indices_nodes = np.sort(np.unique(connect))
Indices_Point = Data1D(name="indice",
values=indices_nodes,
is_components=True)
# Time axis goes back to first axis
f = np.moveaxis(f, -1, 0)
components = {}
fx_data = DataTime(
name="Nodal force (x)",
unit="N",
symbol="Fx",
axes=[Time, Indices_Point],
values=f[..., 0],
)
components["comp_x"] = fx_data
fy_data = DataTime(
name="Nodal force (y)",
unit="N",
symbol="Fy",
axes=[Time, Indices_Point],
values=f[..., 1],
)
components["comp_y"] = fy_data
vec_force = VectorField(name="Nodal forces",
symbol="F",
components=components)
solforce = SolutionVector(field=vec_force, type_cell="node", label="F")
meshsolution.solution.append(solforce)
out_dict = dict()
out_dict["meshsolution"] = meshsolution
return out_dict
def get_meshsolution(self, is_get_mesh, is_save_FEA, save_path, j_t0):
"""Load the mesh data and solution data. FEMM must be working and a simulation must have been solved.
Parameters
----------
self : MagFEMM
a MagFEMM object
is_get_mesh : bool
1 to load the mesh and solution into the simulation
is_save_FEA : bool
1 to save the mesh and solution into a .json file
j_t0 : int
Targeted time step
Returns
-------
res_path: str
path to the result folder
"""
# TODO: Not saving the mesh (only the solution) when the sliding band is activated
idworker = "1" # For parallelization TODO
path_txt = join(MAIN_DIR, "Functions", "FEMM") + "\\"
path_txt_lua = path_txt.replace("\\", "/")
path_lua_in = join(path_txt, "get_mesh_data_FEMM.lua")
path_lua_out = join(save_path, "get_mesh_data_FEMM" + idworker + ".lua")
path_txt_out = save_path + "\\"
path_txt_out = path_txt_out.replace("\\", "/")
# Create a new LUA script with current paths
file_lua = open(path_lua_in, "r")
text_lua = file_lua.read()
file_lua.close()
text_lua = text_lua.replace("my_path_txt", path_txt_out)
text_lua = text_lua.replace("my_id_worker", idworker)
file_lua_out = open(path_lua_out, "w")
file_lua_out.write(text_lua)
file_lua_out.close()
# Run the LUA externally using FEMM LUA console and store the data in the
# temporary text files
path_lua_out2 = path_lua_out.replace("\\", "/")
callfemm('dofile("' + path_lua_out2 + '")')
# Delete the LUA script
os.remove(path_lua_out)
# Read the nodes and elements files
path_node = join(save_path, "nodes" + idworker + ".txt")
path_element = join(save_path, "elements" + idworker + ".txt")
listNd0 = np.loadtxt(path_node, delimiter=" ")
listElem0 = np.loadtxt(path_element, dtype="i", delimiter=" ")
NbNd = len(listNd0)
NbElem = len(listElem0)
# Node list
listNd = np.zeros(shape=(NbNd, 3))
listNd[:, 0] = listNd0[:, 0]
listNd[:, 1] = listNd0[:, 1]
# Element list
# listElem = np.zeros(shape=(NbElem, 3))
listElem = listElem0[:, 0:3] - 1
# Delete text files
os.remove(path_node)
os.remove(path_element)
# Read the results file
path_results = join(save_path, "results" + idworker + ".txt")
results = np.loadtxt(path_results, delimiter=" ")
# Delete text files
os.remove(path_results)
# Save data
if is_get_mesh:
# Create Mesh and Solution dictionaries
mesh = Mesh()
mesh.element = ElementMat(
connectivity=listElem,
nb_elem=NbElem,
group=listElem0[:, 6],
nb_node_per_element=3,
)
mesh.node = NodeMat(coordinate=listNd[:, 0:2], nb_node=NbNd)
solution = SolutionFEMM(B=results[:, 0:2], H=results[:, 2:4], mu=results[:, 4])
meshFEMM = MeshSolution(name="FEMM_magnetic_mesh", mesh=mesh, solution=solution)
if is_save_FEA:
save_path_fea = join(save_path, "meshFEMM" + str(j_t0) + ".json")
meshFEMM.save(save_path_fea)
return meshFEMM
def __init__(
self,
time=None,
angle=None,
Nt_tot=None,
Na_tot=None,
Br=None,
Bt=None,
Tem=None,
Tem_av=None,
Tem_rip=None,
Phi_wind_stator=None,
emf=None,
meshsolution=-1,
FEMM_dict=None,
init_dict=None,
):
"""Constructor of the class. Can be use in two ways :
- __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values
for Matrix, None will initialise the property with an empty Matrix
for pyleecan type, None will call the default constructor
- __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys
ndarray or list can be given for Vector and Matrix
object or dict can be given for pyleecan Object"""
if meshsolution == -1:
meshsolution = MeshSolution()
if init_dict is not None: # Initialisation by dict
check_init_dict(
init_dict,
[
"time",
"angle",
"Nt_tot",
"Na_tot",
"Br",
"Bt",
"Tem",
"Tem_av",
"Tem_rip",
"Phi_wind_stator",
"emf",
"meshsolution",
"FEMM_dict",
],
)
# Overwrite default value with init_dict content
if "time" in list(init_dict.keys()):
time = init_dict["time"]
if "angle" in list(init_dict.keys()):
angle = init_dict["angle"]
if "Nt_tot" in list(init_dict.keys()):
Nt_tot = init_dict["Nt_tot"]
if "Na_tot" in list(init_dict.keys()):
Na_tot = init_dict["Na_tot"]
if "Br" in list(init_dict.keys()):
Br = init_dict["Br"]
if "Bt" in list(init_dict.keys()):
Bt = init_dict["Bt"]
if "Tem" in list(init_dict.keys()):
Tem = init_dict["Tem"]
if "Tem_av" in list(init_dict.keys()):
Tem_av = init_dict["Tem_av"]
if "Tem_rip" in list(init_dict.keys()):
Tem_rip = init_dict["Tem_rip"]
if "Phi_wind_stator" in list(init_dict.keys()):
Phi_wind_stator = init_dict["Phi_wind_stator"]
if "emf" in list(init_dict.keys()):
emf = init_dict["emf"]
if "meshsolution" in list(init_dict.keys()):
meshsolution = init_dict["meshsolution"]
if "FEMM_dict" in list(init_dict.keys()):
FEMM_dict = init_dict["FEMM_dict"]
# Initialisation by argument
self.parent = None
# time can be None, a ndarray or a list
set_array(self, "time", time)
# angle can be None, a ndarray or a list
set_array(self, "angle", angle)
self.Nt_tot = Nt_tot
self.Na_tot = Na_tot
# Br can be None, a ndarray or a list
set_array(self, "Br", Br)
# Bt can be None, a ndarray or a list
set_array(self, "Bt", Bt)
# Tem can be None, a ndarray or a list
set_array(self, "Tem", Tem)
self.Tem_av = Tem_av
self.Tem_rip = Tem_rip
# Phi_wind_stator can be None, a ndarray or a list
set_array(self, "Phi_wind_stator", Phi_wind_stator)
# emf can be None, a ndarray or a list
set_array(self, "emf", emf)
# meshsolution can be None, a MeshSolution object or a dict
if isinstance(meshsolution, dict):
self.meshsolution = MeshSolution(init_dict=meshsolution)
else:
self.meshsolution = meshsolution
self.FEMM_dict = FEMM_dict
# The class is frozen, for now it's impossible to add new properties
self._freeze()
def solve_FEMM(self, output, sym, FEMM_dict):
# Loading parameters for readibilitys
angle = output.mag.angle
L1 = output.simu.machine.stator.comp_length()
Nt_tot = output.mag.Nt_tot # Number of time step
Na_tot = output.mag.Na_tot # Number of angular step
save_path = self.get_path_save(output)
if (hasattr(output.simu.machine.stator, "winding")
and output.simu.machine.stator.winding is not None):
qs = output.simu.machine.stator.winding.qs # Winding phase number
Npcpp = output.simu.machine.stator.winding.Npcpp
Phi_wind_stator = zeros((Nt_tot, qs))
else:
Phi_wind_stator = None
# Create the mesh
femm.mi_createmesh()
# Initialize results matrix
Br = zeros((Nt_tot, Na_tot))
Bt = zeros((Nt_tot, Na_tot))
Tem = zeros((Nt_tot, 1))
lam_int = output.simu.machine.get_lamination(True)
lam_ext = output.simu.machine.get_lamination(False)
Rgap_mec_int = lam_int.comp_radius_mec()
Rgap_mec_ext = lam_ext.comp_radius_mec()
if self.is_get_mesh or self.is_save_FEA:
meshFEMM = [Mesh() for ii in range(Nt_tot)]
solutionFEMM = [Solution() for ii in range(Nt_tot)]
else:
meshFEMM = [Mesh()]
solutionFEMM = [Solution()]
# Compute the data for each time step
for ii in range(Nt_tot):
# Update rotor position and currents
update_FEMM_simulation(
output=output,
materials=FEMM_dict["materials"],
circuits=FEMM_dict["circuits"],
is_mmfs=self.is_mmfs,
is_mmfr=self.is_mmfr,
j_t0=ii,
is_sliding_band=self.is_sliding_band,
)
# try "previous solution" for speed up of FEMM calculation
if self.is_sliding_band:
try:
base = basename(self.get_path_save_fem(output))
ans_file = splitext(base)[0] + ".ans"
femm.mi_setprevious(ans_file, 0)
except:
pass
# Run the computation
femm.mi_analyze()
femm.mi_loadsolution()
# Get the flux result
if self.is_sliding_band:
for jj in range(Na_tot):
Br[ii, jj], Bt[ii,
jj] = femm.mo_getgapb("bc_ag2",
angle[jj] * 180 / pi)
else:
Rag = (Rgap_mec_ext + Rgap_mec_int) / 2
for jj in range(Na_tot):
B = femm.mo_getb(Rag * np.cos(angle[jj]),
Rag * np.sin(angle[jj]))
Br[ii,
jj] = B[0] * np.cos(angle[jj]) + B[1] * np.sin(angle[jj])
Bt[ii,
jj] = -B[0] * np.sin(angle[jj]) + B[1] * np.cos(angle[jj])
# Compute the torque
Tem[ii] = comp_FEMM_torque(FEMM_dict, sym=sym)
if (hasattr(output.simu.machine.stator, "winding")
and output.simu.machine.stator.winding is not None):
# Phi_wind computation
Phi_wind_stator[ii, :] = comp_FEMM_Phi_wind(
qs,
Npcpp,
is_stator=True,
Lfemm=FEMM_dict["Lfemm"],
L1=L1,
sym=sym)
# Load mesh data & solution
if self.is_get_mesh or self.is_save_FEA:
meshFEMM[ii], solutionFEMM[ii] = self.get_meshsolution(
self.is_get_mesh, self.is_save_FEA, save_path, ii)
# Shift to take into account stator position
roll_id = int(self.angle_stator * Na_tot / (2 * pi))
Br = roll(Br, roll_id, axis=1)
Bt = roll(Bt, roll_id, axis=1)
# Store the results
output.mag.Br = Br
output.mag.Bt = Bt
output.mag.Tem = Tem
output.mag.Tem_av = mean(Tem)
if output.mag.Tem_av != 0:
output.mag.Tem_rip = abs(
(np_max(Tem) - np_min(Tem)) / output.mag.Tem_av)
output.mag.Phi_wind_stator = Phi_wind_stator
output.mag.FEMM_dict = FEMM_dict
if self.is_get_mesh:
cond = (not self.is_sliding_band) or (Nt_tot == 1)
output.mag.meshsolution = MeshSolution(
name="FEMM_magnetic_mesh",
mesh=meshFEMM,
solution=solutionFEMM,
is_same_mesh=cond,
)
if self.is_save_FEA:
save_path_fea = join(save_path, "MeshSolutionFEMM.json")
output.mag.meshsolution.save(save_path_fea)
if (hasattr(output.simu.machine.stator, "winding")
and output.simu.machine.stator.winding is not None):
# Electromotive forces computation (update output)
self.comp_emf()
else:
output.mag.emf = None