def geom_to_data(g_id, name=None, divide=True):
n = (name if name is not None else str(g_id)) + '.Geom'
pd = PKDict(name=n, id=g_id, data=[])
d = template_common.to_pkdict(radia.ObjDrwVTK(g_id, 'Axes->No'))
n_verts = len(d.polygons.vertices)
c = radia.ObjCntStuf(g_id)
l = len(c)
if not divide or l == 0:
pd.data = [d]
else:
d_arr = []
n_s_verts = 0
# for g in get_geom_tree(g_id):
for g in c:
# for fully recursive array
# for g in get_all_geom(geom):
s_d = template_common.to_pkdict(radia.ObjDrwVTK(g, 'Axes->No'))
n_s_verts += len(s_d.polygons.vertices)
d_arr.append(s_d)
# if the number of vertices of the container is more than the total
# across its elements, a symmetry or other "additive" transformation has
# been applied and we cannot get at the individual elements
if n_verts > n_s_verts:
d_arr = [d]
pd.data=d_arr
return pd
def geom_to_data(geom, name=None, divide=True):
d_arr = []
if not divide:
d_arr.append(
template_common.to_pkdict(radia.ObjDrwVTK(geom, 'Axes->No')))
else:
for g in radia.ObjCntStuf(geom):
# for fully recursive array
# for g in self._get_all_geom(geom):
d_arr.append(
template_common.to_pkdict(radia.ObjDrwVTK(g, 'Axes->No')))
n = name if name is not None else str(geom)
return PKDict(name=n + '.Geom', id=geom, data=d_arr)
def geom_to_data(g_id, name=None, divide=True):
def _to_pkdict(d):
if not isinstance(d, dict):
return d
rv = PKDict()
for k, v in d.items():
rv[k] = _to_pkdict(v)
return rv
n = (name if name is not None else str(g_id)) + '.Geom'
pd = PKDict(name=n, id=g_id, data=[])
d = _to_pkdict(radia.ObjDrwVTK(g_id, 'Axes->No'))
d.update(_geom_bnds(g_id))
n_verts = len(d.polygons.vertices)
c = radia.ObjCntStuf(g_id)
l = len(c)
if not divide or l == 0:
d.id = g_id
pd.data = [d]
else:
d_arr = []
n_s_verts = 0
# for g in get_geom_tree(g_id):
for g in c:
# for fully recursive array
# for g in get_all_geom(geom):
s_d = _to_pkdict(radia.ObjDrwVTK(g, 'Axes->No'))
s_d.update(_geom_bnds(g))
n_s_verts += len(s_d.polygons.vertices)
s_d.id = g
d_arr.append(s_d)
# if the number of vertices of the container is more than the total
# across its elements, a symmetry or other "additive" transformation has
# been applied and we cannot get at the individual elements
if n_verts > n_s_verts:
d.id = g_id
d_arr = [d]
pd.data = d_arr
pd.bounds = radia.ObjGeoLim(g_id)
return pd
def build_model(self):
"""Build a Radia or Opera model with the current result set."""
length = self.length_spinbox.value()
if self.build_button.text() == 'Radia':
rad.UtiDelAll()
item = self.listview.selectedItems()[0]
# build magnet geometry
magnet = rad.ObjCnt([rad.ObjThckPgn(0, length, pg[2:].reshape((4, 2)).tolist(), "z", list(pg[:2]) + [0, ])
for pg in self.state['results'][tuple(item.text().split(', '))]])
rad.MatApl(magnet, rad.MatStd('NdFeB', next(c for c in self.controls if c.switch == 'Br').control.value()))
# plot geometry in 3d
ax = self.plot3d.axes
ax.cla()
ax.set_axis_off()
polygons = rad.ObjDrwVTK(magnet)['polygons']
vertices = np.array(polygons['vertices']).reshape((-1, 3)) # [x, y, z, x, y, z] -> [[x, y, z], [x, y, z]]
[set_lim(vertices.min(), vertices.max()) for set_lim in (ax.set_xlim3d, ax.set_ylim3d, ax.set_zlim3d)]
vertices = np.split(vertices, np.cumsum(polygons['lengths'])[:-1]) # split to find each face
ax.add_collection3d(Poly3DCollection(vertices, linewidths=0.1, edgecolors='black',
facecolors=self.get_colour(), alpha=0.2))
# add arrows
magnetisation = np.array(rad.ObjM(magnet)).reshape((-1, 6)).T # reshape to [x, y, z, mx, my, mz]
for end in (-1, 1): # one at each end of the block, not in the middle
magnetisation[2] = end * length / 2
ax.quiver(*magnetisation, color='black', lw=1, pivot='middle')
self.tab_control.setCurrentIndex(2) # switch to '3d' tab
# solve the model
try:
rad.Solve(magnet, 0.00001, 10000) # precision and number of iterations
except RuntimeError:
self.statusBar().showMessage('Radia solve error')
# get results
dx = 0.1
multipoles = [mpole_names.index(c.label) for c in self.controls if c.label.endswith('pole') and c.get_arg()]
i = multipoles[-1]
xs = np.linspace(-dx, dx, 4)
fit_field = np.polyfit(xs / 1000, [rad.Fld(magnet, 'by', [x, 0, 0]) for x in xs], i)
fit_int = np.polyfit(xs / 1000,
[rad.FldInt(magnet, 'inf', 'iby', [x, 0, -1], [x, 0, 1]) * 0.001 for x in xs], i)
text = ''
for j, (l, c, ic, u, iu) in enumerate(
zip(mpole_names, fit_field[::-1], fit_int[::-1], units[1:], units[:-1])):
if j in multipoles:
f = factorial(j) # 1 for dip, quad; 2 for sext; 6 for oct
text += f'{l} field = {c * f:.3g} {u}, integral = {ic * f:.3g} {iu}, length = {ic / c:.3g} m\n'
ax.text2D(1, 1, text, transform=ax.transAxes, va='top', ha='right', fontdict={'size': 8})
self.plot3d.canvas.draw()
def plot_radia_object(ax, obj, color, matrix):
polygons = rad.ObjDrwVTK(obj, 'Axes->False')['polygons']
lengths = polygons['lengths']
vertices = np.reshape(polygons['vertices'], (-1, 3))
vertices = np.array(transform_points(vertices, matrix))
idx = 0
faces = []
for length in lengths:
faces += [vertices[idx:(idx + length), [0, 2, 1]]]
idx += length
ax.add_collection3d(
Poly3DCollection(faces,
facecolors=[color],
edgecolors=['k'],
linewidth=0.02,
alpha=0.04))
print('Container Content:', rad.ObjCntStuf(mag))
print('Container Size:', rad.ObjCntSize(mag))
rad.ObjAddToCnt(mag, [mag10, mag11])
cnt02 = rad.ObjCnt([mag00, mag])
mat = rad.MatLin([1.01, 1.2], [0, 0, 1.3])
#mat = rad.MatStd('NdFeB', 1.2)
rad.MatApl(mag01, mat)
print('Magn. Material index:', mat, ' appled to object:', mag01)
mag00a = rad.ObjFullMag([10,0,40],[12,18,5],[0,0,1],[2,2,2],cnt02,mat,[0.5,0,0])
rad.ObjDrwOpenGL(cnt02)
data_cnt = rad.ObjDrwVTK(cnt02)
print(data_cnt)
objAfterCut = rad.ObjCutMag(mag00a,[10,0,40],[1,1,1]) #,'Frame->Lab')
print('Indexes of objects after cutting:', objAfterCut)
#rad.ObjDrwOpenGL(objAfterCut[0])
print(rad.UtiDmp(mag01, 'asc'))
print(rad.UtiDmp(mat, 'asc'))
#print(rad.UtiDmp(107, 'asc'))
magDpl = rad.ObjDpl(mag, 'FreeSym->False')
print('Number of objects in the container:', rad.ObjCntSize(mag))
print('Number of objects in 2nd container:', rad.ObjCntSize(cnt02))