def get_data(self):
"""Import mesh and generate MeshMat object
Parameters
----------
self : ImportData
An ImportData object
Returns
-------
mesh: MeshMat
The generated MeshMat object
"""
# Get mesh data (nodes and elements)
if splitext(self.file_path)[1] == ".unv":
nodes, elements = ImportMeshUnv(self.file_path).get_data()
else:
raise Exception(
splitext(self.file_path)[1] + " files are not supported")
# Define MeshMat object
if min(nodes[:, 0]) == 0 and max(nodes[:, 0]) == len(nodes[:, 0]) - 1:
is_renum = False
else:
is_renum = True
mesh = MeshMat(_is_renum=is_renum)
mesh.label = "Imported mesh"
# Define NodeMat object
mesh.node = NodeMat(
coordinate=nodes[:, 1:],
nb_node=nodes.shape[0],
indice=nodes[:, 0],
)
# Define CellMat objects
for elt_type, elt in elements.items():
mesh.cell[elt_type] = CellMat(
connectivity=elt[:, 1:],
nb_cell=elt.shape[0],
nb_node_per_cell=elt.shape[1] - 1,
indice=elt[:, 0],
)
return mesh
def get_group(self, group_names):
"""Return all attributes of a MeshSolution object with only the cells, points
and corresponding solutions of the group. Solutions are converted as SolutionMat.
Parameters
----------
self : MeshSolution
an MeshSolution object
group_name : str
the name of the group (e.g. "stator")
Returns
-------
grp_cells: dict
a dict sorted by cell type containing connectivity of the group
"""
is_same_mesh = self.is_same_mesh
dimension = self.dimension
group_indices = list()
label = ""
is_interface = False
# 1) get the indices of all targeted cell corresponding to group(s)
sep_list = list()
if isinstance(group_names, list):
for grp in group_names:
if grp == "/":
# The groups before and after "/" are stored in different lists
# to perform the interface.
is_interface = True
group_indices_init = group_indices.copy()
group_indices = list()
sep_list.append(group_indices_init)
else:
group_indices.extend(self.group[grp])
label = label + grp + "_"
elif isinstance(group_names, str):
if group_names not in self.group:
raise KeyError(group_names +
" group doesn't exist (available groups: " +
str(list(self.group.keys())) + ")")
group_indices.extend(self.group[group_names])
label = label + group_names
sep_list.append(group_indices)
# 2) extract the corresponding connectivity and create a new mesh
mesh_init = self.get_mesh()
point_init = mesh_init.get_point()
mesh_list = list()
for sep in sep_list:
connect_dict, nb_cell, indice_dict = mesh_init.get_cell(sep)
node_indice = list()
mesh_new = MeshMat()
for key in connect_dict:
node_indice.extend(np.unique(connect_dict[key]))
mesh_new.cell[key] = CellMat(
connectivity=connect_dict[key],
nb_cell=len(connect_dict[key]),
nb_pt_per_cell=mesh_init.cell[key].nb_pt_per_cell,
indice=indice_dict[key],
interpolation=mesh_init.cell[key].interpolation,
)
node_indice = np.unique(node_indice)
mesh_new.point = PointMat(init_dict=mesh_init.point.as_dict())
mesh_new.label = label
mesh_list.append(mesh_new)
# 3) if interface, create the corresponding new mesh (e.g. with triangle mesh,
# it creates only segment cells)
if is_interface:
mesh_interface = mesh_list[0].interface(mesh_list[1])
connect_interface, nb_cell_interf, indices_interf = mesh_interface.get_cell(
)
node_indice_interf = list()
for key in connect_interface:
node_indice_interf.extend(np.unique(connect_interface[key]))
node_indice = np.unique(node_indice_interf)
# 4) select the corresponding solutions
sol_list = list()
for sol in self.solution:
type_cell_sol = sol.type_cell
new_sol = None
if type_cell_sol == "point":
new_sol = sol.get_solution(indice=node_indice)
elif not is_interface: # Interface is only available for point solution.
new_sol = sol.get_solution(indice=indice_dict[type_cell_sol])
if new_sol is not None:
sol_list.append(new_sol)
# 5) Create the corresponding MeshSolution object
if is_interface:
mesh_interface.renum()
mesh = mesh_interface
else:
mesh_new.renum()
mesh = mesh_new
meshsol_grp = self.copy()
meshsol_grp.label = label
meshsol_grp.mesh = [mesh]
meshsol_grp.is_same_mesh = is_same_mesh
meshsol_grp.solution = sol_list
meshsol_grp.dimension = dimension
return meshsol_grp
def get_group(self, group_names):
"""Return all attributes of a MeshSolution object with only the cells, points and corresponding solutions of
the group. Solutions are converted as SolutionMat.
Parameters
----------
self : MeshSolution
an MeshSolution object
group_name : str
the name of the group (e.g. "stator")
Returns
-------
grp_cells: dict
a dict sorted by cell type containing connectivity of the group
"""
is_same_mesh = self.is_same_mesh
dimension = self.dimension
group_indices = list()
label = ""
is_interface = False
# 1) get the indices of all targeted cell corresponding to group(s)
sep_list = list()
if isinstance(group_names, list):
for grp in group_names:
if (
grp == "/"
): # The groups before and after "/" are stored in different lists to perform the interface.
is_interface = True
group_indices_init = group_indices.copy()
group_indices = list()
sep_list.append(group_indices_init)
else:
group_indices.extend(self.group[grp])
label = label + grp + "_"
elif isinstance(group_names, str):
group_indices.extend(self.group[group_names])
label = label + group_names
sep_list.append(group_indices)
# 2) extract the corresponding connectivity and create a new mesh
mesh_init = self.get_mesh()
point_init = mesh_init.get_point()
mesh_list = list()
for sep in sep_list:
connect_dict, nb_cell, indice_dict = mesh_init.get_cell(sep)
node_indice = list()
mesh_new = MeshMat()
for key in connect_dict:
node_indice.extend(np.unique(connect_dict[key]))
mesh_new.cell[key] = CellMat(
connectivity=connect_dict[key],
nb_cell=len(connect_dict[key]),
nb_pt_per_cell=mesh_init.cell[key].nb_pt_per_cell,
indice=indice_dict[key],
interpolation=mesh_init.cell[key].interpolation,
)
node_indice = np.unique(node_indice)
mesh_new.point = PointMat(init_dict=mesh_init.point.as_dict())
mesh_new.label = label
mesh_list.append(mesh_new)
# 3) if interface, create the corresponding new mesh (e.g. with triangle mesh, it creates only segment cells)
if is_interface:
mesh_interface = mesh_list[0].interface(mesh_list[1])
connect_interface, nb_cell_interf, indices_interf = mesh_interface.get_cell(
)
node_indice_interf = list()
for key in connect_interface:
node_indice_interf.extend(np.unique(connect_interface[key]))
node_indice = np.unique(node_indice_interf)
# 4) select the corresponding solutions
sol_list = list()
for sol in self.solution:
label_sol = sol.label
type_cell_sol = sol.type_cell
field_sol = sol.get_field()
axis_name, axis_size = sol.get_axes_list()
if type_cell_sol == "point":
Iindice = np.where(axis_name == "indice")[0]
axis_size[Iindice] = len(node_indice)
new_field_sol = field_sol[:, node_indice, :]
new_sol = SolutionMat(
label=label_sol,
type_cell=type_cell_sol,
field=new_field_sol,
indice=node_indice,
axis_name=axis_name,
axis_size=axis_size,
)
sol_list.append(new_sol)
elif not is_interface: # Interface is only available for point solution.
ind_cell = indice_dict[type_cell_sol]
if "component" in axis_name:
new_field_sol = field_sol[:, ind_cell, :]
else:
new_field_sol = field_sol[:, ind_cell]
axis_size[axis_name.index("indice")] = len(ind_cell)
new_sol = SolutionMat(
label=label_sol,
type_cell=type_cell_sol,
field=new_field_sol,
indice=ind_cell,
axis_name=axis_name,
axis_size=axis_size,
)
sol_list.append(new_sol)
# 5) Create the corresponding MeshSolution object
if is_interface:
mesh_interface.renum()
mesh = mesh_interface
else:
mesh_new.renum()
mesh = mesh_new
meshsol_grp = self.copy()
meshsol_grp.label = label
meshsol_grp.mesh = [mesh]
meshsol_grp.is_same_mesh = is_same_mesh
meshsol_grp.solution = sol_list
meshsol_grp.dimension = dimension
return meshsol_grp
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"):
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:
mesh = [MeshMat() for ii in range(Nt_tot)]
else:
mesh = []
# 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,
)
# 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"):
# 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:
mesh[ii] = self.get_mesh(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.mesh = mesh
if hasattr(output.simu.machine.stator, "winding"):
# Electromotive forces computation (update output)
self.comp_emf()
else:
output.mag.emf = None
def perm_coord(
self,
perm_coord_list=[0, 1, 2],
path_meshVTK=None,
):
"""Returns the current MeshVTK object with permuted coordinates
Parameters
----------
self : MeshVTK
a MeshVTK object
perm_coord_list : list
list of the coordinates to be permuted
path_meshVTK : str
full path to the MeshVTK file
Returns
-------
mesh: MeshVTK
The MeshVTK object with permuted coordinates
"""
# convert into MeshMat object
mesh_mat = self.convert(meshtype="MeshMat", scale=1)
# extract nodes en elements
mesh_mat_node = mesh_mat.get_node()
mesh_mat_cell = mesh_mat.get_cell()
# swap axis
mesh_mat_node = mesh_mat_node.T[perm_coord_list].T
# create new object
# 1. create NodeMat
nb_node = len(mesh_mat_node)
nodemat = NodeMat(coordinate=mesh_mat_node, nb_node=nb_node)
# 2. create CellMat
cellMat = CellMat()
CellMatDict = dict()
for key in mesh_mat_cell[0]:
cellMat = CellMat(
connectivity=mesh_mat_cell[0][key],
nb_cell=len(mesh_mat_cell[0][key]),
)
CellMatDict[key] = cellMat
# 3. create MeshMat
meshmat = MeshMat(cell=CellMatDict, node=nodemat)
# convert and save into vtk
mesh_pv = meshmat.get_mesh_pv()
if path_meshVTK != None:
mesh_pv.save(path_meshVTK)
else:
mesh_pv.save(self.path + "/" + self.name + ".vtk")
self.mesh = mesh_pv
return self