def get_bfield(ys, zlocs):
sources = {}
for i in range(11):
if i in range(6, 9):
sources['{}tr'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}br'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}tl'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
sources['{}bl'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
else:
sources['{}r'.format(i)] = Cylmag(
loc=[0, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}l'.format(i)] = Cylmag(
loc=[0, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
C = magpy.Collection()
for sc in sources:
C.addSources(sources[sc])
Y = [[0, y, 0] for y in ys]
BZy = C.getBsweep(Y) # mT
return BZy[:, 2] * 10.0
def PlaceMagnets(self):
self.magnets = []
self.sensors = []
init_linspace = np.linspace(0,self.chain._segment_count-1,num=self.chain._segment_count)
init_pose = self.chain.GetPoints(init_linspace)
init_orient = self.chain.GetOrientations(init_linspace)
final_linspace = np.linspace(1,self.chain._segment_count,num=self.chain._segment_count)
final_pose = self.chain.GetPoints(final_linspace)
final_orient = self.chain.GetOrientations(final_linspace)
for i in range(self.chain._segment_count):
#Put sensor at end of line segment
if(isinstance(self.chain._segments[i],LineSegment)):
self.sensors.append(magpy.Sensor(pos=init_pose[i],axis=[0,1,0],angle=90))
rotvec_orient = init_orient[i].as_rotvec()
if np.array_equal(init_orient[i].apply([1.,0.,0.]),[1.,0.,0.]) is False and np.sum(np.absolute(rotvec_orient)) is not 0:
self.sensors[len(self.sensors)-1].rotate(axis=rotvec_orient,angle=(np.linalg.norm(rotvec_orient)*180)/np.pi)
f
#Put magnet at end of chain
if(isinstance(self.chain._segments[i],CircleSegment)):
self.magnets.append(Box(mag=self.magnetization,dim=self.dimension,pos=final_pose[i],axis=[0,1,0],angle=90))
rotvec_orient = final_orient[i].as_rotvec()
if np.array_equal(final_orient[i].apply([1.,0.,0.]),[1.,0.,0.]) is False and np.sum(np.absolute(rotvec_orient)) is not 0:
self.magnets[len(self.magnets)-1].rotate(axis=rotvec_orient,angle=(np.linalg.norm(rotvec_orient)*180)/np.pi)
self.collection = magpy.Collection(self.magnets)
return self.collection
def clearAll(self):
'''
Required for looping through different shapes
'''
self.data[0].dot_positions.clear()
self.data[0].u_mag_positions.clear()
self.data[0].magnetisation = tuple()
self.data[0].ext_field = tuple()
self.data[0].magnet_collection.qubit_positions = list()
self.data[0].magnet_collection.qubit_positions.clear()
self.data[0].magnet_collection.magnets = list()
self.data[0].magnet_collection.magnets.clear()
self.data[0].magnet_collection.coll = magpy.Collection()
self.data[0].magnet_collection: any = None
return None
#4-coil config coil0 = magpy.source.current.Line(curr=I * 26, vertices=squarePts) coil1 = magpy.source.current.Line(curr=I * 11, vertices=squarePts) coil2 = magpy.source.current.Line(curr=I * 11, vertices=squarePts) coil3 = magpy.source.current.Line(curr=I * 26, vertices=squarePts) coil0.move([0, 0, .5055 * d]) coil1.move([0, 0, .1281 * d]) coil2.move([0, 0, -.1281 * d]) coil3.move([0, 0, -.5055 * d]) #ensuring d=a for homogenous magnetic field from hemoltz coils #s1.move([0,0,a/2.]) #s2.move([0,0,-a/2.]) c = magpy.Collection(coil0, coil1, coil2, coil3) #magpy.displaySystem(c,direc=True) r = [[0, 0, z] for z in np.linspace(-d, d, 100)] r = np.asarray(r) Bfield = c.getB(r) * 10. #convert from mT to guass Bfield = Bfield / (c.getB([0, 0, 0])[2] * 10) print(c.getB([0, 0, 0])[2] * 10) plt.plot(r[:, 2] / d, Bfield[:, 2]) #plot z comp of field along z axis plt.show() # # create positions
def __init__(self):
self.coll = magpy.Collection()
self.magnets = list()
self.qubit_positions = list()
Bcenter = zCoil.getB([0, 0, 0.000001])
print('\nFor "z", getB([0,0,0]) = ', Bcenter, ' mT:')
print('Internal Distance between coil = ', zCoilIntDiameter / 2, ' mm')
print('Coil internal diameter = ', zCoilIntDiameter, ' mm')
print('Coil width = ', (AllCoilsWireDiameter * zLoopsInEachEvenLayer),
'mm')
print('min Coil height = ', (zCoilExtDiameter - zCoilIntDiameter), 'mm')
print('Coil resistence ~= ' + str(zCoilResistence) + ' ohms')
print('Coil power dissipation ~= ' + str(zCoilMaxPower) + ' W')
print('Wire lenght necessary to construct the coil ~= ' +
str(zWireLenghtMeters) + ' m')
singleCoilWidth = 0
connectorsCollection = magpy.Collection()
connectorsCollection = constructAccess(
I=zCoilCurrent,
coilExtDiameter=zCoilExtDiameter,
wireDiameter=AllCoilsWireDiameter,
centralPointBetweenHelmCoils=[0, 0, 0],
lengthBetweenCoils=zCoilIntDiameter / 2,
singleCoilWidth=singleCoilWidth,
helmCoil=connectorsCollection,
relativeDistance=relativeDistance)
# ------------------------------------------------------------------------------------------------------------------------------------------------
#%% DESIGN OF THE SECOND HELMHOLTZ COIL ('y') -----------------------------------------------------------------------------------------------
if YDESIGN:
yCoil, yCoilIntDiameter, yCoilExtDiameter, yCoilResistence, yCoilMaxPower, yWireLenghtMeters = coilDesign(
def coil(color='k',
I=1,
coilIntDiameter=1,
referencePosition=[0, 0, 0],
wireDiameter=1,
loopsInEachEvenLayer=1,
evenLayers=1,
oddLayers=1,
collectionToAdd=magpy.Collection()):
"""
Return the model of a rolled coil around the 'z' axis.
Parameters
----------
I : float
The Coil Current in Amperes.
coilIntDiameter : {non-zero int}
The Diameter of the coil's inner loops, in mm.
referencePosition : List, default [0,0,0]
A List containing 3 coordinates.
wireDiameter : float, default 1
Diameter of the coil wire in mm.
loopsInEachEvenLayer : non-zero integer, default 1
How many loops in a single even layer
evenLayers : integer, default 1
Integer number of even layers.
oddLayers : integer, default 1
Integer number of odd layers.
collectionToAdd : Magpy Collection, default empty
Append coil source to a magpy collection.
Example
---------
test = coil(I = 4, coilIntDiameter = 77.26 , referencePosition=[0,0,0], wireDiameter=1.59,
loopsInEachEvenLayer=3, evenLayers = 3, oddLayers = 3, collectionToAdd = magpy.Collection())
test.displaySystem()
"""
# Initialization for the loop
even = True # Flag if the coil rolling is in even format
singleCoilWidth = wireDiameter * loopsInEachEvenLayer
centerPosition = referencePosition[
2] # The center position of the coil in Z
initPosEven = centerPosition - singleCoilWidth / 2 + wireDiameter / 2 # Initial position in the 'even' form of rolling the coil
initPosOdd = centerPosition - singleCoilWidth / 2 + wireDiameter # Initial position in the 'odd' form of rolling the coil
stepPos = wireDiameter # The position increment
finalPosEven = centerPosition + singleCoilWidth / 2 - wireDiameter / 2 + stepPos # Final position in the 'even' form of rolling the coil
finalPosOdd = centerPosition + singleCoilWidth / 2 - wireDiameter + stepPos # Final position in the 'odd' form of rolling the coil
stepDiameter = 2 * (wireDiameter**2 -
(wireDiameter / 2)**2)**0.5 # The diameter increment
subLoops = np.int64(
singleCoilWidth / wireDiameter
) # The max value of the loops in the 'even' rolling, the odd max value is (subLoops - 1)
coilIntDiameter += wireDiameter
if loopsInEachEvenLayer == 1:
nLoops = evenLayers + oddLayers
else:
nLoops = loopsInEachEvenLayer * evenLayers + (
loopsInEachEvenLayer -
1) * oddLayers # Total number of loops in each coil
# ----------------------------
# Starting to roll the coil
while nLoops > 0: # loop that counts the number of wireLoops already done
if (even == 1) | (
singleCoilWidth == wireDiameter
): # The statement that says if the rolling is in the 'even' or 'odd' form
zs = np.arange(
initPosEven, finalPosEven, stepPos
) # The 'zs' is the variable that will be used for rolling loop position
for n in range(0, subLoops):
coilLoop = magpy.source.current.Circular(curr=I,
dim=coilIntDiameter,
pos=[0, 0, zs[n]])
collectionToAdd.addSources(coilLoop)
nLoops = nLoops - 1
if nLoops <= 0:
break
even = False
coilIntDiameter = coilIntDiameter + stepDiameter
else: # The statement that says if the rolling is in the 'even' or 'odd' form
zs = np.arange(
initPosOdd, finalPosOdd, stepPos
) # The 'zs' is the variable that will be used for rolling loop position
for n in range(0, subLoops - 1):
coilLoop = magpy.source.current.Circular(curr=I,
dim=coilIntDiameter,
pos=[0, 0, zs[n]])
collectionToAdd.addSources(coilLoop)
nLoops = nLoops - 1
if nLoops <= 0:
break
even = True
coilIntDiameter = coilIntDiameter + stepDiameter
return collectionToAdd
#imports import numpy as np import matplotlib.pyplot as plt import magpylib as magpy #create magnets s1 = magpy.source.magnet.Box(mag=[0, 0, 600], dim=[3, 3, 3], pos=[-4, 0, 3]) s2 = magpy.source.magnet.Cylinder(mag=[0, 0, 500], dim=[3, 5]) #manipulate magnets s1.rotate(45, [0, 1, 0], anchor=[0, 0, 0]) s2.move([5, 0, -4]) #create collection c = magpy.Collection(s1, s2) #display system geometry fig1 = c.displaySystem(suppress=True) fig1.set_size_inches(6, 6) #calculate B-field on a grid xs = np.linspace(-10, 10, 30) zs = np.linspace(-10, 10, 30) Bs = np.array([[c.getB([x, 0, z]) for x in xs] for z in zs]) #display field in xz-plane using matplotlib fig2, ax = plt.subplots() X, Z = np.meshgrid(xs, zs) U, V = Bs[:, :, 0], Bs[:, :, 2] ax.streamplot(X, Z, U, V, color=np.log(U**2 + V**2), density=2) plt.show()
# taken from https://magpylib.readthedocs.io/en/latest/_pages/2_guideExamples/ from magpylib.source.magnet import Box import magpylib as magpy # fixed magnet parameters M = [0, 0, 1] #magnetization D = [4, 2, 2] #dimension # magnets with Euler angle orientations s1 = Box(mag=M, dim=D, pos=[-4, 0, 4]) s2 = Box(mag=M, dim=D, pos=[4, 0, 4], angle=45, axis=[0, 0, 1]) s3 = Box(mag=M, dim=D, pos=[-4, 0, -4], angle=45, axis=[0, 1, 0]) s4 = Box(mag=M, dim=D, pos=[4, 0, -4], angle=45, axis=[1, 0, 0]) # collection c = magpy.Collection(s1, s2, s3, s4) # display collection magpy.displaySystem(c, direc=True, figsize=(6, 6))
def get_bfield(ys, zlocs, ylocs, xoffset, oris, return_magnets=False):
sources = {}
M = 6335.0 / (4.0 * 1.26) * np.ones(len(zlocs))
D = 0.50 * 25.4 * np.ones(len(zlocs))
L = 0.75 * 25.4 * np.ones(len(zlocs))
D[[0, 1, 11]] = 0.8 * 25.4
L[[0, 1, 11]] = 0.8 * 25.4
# needs fixing
zoffset = 2.5 / 2 * 25.4 + L / 2.0 # mm, radius of nipple plus half the magnet
if return_magnets:
return (M, D, L)
for i in range(len(zlocs)):
if i in range(6, 9):
sources['{}tr'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], zlocs[i] + zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
sources['{}br'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], zlocs[i] + zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
sources['{}tl'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], -zlocs[i] - zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
sources['{}bl'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], -zlocs[i] - zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
else:
sources['{}r'.format(i)] = Cylmag(
loc=[0, ylocs[i], zlocs[i] + zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
sources['{}l'.format(i)] = Cylmag(
loc=[0, ylocs[i], -zlocs[i] - zoffset[i]],
ori=oris[i],
d=D[i],
l=L[i],
m=M[i])
C = magpy.Collection()
for sc in sources:
C.addSources(sources[sc])
Y = [[0, y, 0] for y in ys]
BZy = C.getBsweep(Y) # mT
return BZy[:, 2] * 10.0
NearFarV = np.asarray(
[[a * np.cos(angles[-1]), a * np.sin(angles[-1]), 0.4 * a],
[a * np.cos(angles[-1]), a * np.sin(angles[-1]), 1.64 * a]])
FarNearV = np.asarray(
[[a * np.cos(angles[0]), a * np.sin(angles[0]), 1.64 * a],
[a * np.cos(angles[0]), a * np.sin(angles[0]), 0.4 * a]])
#collection of wire loops
LCs = []
for i in [I, -I, -I, I]:
arcNearXplus = magpy.source.current.Line(curr=i, vertices=arcNearXplusV)
arcFarXplus = magpy.source.current.Line(curr=i, vertices=arcFarXplusV)
NearFar = magpy.source.current.Line(curr=i, vertices=NearFarV)
FarNear = magpy.source.current.Line(curr=i, vertices=FarNearV)
LCs.append(magpy.Collection(arcNearXplus, NearFar, arcFarXplus, FarNear))
#rotating them to proper positions
LCs[1].rotate(angle=180, axis=[1, 0, 0], anchor=[0, 0, 0])
LCs[2].rotate(angle=180, axis=[0, 0, 1], anchor=[0, 0, 0])
LCs[3].rotate(angle=180, axis=[0, 1, 0], anchor=[0, 0, 0])
c = magpy.Collection(*LCs)
#rotate collection to create Gy gradient instead of Gx
c.rotate(angle=90, axis=[0, 0, 1], anchor=[0, 0, 0])
#print(c.sources)
#magpy.displaySystem(c,direc=True)
# r=[[0,y,0] for y in np.linspace(-a,a,100)]
import magpylib
b = magpylib.source.magnet.Box(mag=[1, 2, 3],
dim=[4, 5, 6],
pos=[7, 8, 9],
angle=90,
axis=(0, 0, 1))
col = magpylib.Collection(b)
col.displaySystem()
def helmholtzCoil(
color='k',
collectionToAdd='NULL',
I=1,
coilIntDiameter=1,
wireDiameter=1,
loopsInEachEvenLayer=1,
evenLayers=1,
oddLayers=1,
coilsDistance=1,
orientation='z',
relativeDistance=0.5,
):
### (_TO DO: make the helmholtz coil do not touch each other_)
"""
Generate and add 2 coils to a collection , with r distance (in mm) between both coils.
Return a colection with the helmholtz coil inside
Parameters
----------
I : float
The Helmhotz Coil Current in Amperes.
coilIntDiameter : float
The internal diameter of the coil in mm
wireDiameter : float, optimizationional
Diameter of the coil wire in mm.
loopsInEachEvenLayer : non-zero integer, default 1
How many loops in a single even layer
evenLayers : integer, default 1
Integer number of even layers.
oddLayers : integer, default 1
Integer number of odd layers.
collectionToAdd : Magpy Collection, default empty
Append coil source to a magpy collection.
coilsDistance : float , default 1
Distance between the coil of the helmholtz coil
orientation : {'x', 'y', 'z'}, optimizationional
Change the orientation of the resulting coil having its center parallel with Plane X, Y, or Z.
*OBS: the odd layers always must be evenLayers -1 or = evenLayers
Example
---------
test = helmholtzCoil(I = 4, coilIntDiameter = 77.26, wireDiameter=1.59,
loopsInEachEvenLayer=3, evenLayers=3, oddLayers=3,
collectionToAdd=magpy.Collection(), coilsDistance = 77.26/2, orientation = 'x')
test.displaySystem()
"""
# seting some values to do the calculations after that
if collectionToAdd == 'NULL':
collectionToAdd = magpy.Collection()
helmoltzRotationCenterXYZ = [0, 0, 0]
singleCoilWidth = wireDiameter * loopsInEachEvenLayer
# doing the inverse rotations to change the helmhotz coil orientation (because this function only create the coil in 'z' orientation)
if orientation == 'y':
collectionToAdd.rotate(90, [1, 0, 0], anchor=helmoltzRotationCenterXYZ)
collectionToAdd.rotate(90, [0, 0, 1], anchor=helmoltzRotationCenterXYZ)
elif orientation == 'x':
collectionToAdd.rotate(-90, [0, 0, 1],
anchor=helmoltzRotationCenterXYZ)
collectionToAdd.rotate(-90, [1, 0, 0],
anchor=helmoltzRotationCenterXYZ)
# ---------------------------------------------------------------------
# construct the two coils of a helmholtz coil ----------------------------------------------------------------------------
collectionToAdd = coil(
I=I,
color=color,
coilIntDiameter=coilIntDiameter,
referencePosition=[0, 0, -coilsDistance / 2 - singleCoilWidth / 2],
wireDiameter=wireDiameter,
loopsInEachEvenLayer=loopsInEachEvenLayer,
evenLayers=evenLayers,
oddLayers=oddLayers,
collectionToAdd=collectionToAdd)
collectionToAdd = coil(
I=I,
color=color,
coilIntDiameter=coilIntDiameter,
referencePosition=[0, 0, coilsDistance / 2 + singleCoilWidth / 2],
wireDiameter=wireDiameter,
loopsInEachEvenLayer=loopsInEachEvenLayer,
evenLayers=evenLayers,
oddLayers=oddLayers,
collectionToAdd=collectionToAdd)
# ------------------------------------------------------------------------------------------------------------------------
'''
# construct the access of supply wires to the two coils of a helmholtz coil ----------------------------------------------
stepRadius = (wireDiameter**2 - (wireDiameter/2)**2)**0.5
coilExtDiameter = coilIntDiameter + (wireDiameter + (evenLayers + oddLayers -1)*stepRadius)*2 # calculate the external diameter of the coil
collectionToAdd = constructAccess(I = I, coilExtDiameter = coilExtDiameter, wireDiameter = wireDiameter,
centralPointBetweenHelmCoils = [0,0,0], lengthBetweenCoils = coilsDistance,
singleCoilWidth = singleCoilWidth, helmCoil = collectionToAdd,
relativeDistance = relativeDistance)
# ------------------------------------------------------------------------------------------------------------------------
'''
# doing the rotations to change the helmhotz coil orientation
if orientation == 'y':
collectionToAdd.rotate(-90, [0, 0, 1],
anchor=helmoltzRotationCenterXYZ)
collectionToAdd.rotate(-90, [1, 0, 0],
anchor=helmoltzRotationCenterXYZ)
elif orientation == 'x':
collectionToAdd.rotate(90, [1, 0, 0], anchor=helmoltzRotationCenterXYZ)
collectionToAdd.rotate(90, [0, 0, 1], anchor=helmoltzRotationCenterXYZ)
# ---------------------------------------------------------------------
return collectionToAdd
def magnet_sim(sources,
manipulation,
axis={
'x': np.linspace(-10, 10, 30),
'y': np.linspace(-10, 10, 30)
},
density=2,
title="Magnetic Simulation",
figsize1=[6, 6],
figsize2=[6, 5],
set_color=lambda U, V: np.log(U**2 + V**2),
supress=True,
ticklabels=[[], []],
rotation=[0, 0],
va=['top', 'top'],
ha=['right', 'right'],
fontsize=[10, 10],
axis_show='on',
xlabel='',
ylabel='',
pad=[10, 10],
which=['major', 'major'],
show=True):
frame = inspect.currentframe().f_back
#manipulation of Magnets
exec(str(manipulation), frame.f_globals, frame.f_locals)
#create collection
magnets_collection = magpy.Collection(*sources)
#display system geometry
fig1 = magnets_collection.displaySystem(suppress=supress)
fig1.set_size_inches(figsize1[0], figsize1[1])
#calculate B-field on a grid
Bfield = np.array([[magnets_collection.getB([x, 0, y]) for x in axis['x']]
for y in axis['y']])
#display field in xz-plane using matplotlib
fig2, ax = plt.subplots()
X, Z = np.meshgrid(axis['x'], axis['y'])
U, V = Bfield[:, :, 0], Bfield[:, :, 2]
fig2.set_size_inches(figsize2[0], figsize2[1])
ax.streamplot(X, Z, U, V, color=set_color(U, V), density=density)
ax.set_title(title)
if ticklabels != [[], []]:
ax.set_xticklabels(ticklabels[0],
rotation=rotation[0],
fontsize=fontsize[0],
va=va[0],
ha=ha[0])
ax.set_yticklabels(ticklabels[1],
rotation=rotation[1],
fontsize=fontsize[1],
va=va[1],
ha=ha[1])
plt.tick_params(axis='x', which=which[0], pad=pad[0])
plt.tick_params(axis='y', which=which[1], pad=pad[1])
plt.axis(axis_show)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
#show plots
if show:
plt.show()
import magpylib
pointToCalculate = [-3, -2,
-1] # Position Vector of the field point to calculate
box = magpylib.source.magnet.Box(mag=[1, 2, 3], dim=[4, 5, 6], pos=[7, 8, 9])
sphere = magpylib.source.magnet.Sphere(
mag=[1, 2, 3],
dim=5,
pos=[-7, -8, -9],
)
col = magpylib.Collection(box,
sphere) ## Make a Collection of 2 source objects
sampleValue = col.getB(
pointToCalculate) ## Field Sample from the 2 item Collection
## Output: [0.02236098 0.02485036 0.02734824]
markerZero = [0, 0, 0] + ["Zero Mark"] ## A Marker On Zero Coordinates
markerSample = pointToCalculate + [str(sampleValue)
] ## A Marker On the Field sample
col.displaySystem(markers=[markerZero, markerSample],
direc=True) ## Direc kwarg shows magnetization
## vector
def desiredCoilDiameter(nIteration=1000,
breakCondition=0.005,
desiredField=1,
initialValue=0,
I=1,
coilIntDiameter=1,
wireDiameter=1,
loopsInEachEvenLayer=3,
evenLayers=3,
oddLayers=3,
orientation='z',
relativeDistance=0.5):
"""
Returns a Collection that is a previous Collection with a twisted pair plus that
*OBS: still have to fix the rotations
Parameters
----------
nIteration : integer
Determine how many iterations the loop will do
breakCondition : float
It's the B - Ba break condition
coilIntDiameterStep : float
The step that the coil diameter tested will increase or decrease
desiredField : float
The field amplitude value that the function will search for
I : float
The Helmhotz Coil Current in Amperes.
coilIntDiameter : float
The internal diameter of the coil in mm (initial value)
wireDiameter : float, optimizationional
Diameter of the coil wire in mm.
loopsInEachEvenLayer : non-zero integer, default 1
How many loops in a single even layer
evenLayers : integer, default 1
Integer number of even layers.
oddLayers : integer, default 1
Integer number of odd layers.
collectionToAdd : Magpy Collection, default empty
Append coil source to a magpy collection.
coilsDistance : float , default 1
Distance between the coil of the helmholtz coil
orientation : {'x', 'y', 'z'}, optimizationional
Change the orientation of the resulting coil having its center parallel with Plane X, Y, or Z.
*OBS: the odd layers always must be evenLayers -1 or = evenLayers
Example
---------
test = twistedPair(diameter = 2, nPoints = 40, nTurns = 4, I = 4, collectionToAdd = magpy.Collection(), referencePosition= [0,0,0], end = [0,0,3])
test.displaySystem()
"""
# Setting the initial values of B and Ba
samplingTime = 100
previousError = 0
previousCoilIntDiameter = initialValue
i = 0
# The iteration loop that will find the correct HelmoltzCoil to get the I desired with B desired together
while (1):
coilIntDiameter = -previousError * samplingTime + previousCoilIntDiameter
if coilIntDiameter < 0.1:
coilIntDiameter = 0.1
#b = WhatTimeIsIt()
# Creates a new helmholtzCoil, to search for the right coilintDiameter value
EmptyCol = magpy.Collection()
Coil = helmholtzCoil(I=I,
coilIntDiameter=coilIntDiameter,
wireDiameter=wireDiameter,
loopsInEachEvenLayer=loopsInEachEvenLayer,
evenLayers=evenLayers,
oddLayers=oddLayers,
collectionToAdd=EmptyCol,
coilsDistance=coilIntDiameter / 2,
orientation=orientation,
relativeDistance=relativeDistance)
# --------------------------------------------------------------------------------------------
#a = WhatTimeIsIt()
#print(a-b)
# Store the B in Ba and calculate the new B
field = Coil.getB([0, 0, 0])
if (orientation == 'z'):
field = field[2]
elif (orientation == 'y'):
field = field[1]
elif (orientation == 'x'):
field = field[0]
else:
field = norm(field)
error = desiredField - field
#print(error)
#print(coilIntDiameter)
previousError = error
previousCoilIntDiameter = coilIntDiameter
i += 1
if i > nIteration:
break
if np.linalg.norm(error) < breakCondition:
break
#print(B)
# -----------------------------------------------------------------------------------------------------
return coilIntDiameter
def twistedPair(diameter=2,
nPoints=40,
nTurns=10,
I=4,
collectionToAdd=magpy.Collection(),
referencePosition=[0, 0, 0],
end=[0, 0, 1]):
"""
Returns a Collection that is a previous Collection with a twisted pair plus that
*OBS: still have to fix the rotations
Parameters
----------
diameter : float
Diameter of the spiral
spiralExtremities : list (float) [2]
The beginning [0], and the end [1] in 'z' orientation of the spiral
nPoints : float
Number of points in the spiral, greater the number, more "realistic" model
of a spiral you get
nTurns : positive integer
Number of the turns that will have in your spiral
I : float
The current amplitude that will create the magnetic field
startingSpiralAng : float (0~180)
It's the starting angle of the spiral
rotationSense : integer (-1,1)
This multiply the angle, so the sense will be positive increasing or negative increasing
referencePosition : list (float) [3]
is the starting point where the spiral will be created, in 'z' orientation
Example
---------
test = twistedPair(diameter = 2, nPoints = 40, nTurns = 4, I = 4, collectionToAdd = magpy.Collection(), referencePosition= [0,0,0], end = [0,0,3])
test.displaySystem()
"""
# Find the rotations angles for the right positioning of the twisted pair ------------------------------
spiralExtremities = np.zeros(2)
spiralExtremities[0] = 0
spiralExtremities[1] = ((end[0] - referencePosition[0])**2 +
(end[1] - referencePosition[1])**2 +
(end[2] - referencePosition[2])**2)**0.5
print(spiralExtremities[1]) # debug
# *OBS: still have to fix the rotations
"""
phi = -np.arccos((end[2] - referencePosition[2])/spiralExtremities[1])
print(phi) # debug
teta = np.arccos((end[0] - referencePosition[0])/spiralExtremities[1]/np.sin(phi))*180/pi
print(teta) # debug
phi = phi*180/pi
# -------------------------------------------------------------------------------------
# Doing the inverse rotations -------------------------------------
collectionToAdd.rotate(-teta,[0,0,1],anchor=referencePosition)
collectionToAdd.rotate(-phi,[1,0,0],anchor=referencePosition)
# -------------------------------------------------------------------------------------
"""
# Doing one spiral in the 'z' positive orientation
spi = spiral(
diameter=diameter,
spiralExtremities=[spiralExtremities[0], spiralExtremities[1]],
nPoints=nPoints,
nTurns=nTurns,
I=I,
startingSpiralAng=0,
referencePosition=referencePosition)
collectionToAdd.addSources(spi)
# Doing the second spiral in the 'z' negative orientation
spi = spiral(
diameter=diameter,
spiralExtremities=[spiralExtremities[1], spiralExtremities[0]],
nPoints=nPoints,
nTurns=nTurns,
I=I,
startingSpiralAng=180,
rotationSense=-1,
referencePosition=referencePosition)
collectionToAdd.addSources(spi)
"""
# Doing the rotations -------------------------------------
collectionToAdd.rotate(phi,[1,0,0],anchor=referencePosition)
collectionToAdd.rotate(teta,[0,0,1],anchor=referencePosition)
# -------------------------------------------------------------------------------------
"""
return collectionToAdd
def plotBxyz(collectionToPlot,
collectionToCompare=magpy.Collection(),
plotBounds=[0, 10, 0, 10],
orientation='z',
orderMagnitude='mT',
fieldDif=False,
figureSize=[10, 8],
nPlotPoints=40,
xyz0=0,
figureTittle='Figure',
compareToCenter=False,
centerToCompare=[0, 0, 0]):
"""
Plot in a 2d (x,z) in a y0 = constant graphic with 2 screens the [module %, angles º(related to the z direction)]
diference of the B in [0,0,0] and the other points of the graphic
Parameters
----------
collectionToPlot : Magpy Collection
The collection used to caculate the plots
plotBounds : float list [4]
its the initial and final X and Z boundaries
plotBound[0] = initialX, plotBound[1] = finalX
plotBound[2] = initialZ, plotBound[3] = finalZ
percent : bool
If True, plot the percent diference relative to the B = [0,0,0] field
If False, plot the true field in every point of the graphic
optimization : bool
If True, plot based in an eliptical line in the screen
If False, plot every point related to the field in each point
figureSize : list(integers) [2]
Define the size of the entire figure
nPlotPoints : integer
Number of point that will be used to plot the figure in each axis
y0 : float
The plot made is an 2d 'z' by 'x', this select where in 'y' the plot will be made
figureTittle : string
Define the entire figure tittle
Example
---------
test = helmholtzCoil(I = 4, coilIntDiameter = 77.26, wireDiameter=1.59,
loopsInEachEvenLayer=3, evenLayers=3, oddLayers=3,
collectionToAdd=magpy.Collection(), coilsDistance = 77.26/2, orientation = 'z')
plotB(collectionToPlot = test, optimization= True, figureTittle = 'Test figure', nPlotPoints = 10, percent = True)
test.displaySystem()
"""
if orderMagnitude == 'uT':
multiplier = 1000
else:
multiplier = 1
# Here creates the screens and name the axis
fig = plt.figure(figsize=(figureSize[0], figureSize[1]), dpi=80)
fig.suptitle(figureTittle, fontsize=16)
if compareToCenter:
AXS = [fig.add_subplot(2, 2, i, axisbelow=True) for i in range(1, 5)]
subPlot1, subPlot2, subPlot3, subPlot4 = AXS
else:
subPlot1 = fig.add_subplot(1, 1, 1, axisbelow=True)
if orientation == 'y':
subPlot1.set_xlabel('x axis (mm)')
subPlot1.set_ylabel('z axis (mm)')
elif orientation == 'x':
subPlot1.set_xlabel('z axis (mm)')
subPlot1.set_ylabel('y axis (mm)')
collectionToPlot.rotate(90, [0, 1, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(90, [0, 1, 0], anchor=[0, 0, 0])
collectionToPlot.rotate(90, [1, 0, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(90, [1, 0, 0], anchor=[0, 0, 0])
elif orientation == 'z':
subPlot1.set_xlabel('y axis (mm)')
subPlot1.set_ylabel('x axis (mm)')
collectionToPlot.rotate(-90, [0, 1, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(-90, [0, 1, 0], anchor=[0, 0, 0])
collectionToPlot.rotate(-90, [0, 0, 1], anchor=[0, 0, 0])
collectionToCompare.rotate(-90, [0, 0, 1], anchor=[0, 0, 0])
# Here the process to create the plot arrays
xs = linspace(plotBounds[0], plotBounds[1], nPlotPoints)
zs = linspace(plotBounds[2], plotBounds[3], nPlotPoints)
X, Z = meshgrid(xs, zs)
# Here the process to take the points of the amplitude error and degree error
Bs = array([[
collectionToPlot.getB([xs[x], xyz0, zs[z]]) for x in range(0, len(xs))
] for z in range(0, len(zs))])
Bs = Bs * multiplier
amp = Bs[:, :, 2]
if fieldDif:
Bs2 = array([[
collectionToCompare.getB([xs[x], xyz0, zs[z]])
for x in range(0, len(xs))
] for z in range(0, len(zs))])
Bs2 = Bs2 * multiplier
if orientation == 'x':
amp2 = Bs2[:, :, 2]
#subPlot1.set_title('shows the % difference\n B1tc and B2tp, relative to B2tp \n(comparition in "y" orientation)')
# shows the 'y' comparation
elif orientation == 'z':
amp2 = Bs2[:, :, 2]
#subPlot1.set_title('shows the % difference\n B1tc and B2tp, relative to B2tp \n(comparition in "x" orientation)')
# shows the 'x' comparation
elif orientation == 'y':
amp2 = Bs2[:, :, 2]
#subPlot1.set_title('shows the % difference\n B1tc and B2tp, relative to B2tp \n(comparition in "z" orientation)')
# shows the 'z' comparation
ampDif = np.abs(amp2 - amp) / amp
subPlot1.contourf(X, Z, ampDif, 10, cmap=plt.cm.jet)
cp = subPlot1.contour(X,
Z,
ampDif,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot1.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
elif compareToCenter:
# calculating the diffence of the the comparing point to the whole map
Bcenter = collectionToPlot.getB(centerToCompare)
Bcenter = Bcenter * multiplier
Bs = array([[
collectionToPlot.getB([xs[x], xyz0, zs[z]])
for x in range(0, len(xs))
] for z in range(0, len(zs))])
Bs = Bs * multiplier
BsNorm = ((Bs[:, :, 0])**2 + (Bs[:, :, 1])**2 + (Bs[:, :, 2])**2)**0.5
BcenterNorm = ((Bcenter[0])**2 + (Bcenter[1])**2 +
(Bcenter[2])**2)**0.5
normDif = (BsNorm - BcenterNorm) / BcenterNorm * 100
# ---------------------------------------------------------------------------
# Here the process to actualy plot int the screen
subPlot1.set_title(
'B vector amplitude Error realative to the "center" (%)')
subPlot1.contourf(X, Z, normDif, 10, cmap=plt.cm.jet)
cp = subPlot1.contour(X,
Z,
normDif,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot1.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
# Here calculate the angle to plot
if orientation == 'y':
subPlot1.set_xlabel('.')
subPlot2.set_xlabel('.')
subPlot2.set_ylabel('z axis (mm)')
subPlot3.set_xlabel('x axis (mm)')
subPlot3.set_ylabel('z axis (mm)')
subPlot4.set_xlabel('x axis (mm)')
subPlot4.set_ylabel('z axis (mm)')
Bsx = Bs[:, :, 0]
Bsy = Bs[:, :, 1]
Bsz = Bs[:, :, 2]
elif orientation == 'x':
subPlot1.set_xlabel('.')
subPlot2.set_xlabel('.')
subPlot2.set_ylabel('y axis (mm)')
subPlot3.set_xlabel('z axis (mm)')
subPlot3.set_ylabel('y axis (mm)')
subPlot4.set_xlabel('z axis (mm)')
subPlot4.set_ylabel('y axis (mm)')
Bsx = Bs[:, :, 1]
Bsy = Bs[:, :, 2]
Bsz = Bs[:, :, 0]
elif orientation == 'z':
subPlot1.set_xlabel('.')
subPlot2.set_xlabel('.')
subPlot2.set_ylabel('x axis (mm)')
subPlot3.set_xlabel('y axis (mm)')
subPlot3.set_ylabel('x axis (mm)')
subPlot4.set_xlabel('y axis (mm)')
subPlot4.set_ylabel('x axis (mm)')
Bsx = Bs[:, :, 2]
Bsy = Bs[:, :, 0]
Bsz = Bs[:, :, 1]
if orderMagnitude == 'uT':
subPlot2.set_title('x component (uT)')
subPlot3.set_title('y component (uT)')
subPlot4.set_title('z component (uT)')
else:
subPlot2.set_title('x component (mT)')
subPlot3.set_title('y component (mT)')
subPlot4.set_title('z component (mT)')
#print(Bs)
subPlot2.contourf(X, Z, Bsx, 10, cmap=plt.cm.jet)
cp = subPlot2.contour(X,
Z,
Bsx,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot2.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
subPlot3.contourf(X, Z, Bsy, 10, cmap=plt.cm.jet)
cp = subPlot3.contour(X,
Z,
Bsy,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot3.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
subPlot4.contourf(X, Z, Bsz, 10, cmap=plt.cm.jet)
cp = subPlot4.contour(X,
Z,
Bsz,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot4.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
else:
if orderMagnitude == 'uT':
subPlot1.set_title('B vector amplitude (uT)')
else:
subPlot1.set_title('B vector amplitude (mT)')
subPlot1.contourf(X, Z, amp, 10, cmap=plt.cm.jet)
cp = subPlot1.contour(X,
Z,
amp,
30,
colors=('k', 'k'),
linestyles=('-', '-'),
linewidths=(1, 1))
subPlot1.clabel(cp, fontsize=10, inline=True, fmt='%4.3f')
if orientation == 'x':
collectionToPlot.rotate(-90, [1, 0, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(-90, [1, 0, 0], anchor=[0, 0, 0])
collectionToPlot.rotate(-90, [0, 1, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(-90, [0, 1, 0], anchor=[0, 0, 0])
elif orientation == 'z':
collectionToPlot.rotate(90, [0, 0, 1], anchor=[0, 0, 0])
collectionToCompare.rotate(90, [0, 0, 1], anchor=[0, 0, 0])
collectionToPlot.rotate(90, [0, 1, 0], anchor=[0, 0, 0])
collectionToCompare.rotate(90, [0, 1, 0], anchor=[0, 0, 0])
pos=[0, 6 * yo, -.421 * 25.4 - zo - L])
s73 = magpy.source.magnet.Cylinder(mag=[0, 0, M],
dim=[D, L],
pos=[0, 6 * yo, +.421 * 25.4 + zo])
s81 = magpy.source.magnet.Cylinder(mag=[0, 0, M],
dim=[D, L],
pos=[0, 7 * yo, -.948 * 25.4 - zo - L])
s83 = magpy.source.magnet.Cylinder(mag=[0, 0, M],
dim=[D, L],
pos=[0, 7 * yo, +.948 * 25.4 + zo])
time.sleep(1)
print('Initializing collections... ', end='\r')
c1 = magpy.Collection(s11, s12, s13, s14)
c2 = magpy.Collection(s21, s22, s23, s24)
c3 = magpy.Collection(s31, s32, s33, s34)
c4 = magpy.Collection(s41, s42, s43, s44)
c5 = magpy.Collection(s51, s53)
c6 = magpy.Collection(s61, s63)
c7 = magpy.Collection(s71, s73)
c8 = magpy.Collection(s81, s83)
cz = magpy.Collection(s11, s12, s13, s14, s21, s22, s23, s24, s31, s32, s33,
s34, s41, s42, s43, s44, s51, s53, s61, s63, s71, s73,
s81, s83)
ymin = -yo
ymax = 9 * yo
nys = 100
# Millimeter for lengths
# Degree for angles
# Millitesla for magnetization/remanence, magnetic moment and magnetic field,
# Ampere for currents.
#create sources
#magnetization is in x dir with magnitude 1 in CHECK UNITS LATER
#dimesions are [diameter, height]=[4,5] (mm)
#make cylinder with center 5 mm above origin in z direction
s1 = magpy.source.magnet.Cylinder(mag=[1, 0, 0], dim=[10, 5], pos=[0, 0, 5])
#makes loop in x-y plane
s3 = magpy.source.current.Circular(
curr=1,
dim=10) #current is one amp clockwise (in z direction), dimension is 10 mm
#create collection
c = magpy.Collection(s1,
s3) #now the system can be moved and manipulated as one
#display system
#specify markers to show places of interest:
markerPos = [(0, 0, 0, 'origin'), (10, 10, 10), (-10, -10, -10)]
#Evaluate field at orign
print(c.getB([0, 0, 0]))
#show the collection
magpy.displaySystem(c, markers=markerPos, direc=True)
# taken from https://magpylib.readthedocs.io/en/latest/_pages/2_guideExamples/ import magpylib as magpy from magpylib.source.current import Circular from numpy import linspace # windings of three parts of a coil coil1a = [Circular(curr=1, dim=3, pos=[0, 0, z]) for z in linspace(-3, -1, 10)] coil1b = [Circular(curr=1, dim=3, pos=[0, 0, z]) for z in linspace(-1, 1, 10)] coil1c = [Circular(curr=1, dim=3, pos=[0, 0, z]) for z in linspace(1, 3, 10)] # create collection and manipulate step by step c1 = magpy.Collection(coil1a) c1.move([-1, -1, 0]) c1.addSources(coil1b) c1.move([-1, -1, 0]) c1.addSources(coil1c) c1.move([-1, -1, 0]) # windings of three parts of another coil coil2a = [Circular(curr=1, dim=3, pos=[3, 3, z]) for z in linspace(-3, -1, 15)] coil2b = [Circular(curr=1, dim=3, pos=[3, 3, z]) for z in linspace(-1, 1, 15)] coil2c = [Circular(curr=1, dim=3, pos=[3, 3, z]) for z in linspace(1, 3, 15)] # create individual sub-collections c2a = magpy.Collection(coil2a) c2b = magpy.Collection(coil2b) c2c = magpy.Collection(coil2c) # combine sub-collections to one big collection c2 = magpy.Collection(c2a, c2b, c2c)
import magpylib as magpy
from magpylib.source.current import Circular
import numpy as np
from matplotlib import pyplot as plt
from skimage import measure
# windings of three parts of a coil
coil1a = [
Circular(curr=1, dim=3, pos=[0, 0, z]) for z in np.linspace(-3, 3, 15)
]
# create collection and manipulate step by step
c1 = magpy.Collection(coil1a)
# magpy.displaySystem(c1, figsize=(6,6))
# create positions
xs = np.linspace(-8, 8, 100)
zs = np.linspace(-6, 6, 100)
posis = [[x, 0, z] for z in zs for x in xs]
# calculate field and amplitude
B = [c1.getB(pos) for pos in posis]
Bs = np.array(B).reshape([100, 100, 3]) #reshape
Bamp = np.linalg.norm(Bs, axis=2)
print(Bamp.shape)
print(Bamp[50, 50]) # field in center
fig = plt.figure(figsize=[5, 5])
ax = fig.add_axes([.1, .1, .8, .8])
if i in range(6, 9):
sources['{}tr'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}br'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}tl'.format(i)] = Cylmag(
loc=[xoffset, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
sources['{}bl'.format(i)] = Cylmag(
loc=[-xoffset, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
else:
sources['{}r'.format(i)] = Cylmag(
loc=[0, ylocs[i], zlocs[i] + zoffset], ori=oris[i])
sources['{}l'.format(i)] = Cylmag(
loc=[0, ylocs[i], -zlocs[i] - zoffset], ori=oris[i])
C = magpy.Collection()
for sc in sources:
C.addSources(sources[sc])
ymin = 0 # mm
ymax = 11 * 25.4 # mm
ny = 100
ys = np.linspace(ymin, ymax, ny)
Y = [[0, y, 0] for y in ys]
BZy = C.getBsweep(Y) # mT
plt.figure()
plt.plot(ys / 10, BZy[:, 2] * 10)
plt.xlabel('Beamline Position (cm)')
plt.ylabel('Z Magnetic Field (Gs)')
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
import magpylib as magpy
# create collection of two magnets
s1 = magpy.source.current.Circular(curr=1, dim=8)
s1.rotate(45, [0, 1, 0], anchor=s1.position
) #tilts loop 45 degree about y-axis that passes through its center
c = magpy.Collection(s1)
# create positions
xs = np.linspace(-8, 8, 100)
dxs = xs[1] - xs[0]
zs = np.linspace(-6, 6, 100)
dzs = zs[1] - zs[0]
posis = [[x, 0, z] for z in zs for x in xs] #increments x first
# calculate field and amplitude
B = [c.getB(pos) for pos in posis] #
Bs = np.array(B).reshape([100, 100, 3]) #reshape to [z_pos,x_pos,[Bx,By,Bz]]
Bamp = np.linalg.norm(Bs, axis=2) #comuptes norm of all vectors
Bamp = Bamp * 10 #converts from mT to Gauss
#field at center in guass
print("Field at center in Gauss")
print(np.linalg.norm(c.getB([0, 0, 0]) * 10))
# define figure with a 2d and a 3d axis
fig = plt.figure(figsize=(10, 5)) #fig size
ax1 = fig.add_subplot(121, projection='3d')
fig = plt.figure()
ax = fig.add_subplot(111,projection='3d')
pi = np.pi
seg = Segment()
seg.bend_angle = pi/2
seg.bend_direction = 3*pi
rotvec = [0,0,1]
seg.apply_rotvec(rotvec,[1,0,0])
x = seg.bend_line(rotvec)
ax.plot(x[0],x[1],x[2],color='black')
c = magpy.Collection(seg.magnet)
magpy.displaySystem(c,subplotAx=ax,suppress=True)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
'''
ax.set_xlim(-200,200)
ax.set_ylim(-200,200)
ax.set_zlim(-200,200)
'''
plt.show()
import magpylib as magpy
# create magnets
magnet1 = magpy.source.magnet.Box(mag=[0, 0, 600],
dim=[3, 3, 3],
pos=[-4, 0, 3])
magnet2 = magpy.source.magnet.Cylinder(mag=[0, 0, 500],
dim=[3, 5],
pos=[0, 0, 0])
# manipulate magnets
magnet1.rotate(45, [0, 1, 0], anchor=[0, 0, 0])
magnet2.move([5, 0, -4])
# collect magnets
pmc = magpy.Collection(magnet1, magnet2)
# display system geometry
pmc.displaySystem()
# calculate B-fields on a grid
xs = np.linspace(-10, 10, 20)
zs = np.linspace(-10, 10, 20)
Bs = np.array([[pmc.getB([x, 0, z]) for x in xs] for z in zs])
# display fields using matplotlib
fig, ax = plt.subplots()
X, Y = np.meshgrid(xs, zs)
U, V = Bs[:, :, 0], Bs[:, :, 2]
ax.streamplot(X, Y, U, V, color=np.log(U**2 + V**2), density=1.5)
plt.show()
s3d1.move([0, 0, -d1 - d2])
s4d1.move([0, 0, -d1 - d2])
s5d1.move([0, 0, -d1 - d2])
s6d1.move([0, 0, -d1 - d2])
s1d2.move([0, 0, -d1 + d2])
s2d2.move([0, 0, -d1 + d2])
s3d2.move([0, 0, -d1 + d2])
s4d2.move([0, 0, -d1 + d2])
s5d2.move([0, 0, -d1 + d2])
s6d2.move([0, 0, -d1 + d2])
print('complete')
print('building collection...', end='')
Cmot = magpy.Collection(s1u1, s2u1, s3u1, s4u1, s5u1, s6u1, s1u2, s2u2, s3u2,
s4u2, s5u2, s6u2, s1d1, s2d1, s3d1, s4d1, s5d1, s6d1,
s1d2, s2d2, s3d2, s4d2, s5d2, s6d2)
Cmot.displaySystem()
print('complete')
xmin = -2 * rmax
xmax = 2 * rmax
nx = 100
zmin = -2 * d1
zmax = 2 * d1
nz = 100
xs = np.linspace(xmin, xmax, nx)
zs = np.linspace(zmin, zmax, nz)
cz = magpy.Collection(
s11,
#s12,
s13,
#s14,
s21,
#s22,
s23,
#s24,
s31,
#s32,
s33,
#s34,
s41,
#s42,
s43,
#s44,
s51,
s53,
s61,
s63,
s71,
s72,
s73,
s74,
s81,
s82,
s83,
s84,
s91,
s92,
s93,
s94,
s101,
s103,
s111,
s113)
piv4 = [-7,0,-5]
anch4 = [-7,0,-2]
s4 = Box(mag=M, dim=D, pos = [-7,-3,-5])
piv5 = [0,0,-5]
anch5 = [0,0,-2]
s5 = Box(mag=M, dim=D, pos = [0,-3,-5])
s5.rotate(-45,[0,0,1],anchor=anch5)
piv6 = [7,0,-5]
anch6 = [7,0,-8]
s6 = Box(mag=M, dim=D, pos = [7,-3,-5])
s6.rotate(-45,[0,0,1],anchor=anch6)
# collect all sources
c = magpy.Collection(s1,s2,s3,s4,s5,s6)
# draw rotation axes
for x in [-7,0,7]:
for z in [-5,5]:
ax.plot([x,x],[0,0],[z-3,z+4],color='.3')
# define markers
Ms = [piv1+['piv1'], piv2+['piv2'], piv3+['piv3'], piv4+['piv4'],
piv5+['piv5'], piv6+['piv6'], anch4+['anch4'],anch5+['anch5'],anch6+['anch6']]
# display system
magpy.displaySystem(c,subplotAx=ax,markers=Ms,suppress=True)
plt.show()
def constructAccess(I=4,
centralPointBetweenHelmCoils=[0, 0, 0],
coilExtDiameter=1,
relativeDistance=1,
wireDiameter=1,
singleCoilWidth=1,
lengthBetweenCoils=1,
helmCoil=magpy.Collection()):
"""
Returns a collection with the wires access in 'x' axis orientation
to the coils of a helmholtz collection with 'z' field orientation
Parameters
----------
I : float
The Coil Current in Amperes.
centralPointBetweenHelmCoils : integer, default 1
Integer number of odd layers.
coilExtDiameter : float
The external diameter of one of the helmholtz coils, in mm.
relativeDistance : float 0~1, default 1
The porcentage of the 1.5*coilExtDiameter distance from the
centralPointBetweenHelmCoils that the wire will split to the coils
wireDiameter : float, default 1
Diameter of the coil wire in mm.
singleCoilWidth : float, default 1
Width of a single coil of helmholtz coil, in mm
lengthBetweenCoils : float, default 1
The internal length between the two coils of the helmholtz coil
helmCoil : Magpy Collection, default empty
Append the wires to a magpy collection.
Example
---------
test = constructAccess( I = 4, centralPointBetweenHelmCoils = [0,0,0], coilExtDiameter = 1, relativeDistance = 0.5,
wireDiameter = 1, singleCoilWidth = 1, lengthBetweenCoils = 1, helmCoil = magpy.Collection()):
test.displaySystem()
"""
# distance from the centralPointBetweenHelmCoils to the center of one coil of Helmholtz coil
halfCoillengthBetweenCoils = (lengthBetweenCoils + singleCoilWidth) / 2
# Initializing the statingPoint of the wires with the central point of the coil + some distance relative to the coilIntDiameter
wiresStartingPoint = centralPointBetweenHelmCoils
wiresStartingPoint[0] += 1.5 * coilExtDiameter
# |
#
#
vector = [[
wiresStartingPoint[0], wiresStartingPoint[1],
wireDiameter + wiresStartingPoint[2]
], [wiresStartingPoint[0] * relativeDistance, 0, wireDiameter]]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _|
#
#
vector = [
vector[1],
[
vector[1][0], vector[1][1],
vector[1][2] + halfCoillengthBetweenCoils
]
]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _|
# |
# |
vector = [
vector[1],
[coilExtDiameter / 2 - wireDiameter, vector[1][1], vector[1][2]]
]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _|
# |
# ||
vector = [[vector[1][0], vector[1][1], vector[1][2] - wireDiameter],
[
vector[0][0] - wireDiameter, vector[0][1],
vector[0][2] - wireDiameter
]]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# going to the other side
# _|
# | __
# ||
vector = [vector[1], [vector[1][0], vector[1][1], -vector[1][2]]]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _|
# | __
# || |
vector = [
vector[1],
[coilExtDiameter / 2 - wireDiameter, vector[1][1], vector[1][2]]
]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _|
# | __ |
# || ||
vector = [[vector[1][0], vector[1][1], vector[1][2] - wireDiameter],
[
vector[0][0] + wireDiameter, vector[0][1],
vector[0][2] - wireDiameter
]]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _| _
# | __ |
# || ||
vector = [
vector[1],
[wiresStartingPoint[0] * relativeDistance, 0, -wireDiameter]
]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
# _| |_
# | __ |
# || ||
vector = [[wiresStartingPoint[0] * relativeDistance, 0, -wireDiameter],
[
wiresStartingPoint[0], wiresStartingPoint[1],
-wireDiameter + wiresStartingPoint[2]
]]
line = magpy.source.current.Line(curr=I, vertices=vector)
helmCoil.addSources(line)
return helmCoil
