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)) '''