def calculate_force_per_row(self):
''' solve for force on row'''
if self.model.model_parameters.type == 'Compensated_APPLE':
#"General Solution Method"
rows = []
for i in range(self.model.model_parameters.rows):
#append to the list, a list of two containers.
#The Container we chack the force on,
#and the container for objects 'creating rest of field
rows.append([wrd.wradObjCnt(),wrd.wradObjCnt()])
self.rownames = self.model.rownames
#for each magnet row
for i in range(self.model.model_parameters.rows):
#for each beam option
for j in range(self.model.model_parameters.rows):
#if the row is the desired row
if self.model.allarraytabs[i].row == j:
#put it in the 'is this' container
rows[j][0].wradObjAddToCnt([self.model.allarraytabs[i].cont])
else:
#put it in the 'is not this' container
rows[j][1].wradObjAddToCnt([self.model.allarraytabs[i].cont])
self.rowforces = np.zeros([len(rows),3])
#calculate forces on 'this' due to 'not this' in model
for i in range(len(self.rowforces)):
self.rowforces[i] = np.array(rd.FldEnrFrc(rows[i][0].radobj,rows[i][1].radobj,"fxfyfz"))
self.solved_attributes.append('rowforces')
def calculate_force_per_beam(self):
'''solve for the force on the beam'''
if self.model.model_parameters.type == 'Compensated_APPLE':
#create upper wrad object
#upper_beam = wrd.wradObjCnt()
#upper_beam.wradObjAddToCnt([self.model.allarrays['q1'].cont,
# self.model.allarrays['q2'].cont,
# self.model.allarrays['c1h'].cont,
# self.model.allarrays['c1v'].cont,
# self.model.allarrays['c2h'].cont,
# self.model.allarrays['c2v'].cont])
#create lower rad object
#lower_beam = wrd.wradObjCnt()
#lower_beam.wradObjAddToCnt([self.model.allarrays['q3'].cont,
# self.model.allarrays['q4'].cont,
# self.model.allarrays['c3h'].cont,
# self.model.allarrays['c3v'].cont,
# self.model.allarrays['c4h'].cont,
# self.model.allarrays['c4v'].cont])
beams = []
for i in range(self.model.model_parameters.beams):
#append to the list, a list of two containers.
#The Container we chack the force on,
#and the container for objects 'creating rest of field
beams.append([wrd.wradObjCnt(),wrd.wradObjCnt()])
self.beamnames = ['upper','lower']
#for each magnet row
for i in range(self.model.model_parameters.rows):
#for each beam option
for j in range(self.model.model_parameters.beams):
#if the row is in the beam option
if self.model.allarraytabs[i].beam == j:
#put it in the 'is this' container
beams[j][0].wradObjAddToCnt([self.model.allarraytabs[i].cont])
else:
#put it in the 'is not this' container
beams[j][1].wradObjAddToCnt([self.model.allarraytabs[i].cont])
#solve force lower due to all the rest
#a = rd.FldEnrFrc(upper_beam.radobj,lower_beam.radobj,"fxfyfz")
#solve force on upper due to all the rest
#b = rd.FldEnrFrc(lower_beam.radobj,upper_beam.radobj,"fxfyfz")
#self.forceonlower = a
#self.forceonupper = b
self.beamforces = np.zeros([len(beams),3])
for i in range(len(self.beamforces)):
self.beamforces[i] = np.array(rd.FldEnrFrc(beams[i][0].radobj,beams[i][1].radobj,"fxfyfz"))
self.solved_attributes.append('beamforces')
def calculate_force_per_quadrant(self):
'''solve for force on quadrant'''
if self.model.model_parameters.type == 'Compensated_APPLE':
# self.forceonquadrants = {}
# self.forceonquadrantsarray = np.zeros([3,4])
# #create upper wrad object
# for quad in range(1,5,1):
# self.forceonquadrants['quad{}'.format(quad)] = wrd.wradObjCnt()
# self.forceonquadrants['notquad{}'.format(quad)] = wrd.wradObjCnt()
# self.forceonquadrants['quad{}'.format(quad)].wradObjAddToCnt([self.model.allarrays['q{}'.format(quad)].cont,
# self.model.allarrays['c{}v'.format(quad)].cont,
# self.model.allarrays['c{}h'.format(quad)].cont])
# for notquad in range(1,5,1):
# if notquad != quad:
# self.forceonquadrants['notquad{}'.format(quad)].wradObjAddToCnt([self.model.allarrays['q{}'.format(notquad)].cont,
# self.model.allarrays['c{}v'.format(notquad)].cont,
# self.model.allarrays['c{}h'.format(notquad)].cont])
#solve forces on each due to the rest
# for quadsol in range(1,5,1):
# self.forceonquadrants['force_on_quadrant_{}'.format(quadsol)] = rd.FldEnrFrc(self.forceonquadrants['quad{}'.format(quadsol)].radobj,self.forceonquadrants['notquad{}'.format(quadsol)].radobj,"fxfyfz")
# self.forceonquadrantsarray[:,quadsol-1] = self.forceonquadrants['force_on_quadrant_{}'.format(quadsol)]
#"General Solution Method"
quadrants = []
for i in range(self.model.model_parameters.quadrants):
#append to the list, a list of two containers.
#The Container we chack the force on,
#and the container for objects 'creating rest of field
quadrants.append([wrd.wradObjCnt(),wrd.wradObjCnt()])
self.quadrantnames = ['q1','q2','q3','q4']
#for each magnet row
for i in range(self.model.model_parameters.rows):
#for each beam option
for j in range(self.model.model_parameters.quadrants):
#if the row is in the quadrant option
if self.model.allarraytabs[i].quadrant == j:
#put it in the 'is this' container
quadrants[j][0].wradObjAddToCnt([self.model.allarraytabs[i].cont])
else:
#put it in the 'is not this' container
quadrants[j][1].wradObjAddToCnt([self.model.allarraytabs[i].cont])
self.quadrantforces = np.zeros([len(quadrants),3])
#calculate forces on 'this' due to 'not this' in model
for i in range(len(self.quadrantforces)):
self.quadrantforces[i] = np.array(rd.FldEnrFrc(quadrants[i][0].radobj,quadrants[i][1].radobj,"fxfyfz"))
self.solved_attributes.append('quadrantforces')
def __init__(self,name = 'default_name', Body = HalbachArray(), Termination = HalbachTermination_APPLE(),beam = 0, quadrant = 0, row = 0):
self.cont = wrd.wradObjCnt([])
self.cont.wradObjAddToCnt([Body.cont, Termination.cont])
self.beam = beam
self.quadrant = quadrant
self.row = row
self.name = name
def appleArray(parameter_class, loc_offset, halbach_direction=-1):
a = wrd.wradObjCnt([])
loc_offset[1] += -((parameter_class.appleMagnets - 1) / 2.0) * (
parameter_class.mainmagthick + parameter_class.shim)
M = []
mat = []
for i in range(4):
#M.append([halbach_direction * np.sin(i*np.pi/2.0)*parameter_class.M*np.sin(2*np.pi*parameter_class.Mova/360.0),halbach_direction * np.sin(i*np.pi/2.0)*parameter_class.M * np.cos(2*np.pi*parameter_class.Mova/360.0), np.cos(i*np.pi/2.0)*parameter_class.M])
M.append([
np.cos(i * np.pi / 2.0) * parameter_class.M *
np.sin(2 * np.pi * parameter_class.Mova / 360.0),
halbach_direction * np.sin(i * np.pi / 2.0) * parameter_class.M,
np.cos(i * np.pi / 2.0) * parameter_class.M *
np.cos(2 * np.pi * parameter_class.Mova / 360.0)
])
mat.append(wrdm.wradMatLin(parameter_class.ksi, M[i]))
for x in range(-int((parameter_class.appleMagnets - 1) / 2),
int(1 + (parameter_class.appleMagnets - 1) /
2)): #0,parameter_class.appleMagnets
mag = ms.appleMagnet(parameter_class, loc_offset)
loc_offset[1] += parameter_class.mainmagthick + parameter_class.shim
magcol = [(2 + y) / 4.0 for y in M[(x) % 4]]
mag.wradObjDrwAtr(magcol, 2) # [x / myInt for x in myList]
mag.wradObjDivMag([2, 3, 1])
a.wradObjAddToCnt([mag])
return a
def compVArray(parameter_class, loc_offset, halbach_direction=-1):
a = wrd.wradObjCnt([])
loc_offset[1] = -((parameter_class.appleMagnets - 1) / 2.0) * (
parameter_class.mainmagthick + parameter_class.shim)
M = []
mat = []
for i in range(4):
#M.append([np.sin(i*np.pi/2.0)*parameter_class.M*np.sin(2*np.pi*parameter_class.Mova/360.0),np.sin(i*np.pi/2.0)*parameter_class.M * np.cos(2*np.pi*parameter_class.Mova/360.0),halbach_direction * np.cos(i*np.pi/2.0)*parameter_class.M])
M.append([
-halbach_direction * np.cos(i * np.pi / 2.0) * parameter_class.M *
np.cos(2 * np.pi * parameter_class.Mova / 360.0),
halbach_direction * np.sin(i * np.pi / 2.0) * parameter_class.M,
np.cos(i * np.pi / 2.0) * parameter_class.M *
np.sin(2 * np.pi * parameter_class.Mova / 360.0)
])
mat.append(wrdm.wradMatLin(parameter_class.ksi, M[i]))
for x in range(0, parameter_class.appleMagnets):
mag = compMagnet(parameter_class, loc_offset[1], mat[x % 4],
loc_offset)
loc_offset[1] += parameter_class.mainmagthick + parameter_class.shim
magcol = [(2 + y) / 4.0 for y in M[x % 4]]
mag.wradObjDrwAtr(magcol, 2) # [x / myInt for x in myList]
mag.wradObjDivMag([2, 3, 1])
a.wradObjAddToCnt([mag])
a.wradRotate([0, 0, 0], [0, 1, 0], np.pi / 2.0)
return a
def calculate_force_per_magnet(self):
'''solve for an individual magnet in the model'''
if self.model.model_parameters.type == 'Compensated_APPLE':
magnets = [[] for r in range(self.model.model_parameters.rows)]
for i in range(len(magnets)):
#append to the list, a list of two containers.
#The Container we chack the force on,
#and the container for objects 'creating rest of field
magnets[i] = [[wrd.wradObjCnt(),wrd.wradObjCnt()] for r in range(self.model.model_parameters.magnets_per_period)]
#for each magnet row
for i in range(self.model.model_parameters.rows):
#for each magnet row
for j in range(self.model.model_parameters.rows):
#if the row is the desired row
if self.model.allarraytabs[i].row == j:
#loop down to magnets
for k in range(self.model.model_parameters.magnets_per_period):
#put end structure in 'is not this' container
#print('i is {}, j is {}, k is {}'.format(i,j,k))
magnets[j][k][1].wradObjAddToCnt([self.model.allarraytabs[i].cont.objectlist[1]])
#put part of periodic structure that is not in test area in 'is not this' container
for m in range(int((self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()-1)/2)):
magnets[j][k][1].wradObjAddToCnt([self.model.allarraytabs[i].cont.objectlist[0].objectlist[m]])
for m in range(int((self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()-1)/2+self.model.model_parameters.magnets_per_period),self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()):
magnets[j][k][1].wradObjAddToCnt([self.model.allarraytabs[i].cont.objectlist[0].objectlist[m]])
#check periodic part for 'is this'
for m in range(int((self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()-1)/2),int((self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()-1)/2+self.model.model_parameters.magnets_per_period)):
if k+int((self.model.allarraytabs[i].cont.objectlist[0].objectlist.__len__()-1)/2) == m:
magnets[j][k][0].wradObjAddToCnt([self.model.allarraytabs[i].cont.objectlist[0].objectlist[m]])
else:
magnets[j][k][1].wradObjAddToCnt([self.model.allarraytabs[i].cont.objectlist[0].objectlist[m]])
else:
#put it in the 'is not this' container
for k in range(len(magnets[i])):
magnets[i][k][1].wradObjAddToCnt([self.model.allarraytabs[j].cont])
self.magnetforces = np.zeros([self.model.model_parameters.rows,len(magnets[0]),3])
#calculate forces on 'this' to 'not this'
for i in range(len(magnets)):
for j in range(len(magnets[i])):
self.magnetforces[i,j] = np.array(rd.FldEnrFrc(magnets[i][j][0].radobj,magnets[i][j][1].radobj,"fxfyfz"))
self.solved_attributes.append('magnetforces')
def __init__(self, model_hyper_parameters = parameters.model_parameters(), magnet = ms.appleMagnet):
self.cont = wrd.wradObjCnt([])
loc_offset = [0,0,0]
loc_offset[1] = -(((model_hyper_parameters.totalmagnets-1)/2.0) *
(model_hyper_parameters.nominal_fmagnet_dimensions[1] +
model_hyper_parameters.shim) +
model_hyper_parameters.nominal_fmagnet_dimensions[1]/2.0 + 2 *model_hyper_parameters.shim +
model_hyper_parameters.end_magnet_thickness[0] * 2.5 +
model_hyper_parameters.end_separation
)
M = []
mat = []
for i in range(model_hyper_parameters.magnets_per_period):
#M.append([halbach_direction * np.sin(i*np.pi/2.0)*model_hyper_parameters.M*np.sin(2*np.pi*model_hyper_parameters.Mova/360.0),halbach_direction * np.sin(i*np.pi/2.0)*model_hyper_parameters.M * np.cos(2*np.pi*model_hyper_parameters.Mova/360.0), np.cos(i*np.pi/2.0)*model_hyper_parameters.M])
M.append([np.cos(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M*np.sin(2*np.pi*model_hyper_parameters.Mova/360.0),
-1 * np.sin(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M,
np.cos(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M * np.cos(2*np.pi*model_hyper_parameters.Mova/360.0)])
mat.append(wrdm.wradMatLin(model_hyper_parameters.ksi,M[i]))
Mus = -int((model_hyper_parameters.totalmagnets-1)/2)#1st full magnet Upstream in row
Mds = int((model_hyper_parameters.totalmagnets-1)/2)#1st full magnet Downstreamin row
mag1 = magnet(model_hyper_parameters, loc_offset,mat[(Mus-3)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
loc_offset[1] += model_hyper_parameters.end_magnet_thickness[0] + model_hyper_parameters.end_separation
mag2 = magnet(model_hyper_parameters, loc_offset,mat[(Mus-2)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
loc_offset[1] += model_hyper_parameters.end_magnet_thickness[0] + model_hyper_parameters.shim
mag3 = magnet(model_hyper_parameters, loc_offset,mat[(Mus-1)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
loc_offset[1] = (((model_hyper_parameters.totalmagnets-1)/2.0) *
(model_hyper_parameters.nominal_fmagnet_dimensions[1] +
model_hyper_parameters.shim) +
model_hyper_parameters.nominal_fmagnet_dimensions[1]/2.0 +
model_hyper_parameters.shim +
model_hyper_parameters.end_magnet_thickness[0]/2.0
)
mag4 = magnet(model_hyper_parameters, loc_offset,mat[(Mds+1)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
loc_offset[1] += model_hyper_parameters.end_magnet_thickness[0] + model_hyper_parameters.shim
mag5 = magnet(model_hyper_parameters, loc_offset,mat[(Mds+2)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
loc_offset[1] += model_hyper_parameters.end_magnet_thickness[0] + model_hyper_parameters.end_separation
mag6 = magnet(model_hyper_parameters, loc_offset,mat[(Mds+3)%model_hyper_parameters.magnets_per_period], magnet_thickness = model_hyper_parameters.end_magnet_thickness[0])
self.cont.wradObjAddToCnt([mag1.cont, mag2.cont, mag3.cont, mag4.cont, mag5.cont, mag6.cont])
def compUpperBeam(parameter_class):
a = wrd.wradObjCnt([])
q1v = compVArray(parameter_class,
[0, 0, -parameter_class.compappleseparation],
halbach_direction=-1)
# q1h
# q2v
# q2h
a.wradObjAddToCnt([q1v])
return a
def appleUpperBeam(parameter_class):
halbach_direction = 1 ##Field BELOW the Halbach array
q1 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q2 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, 0,
parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q1.wradReflect(parameter_class.origin, [1, 0, 0])
a = wrd.wradObjCnt([])
a.wradObjAddToCnt([q1, q2])
return a
def appleLowerBeam(parameter_class):
halbach_direction = -1 ##Field ABOVE the Halbach array
q3 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, -parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4.wradReflect(parameter_class.origin, [1, 0, 0])
a = wrd.wradObjCnt([])
a.wradObjAddToCnt([q3, q4])
return a
def appleComplete(parameter_class):
##### UPPER BEAM #####
halbach_direction = 1 ##Field BELOW the Halbach array
q1 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q2 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, 0,
parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q1.wradReflect(parameter_class.origin, [1, 0, 0])
##### LOWER BEAM #####
halbach_direction = -1 ##Field ABOVE the Halbach array
q3 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, -parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4.wradReflect(parameter_class.origin, [1, 0, 0])
a = wrd.wradObjCnt([])
a.wradObjAddToCnt([q1, q2, q3, q4])
return a
def __init__(self, model_hyper_parameters = parameters.model_parameters(), magnet = ms.appleMagnet):
'''
Constructor
'''
#def appleArray(model_hyper_parameters, loc_offset, halbach_direction = -1):
self.cont = wrd.wradObjCnt([])
loc_offset = [0,0,0]
loc_offset[1] = -((model_hyper_parameters.totalmagnets-1)/2.0) * (model_hyper_parameters.nominal_fmagnet_dimensions[1] + model_hyper_parameters.shim)
M = []
mat = []
for i in range(model_hyper_parameters.magnets_per_period):
#M.append([halbach_direction * np.sin(i*np.pi/2.0)*model_hyper_parameters.M*np.sin(2*np.pi*model_hyper_parameters.Mova/360.0),halbach_direction * np.sin(i*np.pi/2.0)*model_hyper_parameters.M * np.cos(2*np.pi*model_hyper_parameters.Mova/360.0), np.cos(i*np.pi/2.0)*model_hyper_parameters.M])
M.append([np.cos(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M*np.sin(2*np.pi*model_hyper_parameters.Mova/360.0),-1 * np.sin(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M, np.cos(i*2*np.pi/model_hyper_parameters.magnets_per_period)*model_hyper_parameters.M * np.cos(2*np.pi*model_hyper_parameters.Mova/360.0)])
mat.append(wrdm.wradMatLin(model_hyper_parameters.ksi,M[i]))
for x in range(-int((model_hyper_parameters.totalmagnets-1)/2),int(1+(model_hyper_parameters.totalmagnets-1)/2)):#0,model_hyper_parameters.appleMagnets
mag = magnet(model_hyper_parameters, loc_offset,mat[(x)%model_hyper_parameters.magnets_per_period])
loc_offset[1] += model_hyper_parameters.nominal_fmagnet_dimensions[1] + model_hyper_parameters.shim
self.cont.wradObjAddToCnt([mag.cont])
def __init__(self,
model_parameters=parameters.model_parameters(),
magnet_centre=[0, 0, 0],
this_magnet_material='default',
magnet_thickness='default'):
'''
Constructor
'''
mp = model_parameters
self.magnet_centre = magnet_centre
if this_magnet_material == 'default':
this_magnet_material = mp.magnet_material
if magnet_thickness == 'default':
magnet_thickness = mp.nominal_vcmagnet_dimensions[1]
'''orientation order z,y,x'''
self.cont = wrd.wradObjCnt([])
p1 = wrd.wradObjThckPgn(
magnet_centre[1], magnet_thickness,
[[
magnet_centre[0] -
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0,
magnet_centre[2] -
model_parameters.nominal_vcmagnet_dimensions[2] / 2.0
],
[
magnet_centre[0] -
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0,
magnet_centre[2] +
model_parameters.nominal_vcmagnet_dimensions[2] / 2.0
],
[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0 -
model_parameters.comp_magnet_chamfer[0], magnet_centre[2] +
model_parameters.nominal_vcmagnet_dimensions[2] / 2.0
],
[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0 -
model_parameters.comp_magnet_chamfer[0], magnet_centre[2] -
model_parameters.nominal_vcmagnet_dimensions[2] / 2.0
]], model_parameters.direction)
p2 = wrd.wradObjThckPgn(
magnet_centre[1], magnet_thickness,
[[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2,
magnet_centre[2] -
model_parameters.nominal_vcmagnet_dimensions[2] / 2 +
model_parameters.comp_magnet_chamfer[2] / 2.0
],
[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2,
magnet_centre[2] +
model_parameters.nominal_vcmagnet_dimensions[2] / 2.0 -
model_parameters.comp_magnet_chamfer[2] / 2.0
],
[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0 -
model_parameters.comp_magnet_chamfer[0], magnet_centre[2] +
model_parameters.nominal_vcmagnet_dimensions[2] / 2 -
model_parameters.comp_magnet_chamfer[2] / 2.0
],
[
magnet_centre[0] +
model_parameters.nominal_vcmagnet_dimensions[0] / 2.0 -
model_parameters.comp_magnet_chamfer[0], magnet_centre[2] -
model_parameters.nominal_vcmagnet_dimensions[2] / 2 +
model_parameters.comp_magnet_chamfer[2] / 2.0
]], model_parameters.direction)
self.cont.wradObjAddToCnt([p1, p2])
self.cont.wradMatAppl(this_magnet_material)
self.cont.wradObjDivMag(mp.block_subdivision)
self.cont.wradObjDrwAtr(colour='default', linethickness=2)
def compensatedAppleComplete(parameter_class, style="symmetric"):
##### FUNCTIONAL MAGNETS #####
##### UPPER BEAM #####
halbach_direction = 1 ##Field BELOW the Halbach array
q1 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q2 = appleArray(parameter_class, [
parameter_class.mainmagdimension / 2.0 +
parameter_class.minimumgap / 2.0, 0,
parameter_class.mainmagdimension / 2.0 +
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q1.wradReflect(parameter_class.origin, [1, 0, 0])
##### LOWER BEAM #####
halbach_direction = -1 ##Field ABOVE the Halbach array
q3 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4 = appleArray(parameter_class, [
-parameter_class.mainmagdimension / 2.0 -
parameter_class.minimumgap / 2.0, parameter_class.circlin *
parameter_class.shift, -parameter_class.mainmagdimension / 2.0 -
parameter_class.rowtorowgap / 2.0
], halbach_direction)
q4.wradReflect(parameter_class.origin, [1, 0, 0])
##### Q1 Compensation Magnets #####
q1v = compVArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.rowtorowgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.minimumgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=1)
q1h = compHArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.rowtorowgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=-1)
q1h.wradReflect(parameter_class.origin, [0, 0, 1])
##### Q2 Compensation Magnets #####
q2v = compVArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.rowtorowgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.minimumgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=-1)
q2h = compHArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.rowtorowgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=-1)
q2v.wradReflect(parameter_class.origin, [1, 0, 0])
q2h.wradRotate(parameter_class.origin, [0, 1, 0], np.pi)
q2h.wradFieldInvert()
##### Q3 Compensation Magnets #####
q3v = compVArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.rowtorowgap / 2.0, 0,
parameter_class.compmagdimensions[2] / 2.0 +
parameter_class.minimumgap / 2.0 + parameter_class.mainmagdimension +
parameter_class.compappleseparation
],
halbach_direction=-1)
q3h = compHArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.rowtorowgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=-1)
q3v.wradFieldInvert()
##### Q4 Compensation Magnets #####
q4v = compVArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.rowtorowgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.minimumgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=1)
q4h = compHArray(parameter_class, [
-parameter_class.compmagdimensions[0] / 2.0 -
parameter_class.minimumgap / 2.0, 0,
-parameter_class.compmagdimensions[2] / 2.0 -
parameter_class.rowtorowgap / 2.0 - parameter_class.mainmagdimension -
parameter_class.compappleseparation
],
halbach_direction=-1)
q4h.wradReflect(parameter_class.origin, [1, 0, 0])
q4h.wradFieldInvert()
q4v.wradRotate(parameter_class.origin, [0, 1, 0], np.pi)
a = wrd.wradObjCnt([])
a.wradObjAddToCnt([q1, q1h, q1v, q2, q2h, q2v, q3, q3h, q3v, q4, q4h, q4v])
return a
def __init__(self,
model_hyper_parameters=parameters.model_parameters(),
fmagnet=ms.appleMagnet,
cmagnet=ms.compMagnet):
self.cont = wrd.wradObjCnt([])
mp = model_hyper_parameters
if mp.shiftmode == 'circular':
shiftmodesign = 1
elif mp.shiftmode == 'linear':
shiftmodesign = -1
else:
shiftmodesign = 0
self.allarrays = {
'q1':
ha.MagnetRow(
ha.HalbachArray(model_hyper_parameters, fmagnet),
ha.HalbachTermination_APPLE(model_hyper_parameters, fmagnet)),
'q2':
ha.HalbachArray(model_hyper_parameters, fmagnet),
'q3':
ha.HalbachArray(model_hyper_parameters, fmagnet),
'q4':
ha.HalbachArray(model_hyper_parameters, fmagnet),
'c1v':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c1h':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c2v':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c2h':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c3v':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c3h':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c4v':
ha.HalbachArray(model_hyper_parameters, cmagnet),
'c4h':
ha.HalbachArray(model_hyper_parameters, cmagnet),
}
##### Functional Magnets #####
### Q1 ###
self.allarrays['q1'].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift, -(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['q1'].cont.wradFieldInvert()
self.allarrays['q1'].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### Q2 ###
self.allarrays['q2'].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['q2'].cont.wradFieldInvert()
self.allarrays['q2'].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
self.allarrays['q2'].cont.wradReflect([0, 0, 0], [1, 0, 0])
### Q3 ###
self.allarrays['q3'].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['q3'].cont.wradReflect([0, 0, 0], [1, 0, 0])
### Q4 ###
self.allarrays['q4'].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift * shiftmodesign,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
##### Compensation Magnets #####
### C1h ###
self.allarrays['c1h'].cont.wradTranslate([
-(mp.nominal_cmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, mp.rowshift,
-(mp.nominal_cmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['c1h'].cont.wradFieldInvert()
self.allarrays['c1h'].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### C2h ###
self.allarrays['c2h'].cont.wradTranslate([
(mp.nominal_cmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, 0.0, -(mp.nominal_cmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['c2h'].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### C3h ###
self.allarrays['c3h'].cont.wradTranslate([
-(mp.nominal_cmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, 0.0, -(mp.nominal_cmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['c3h'].cont.wradFieldInvert()
self.allarrays['c3h'].cont.wradReflect([0, 0, 0], [1, 0, 0])
### C4h ###
self.allarrays['c4h'].cont.wradTranslate([
(mp.nominal_cmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, mp.rowshift * shiftmodesign,
-(mp.nominal_cmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarrays['c4h'].cont.wradReflect([0, 0, 0], [1, 0, 0])
### C1v ###
self.allarrays['c1v'].cont.wradRotate([0, 0, 0], [0, 1, 0], -np.pi / 2)
self.allarrays['c1v'].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
-np.pi / 2)
self.allarrays['c1v'].cont.wradTranslate([
(mp.nominal_cmagnet_dimensions[2] / 2.0 + mp.rowtorowgap) / 2.0,
mp.rowshift,
(mp.nominal_cmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
### C2v ###
self.allarrays['c2v'].cont.wradRotate([0, 0, 0], [0, 1, 0], -np.pi / 2)
self.allarrays['c2v'].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
-np.pi / 2)
self.allarrays['c2v'].cont.wradFieldInvert()
self.allarrays['c2v'].cont.wradReflect([0, 0, 0], [1, 0, 0])
self.allarrays['c2v'].cont.wradTranslate([
-(mp.nominal_cmagnet_dimensions[2] / 2.0 + mp.rowtorowgap) / 2.0,
0.0,
(mp.nominal_cmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
### C3v ###
self.allarrays['c3v'].cont.wradRotate([0, 0, 0], [0, 1, 0], -np.pi / 2)
self.allarrays['c3v'].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
np.pi / 2)
self.allarrays['c3v'].cont.wradTranslate([
(mp.nominal_cmagnet_dimensions[2] / 2.0 + mp.rowtorowgap) / 2.0,
0.0,
(mp.nominal_cmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
self.allarrays['c3v'].cont.wradReflect([0, 0, 0], [0, 0, 1])
### C4v ###
self.allarrays['c4v'].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi / 2)
self.allarrays['c4v'].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
-np.pi / 2)
self.allarrays['c4v'].cont.wradTranslate([
-(mp.nominal_cmagnet_dimensions[2] / 2.0 + mp.rowtorowgap) / 2.0,
mp.rowshift * shiftmodesign,
-(mp.nominal_cmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) /
2.0
])
for key in self.allarrays:
self.cont.wradObjAddToCnt([self.allarrays[key].cont])
print('my compensated APPLE calculated at a gap of {}mm'.format(
mp.gap))
def __init__(self,
model_parameters=parameters.model_parameters(),
fmagnet=ms.appleMagnet):
rd.UtiDelAll()
self.cont = wrd.wradObjCnt([])
self.model_parameters = model_parameters
mp = self.model_parameters
if mp.shiftmode == 'circular':
shiftmodesign = 1
elif mp.shiftmode == 'linear':
shiftmodesign = -1
else:
shiftmodesign = 0
self.rownames = ['q1', 'q2', 'q3', 'q4']
self.allarraytabs = np.array([
ha.MagnetRow(
self.rownames[0], ha.HalbachArray(model_parameters, fmagnet),
ha.HalbachTermination_APPLE(model_parameters, fmagnet))
for _ in range(4)
])
for r in range(4):
self.allarraytabs[r] = ha.MagnetRow(
self.rownames[r],
ha.HalbachArray(model_parameters, fmagnet),
ha.HalbachTermination_APPLE(model_parameters, fmagnet),
beam=int((r // 2)),
quadrant=int(self.rownames[r][1]) - 1,
row=r)
##### Functional Magnets #####
### Q1 ###
self.allarraytabs[0].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[0].cont.wradFieldInvert()
self.allarraytabs[0].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
self.allarraytabs[0].cont.wradReflect([0, 0, 0], [1, 0, 0])
### Q2 ###
self.allarraytabs[1].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift, -(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[1].cont.wradFieldInvert()
self.allarraytabs[1].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### Q3 ###
self.allarraytabs[2].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift * shiftmodesign,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
### Q4 ###
self.allarraytabs[3].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[3].cont.wradReflect([0, 0, 0], [1, 0, 0])
for row in range(len(self.allarraytabs)):
self.cont.wradObjAddToCnt([self.allarraytabs[row].cont])
def __init__(self,
model_parameters=parameters.model_parameters(),
fmagnet=ms.appleMagnet,
cmagnet=ms.compMagnet,
Hcmagnet=ms.HcompMagnet,
Vcmagnet=ms.VcompMagnet):
rd.UtiDelAll()
self.cont = wrd.wradObjCnt([])
self.model_parameters = model_parameters
mp = self.model_parameters
if mp.shiftmode == 'circular':
shiftmodesign = 1
elif mp.shiftmode == 'linear':
shiftmodesign = -1
else:
shiftmodesign = 0
self.rownames = [
'q1', 'q2', 'q3', 'q4', 'c1v', 'c1h', 'c2v', 'c2h', 'c3v', 'c3h',
'c4v', 'c4h'
]
self.allarraytabs = np.array([
ha.MagnetRow(
self.rownames[0], ha.HalbachArray(model_parameters, fmagnet),
ha.HalbachTermination_APPLE(model_parameters, fmagnet))
for _ in range(12)
])
for r in range(4):
self.allarraytabs[r] = ha.MagnetRow(
self.rownames[r],
ha.HalbachArray(model_parameters, fmagnet),
ha.HalbachTermination_APPLE(model_parameters, fmagnet),
beam=int((r // 2)),
quadrant=int(self.rownames[r][1]) - 1,
row=r)
for r in range(4, 12, 2):
if r < 8:
be = 0
else:
be = 1
self.allarraytabs[r] = ha.MagnetRow(
self.rownames[r],
ha.HalbachArray(model_parameters, Vcmagnet),
ha.HalbachTermination_APPLE(model_parameters, Vcmagnet),
beam=be,
quadrant=int(self.rownames[r][1]) - 1,
row=r)
for r in range(5, 12, 2):
if r < 8:
be = 0
else:
be = 1
self.allarraytabs[r] = ha.MagnetRow(
self.rownames[r],
ha.HalbachArray(model_parameters, Hcmagnet),
ha.HalbachTermination_APPLE(model_parameters, Hcmagnet),
beam=be,
quadrant=int(self.rownames[r][1]) - 1,
row=r)
##### Functional Magnets #####
### Q1 ###
self.allarraytabs[0].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[0].cont.wradFieldInvert()
self.allarraytabs[0].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
self.allarraytabs[0].cont.wradReflect([0, 0, 0], [1, 0, 0])
### Q2 ###
self.allarraytabs[1].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift, -(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[1].cont.wradFieldInvert()
self.allarraytabs[1].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### Q3 ###
self.allarraytabs[2].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0,
mp.rowshift * shiftmodesign,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
### Q4 ###
self.allarraytabs[3].cont.wradTranslate([
-(mp.nominal_fmagnet_dimensions[2] + mp.rowtorowgap) / 2.0, 0.0,
-(mp.nominal_fmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[3].cont.wradReflect([0, 0, 0], [1, 0, 0])
##### Compensation Magnets #####
### C1h ###
self.allarraytabs[5].cont.wradTranslate([
-(mp.nominal_hcmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, 0.0, -(mp.nominal_hcmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[5].cont.wradReflect([0, 0, 0], [0, 0, 1])
### C2h ###
self.allarraytabs[7].cont.wradTranslate([
-(mp.nominal_hcmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, mp.rowshift,
-(mp.nominal_hcmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[7].cont.wradFieldInvert()
self.allarraytabs[7].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi)
### C3h ###
self.allarraytabs[9].cont.wradTranslate([
-(mp.nominal_hcmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, mp.rowshift * shiftmodesign,
-(mp.nominal_hcmagnet_dimensions[0] + mp.gap) / 2.0
])
### C4h ###
self.allarraytabs[11].cont.wradTranslate([
-(mp.nominal_hcmagnet_dimensions[2] + mp.rowtorowgap + 2 *
(mp.nominal_fmagnet_dimensions[0] + mp.compappleseparation)) /
2.0, 0.0, -(mp.nominal_hcmagnet_dimensions[0] + mp.gap) / 2.0
])
self.allarraytabs[11].cont.wradFieldInvert()
self.allarraytabs[11].cont.wradReflect([0, 0, 0], [1, 0, 0])
### C1v ###
self.allarraytabs[4].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
np.pi / 2)
self.allarraytabs[4].cont.wradFieldInvert()
self.allarraytabs[4].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi / 2)
self.allarraytabs[4].cont.wradReflect([0, 0, 0], [0, 0, 1])
self.allarraytabs[4].cont.wradTranslate([
-(mp.nominal_vcmagnet_dimensions[0] + mp.rowtorowgap) / 2.0, 0.0,
(mp.nominal_vcmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
###feildrotatedebugtest###
# axisq1 = [[10,-20,10],[10,20,10]]
# rd.Solve(self.allarraytabs[0].cont.objectlist[0].objectlist[0].radobj,0.001,1000)
# q1m = np.array(rd.FldLst(self.allarraytabs[0].cont.objectlist[0].objectlist[0].radobj,'mxmymz',axisq1[0],axisq1[1],101,'arg',-20))
# plt.plot(q1m[:,0],q1m[:,3])
# axisc1v = [[4,-20,30],[4,20,30]]
# rd.Solve(self.allarraytabs[4].cont.objectlist[0].objectlist[0].radobj,0.001,1000)
# c1vm = np.array(rd.FldLst(self.allarraytabs[4].cont.objectlist[0].objectlist[0].radobj,'mxmymz',axisc1v[0],axisc1v[1],101,'arg',-20))
# plt.plot(c1vm[:,0],c1vm[:,3])
# print(1)
### C2v ###
self.allarraytabs[6].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
np.pi / 2)
#self.allarraytabs[4].cont.wradFieldInvert()
self.allarraytabs[6].cont.wradRotate([0, 0, 0], [0, 1, 0], -np.pi / 2)
self.allarraytabs[6].cont.wradTranslate([
(mp.nominal_vcmagnet_dimensions[0] + mp.rowtorowgap) / 2.0,
mp.rowshift,
(mp.nominal_vcmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
### C3v ###
self.allarraytabs[8].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
np.pi / 2)
#self.allarraytabs[10].cont.wradFieldInvert()
self.allarraytabs[8].cont.wradRotate([0, 0, 0], [0, 1, 0], np.pi / 2)
self.allarraytabs[8].cont.wradTranslate([
-(mp.nominal_vcmagnet_dimensions[0] + mp.rowtorowgap) / 2.0,
mp.rowshift * shiftmodesign,
-(mp.nominal_vcmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) /
2.0
])
### C4v ###
self.allarraytabs[10].cont.wradFieldRotate([0, 0, 0], [0, 1, 0],
np.pi / 2)
self.allarraytabs[10].cont.wradFieldInvert()
self.allarraytabs[10].cont.wradRotate([0, 0, 0], [0, 1, 0], -np.pi / 2)
self.allarraytabs[10].cont.wradTranslate([
(mp.nominal_vcmagnet_dimensions[0] + mp.rowtorowgap) / 2.0, 0.0,
(mp.nominal_vcmagnet_dimensions[2] + mp.gap + 2 *
(mp.nominal_fmagnet_dimensions[2] + mp.compappleseparation)) / 2.0
])
self.allarraytabs[10].cont.wradReflect([0, 0, 0], [0, 0, 1])
for row in range(len(self.allarraytabs)):
self.cont.wradObjAddToCnt([self.allarraytabs[row].cont])
print('my compensated APPLE calculated at a gap of {}mm'.format(
mp.gap))
'''