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 UEX(periodlength=120, gap=13, rowshift=0):
UEXH_params = testparams = parameters.model_parameters(
periods=10,
periodlength=periodlength,
block_subdivision=[2, 1, 1],
nominal_fmagnet_dimensions=[40.0, 0.0, 40.0],
apple_clampcut=5.0,
magnets_per_period=4,
gap=gap,
rowshift=rowshift,
rowtorowgap=1.0,
shiftmode='circular',
M=1.3)
#create model
UEXH = id.plainAPPLE(UEXH_params)
return UEXH
def UE112():
UE112H_params = testparams = parameters.model_parameters(
periods=10,
periodlength=112,
block_subdivision=[2, 1, 1],
nominal_fmagnet_dimensions=[40.0, 0.0, 40.0],
apple_clampcut=5.0,
comp_magnet_chamfer=[3.0, 0.0, 3.0],
magnets_per_period=4,
gap=22.9,
rowshift=56,
rowtorowgap=1.2,
shiftmode='circular',
M=1.2)
#create model
UE112H = id.plainAPPLE(UE112H_params)
return UE112H
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,
base_hyper_parameters,
hyper_solution_variables,
scan_parameters = 'default',
hyper_solution_properties = ['B'],
method = 'random',
iterations = 20):
if scan_parameters == 'default':
self.scan_parameters = parameters.scan_parameters(periodlength = test_hyper_params.periodlength)
else:
self.scan_parameters = scan_parameters
solvecount = 0
self.base_hyper_parameters = parameters.model_parameters(**base_hyper_parameters) #what is the fundamental model
self.hyper_solution_variables = copy.deepcopy(hyper_solution_variables) #what parameters in the hyperparameters are being varied and their ranges
self.hyper_solution_properties = copy.deepcopy(hyper_solution_properties) #
self.hyper_inputs = []
self.hyper_results = {}
self.solutions = []
keylist = list(self.hyper_solution_variables.keys())
#Build Hyper_Inputs
if method == 'systematic':
tmp = []
for key in keylist:
if type(self.hyper_solution_variables[key]) is list:
for i in range(len(self.hyper_solution_variables[key])):
tmp.append(self.hyper_solution_variables[key][i])
else:
tmp.append(self.hyper_solution_variables[key])
tmp1 = list(itertools.product(*tmp))
for j in tmp1:
jlist = list(j)
for key in range(len(keylist)):
keylen = 1
if isinstance(base_hyper_parameters[keylist[key]],list):
keylen = len(base_hyper_parameters[keylist[key]])
base_hyper_parameters[keylist[key]] = jlist[0:keylen]
else:
base_hyper_parameters[keylist[key]] = jlist[0]
del jlist[0:keylen]
#check exisitng length
new_hyper_params = copy.deepcopy((parameters.model_parameters(**base_hyper_parameters)))
self.hyper_inputs.append(new_hyper_params)
if method == 'random':
#for n in iterations - build hyperparameter cases
for n in range(iterations):
# new_hyper_params = copy.deepcopy(base_hyper_params)
#for key in dictionary
for key in self.hyper_solution_variables:
#if key is list... or even if it's not
a = self.randomise_hyper_input(self.hyper_solution_variables[key])
base_hyper_parameters[key] = a
# setattr(new_hyper_params,key, copy.copy(a))
new_hyper_params = parameters.model_parameters(**base_hyper_parameters)
self.hyper_inputs.append(new_hyper_params)
#build hyper_results dict
#what shape of results array needed (i.e. steps in hyper_solution_variables)
list_of_hyper_vars = list(self.hyper_solution_variables.keys())
hyper_result_shape = []
# for var in list_of_hyper_vars:
# hyper_result_shape.append(len(self.hyper_solution_variables[var]))
for var in list_of_hyper_vars:
if isinstance(self.hyper_solution_variables[var], list):
for i in range(len(self.hyper_solution_variables[var])):
hyper_result_shape.append(self.hyper_solution_variables[var][i].__len__())
else:
hyper_result_shape.append(self.hyper_solution_variables[var].__len__())
if 'B' in self.hyper_solution_properties:
self.hyper_results['Bmax'] = np.zeros(np.append(hyper_result_shape,3))
#self.hyper_results['Bfieldharmonics'] = np.zeros(np.append(hyper_result_shape,[2,10]))
self.hyper_results['Beff'] = np.zeros(np.append(hyper_result_shape,3))
if 'Integrals' in self.hyper_solution_properties:
self.hyper_results['1st_Integral_Max_Harmonic'] = np.zeros(np.append(hyper_result_shape,11,2))
self.hyper_results['2nd_Integral_Max_Harmonic'] = np.zeros(np.append(hyper_result_shape,11,2))
if 'Forces' in self.hyper_solution_properties:
self.hyper_results['Force_Per_Magnet_Type'] = np.zeros(np.append(hyper_result_shape,[self.base_hyper_parameters.magnet_rows*self.base_hyper_parameters.magnets_per_period, 3]))
self.hyper_results['Force_Per_Row'] = np.zeros(np.append(hyper_result_shape,[self.base_hyper_parameters.magnet_rows,3]))
self.hyper_results['Force_Per_Quadrant'] = np.zeros(np.append(hyper_result_shape,[4,3]))
self.hyper_results['Force_Per_Beam'] = np.zeros(np.append(hyper_result_shape,[2,3]))
if 'Torques' in self.hyper_solution_properties:
self.hyper_results['Max_Single_Magnet_Torque'] = np.zeros(np.append(hyper_result_shape,3))
self.hyper_results['Max_Single_Row_Torque'] = np.zeros(np.append(hyper_result_shape,3))
self.hyper_results['Max_Single_Quadrant_Torque'] = np.zeros(np.append(hyper_result_shape,3))
self.hyper_results['Max_Single_Beam_Torque'] = np.zeros(np.append(hyper_result_shape,3))
#does this leave a lot of duplicated data? Yes
hf.close()
if __name__ == '__main__':
### developing Case Solution ###
test_hyper_params = parameters.model_parameters(Mova = 20,
periods = 1,
periodlength = 15,
nominal_fmagnet_dimensions = [15.0,0.0,15.0],
#nominal_cmagnet_dimensions = [10.0,0.0,15.0],
nominal_vcmagnet_dimensions = [7.5,0.0,12.5],
nominal_hcmagnet_dimensions = [7.5,0.0,15.0],
compappleseparation = 7.5,
apple_clampcut = 3.0,
comp_magnet_chamfer = [3.0,0.0,3.0],
magnets_per_period = 6,
gap = 2,
rowshift = 0,
shiftmode = 'circular',
block_subdivision = [1,1,1]
)
a = id.compensatedAPPLEv2(test_hyper_params)
#
case1 = CaseSolution(a)
case1.calculate_B_field()
print(case1.bmax)
print(1)
# case1.calculate_force_per_beam()
# case1.calculate_force_per_quadrant()
from idcomponents import parameters
from idanalysis import analysis_functions as af
from ipywidgets.widgets.interaction import fixed
from wradia.wrad_obj import wradObjCnt
if __name__ == '__main__':
test_hyper_params = parameters.model_parameters(
Mova=0,
periods=8,
periodlength=65,
nominal_fmagnet_dimensions=[30.0, 0.0, 30.0],
M=1.3,
#nominal_cmagnet_dimensions = [10.0,0.0,15.0],
nominal_vcmagnet_dimensions=[7.5, 0.0, 12.5],
nominal_hcmagnet_dimensions=[7.5, 0.0, 15.0],
compappleseparation=15,
apple_clampcut=5.0,
comp_magnet_chamfer=[3.0, 0.0, 3.0],
magnets_per_period=4,
gap=10,
rowshift=0,
shiftmode='circular',
rowtorowgap=1.0,
)
id_10eV = id.compensatedAPPLEv2(test_hyper_params)
#
case1 = af.CaseSolution(id_10eV)
case1.calculate_B_field()
print(case1.bmax)
rd.ObjDrwOpenGL(id_10eV.cont.radobj)
plt.plot(case1.bfield[:, 0], case1.bfield[:, 1], case1.bfield[:, 3])
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))
'''
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))
self.cont.wradObjAddToCnt([mag1.cont, mag2.cont, mag3.cont, mag4.cont, mag5.cont, mag6.cont])
class MagnetRow():
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
if __name__ == '__main__':
mymodelparams = parameters.model_parameters(magnets_per_period = 6, periods = 1)
a = HalbachArray(mymodelparams)
b = HalbachTermination_APPLE(mymodelparams)
c = MagnetRow(a,b)
a.cont.wradSolve(0.001, 1000)
print('{}{}'.format(a.cont.radobj,b))
# rd.ObjDrwOpenGL(a.cont.radobj)
rd.ObjDrwOpenGL(b.cont.radobj)
rd.ObjDrwOpenGL(c.cont.radobj)
if __name__ == '__main__':
# shared parameters
min_gap = 13
#parameter_Set Horizontal_polarisation
UE80_horz = parameters.model_parameters(
Mova=0,
periods=5,
periodlength=80,
nominal_fmagnet_dimensions=[30.0, 0.0, 30.0],
#square_magnet = True,
nominal_cmagnet_dimensions=[10.0, 0.0, 15.0],
#nominal_vcmagnet_dimensions = [7.5,0.0,12.5],
#nominal_hcmagnet_dimensions = [7.5,0.0,15.0],
compappleseparation=75,
apple_clampcut=5.0,
comp_magnet_chamfer=[3.0, 0.0, 3.0],
magnets_per_period=4,
gap=min_gap,
rowshift=0,
shiftmode='circular',
block_subdivision=[2, 3, 1],
M=1.3)
UE80_vert = parameters.model_parameters(
Mova=0,
periods=5,
periodlength=80,
nominal_fmagnet_dimensions=[30.0, 0.0, 30.0],
nominal_cmagnet_dimensions=[10.0, 0.0, 15.0],
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)
