diff --git a/OpticsTools.py b/OpticsTools.py index a156121..59f46c7 100644 --- a/OpticsTools.py +++ b/OpticsTools.py @@ -26,7 +26,7 @@ class OpticsTools(QtWidgets.QMainWindow, Ui_OpticsGUI): # initialize online model self.model = Model(phase=phase,parent=self) - self.matching = Matching(parent=self,model = self.model) + if phase > 0: office = True self.machine = Machine(parent = True, office = office) @@ -42,6 +42,7 @@ class OpticsTools(QtWidgets.QMainWindow, Ui_OpticsGUI): self.loadSettingsdirect("/sf/data/applications/BD-OpticsTools/reference/settings/ReferenceSetting.json") self.sandbox.updateSandbox() self.reference = ReferenceManager(parent=self) + self.matching = Matching(parent=self, model=self.model, reference = self.reference) # events handling self.actionOpen_2.triggered.connect(self.loadSettings) diff --git a/generateMatchSettings.py b/generateMatchSettings.py new file mode 100644 index 0000000..fe640bc --- /dev/null +++ b/generateMatchSettings.py @@ -0,0 +1,96 @@ +import json + +varypar={'min:':-1e-6,'max:':1e-6,'preset':0} + +def MatchStep(ref,id,end, dest,sequence='SwissFEL',saveTwiss=False): + match={'Reference':ref,'MatchID':id,'End':end, 'Destination':dest,'Sequence':sequence} + return match + +def MatchParameter(var0,tar0): + var={key: varypar for key in var0} + tar= tar0 + return {'Variable':var,'Target':tar} + +def MatchReference(loc,twiss): + match ={'Location': loc, 'Twiss': twiss} + return match + + + +#def MatchTar(tar_in) +# tar_out={} +# for tar in tar_in: + # if 'Reference' in tar.key(): + # res=self.getReferenceByTag(tar['Reference']) + # tar_out[res['Location']]=res['Twiss'] + # return tar_out + + + +#def MatchFixed(var0,start,cond): +# var = {key: varypar for key in var0} +# match={'Variable':var,'Start':start,'Constraint':cond} +# return match + + + + +#def MatchPeriodic(seq,var,tar,save): +# match={'Sequence':seq,'Variable':var,'Target':tar,'Save':save} +# return match + +#def MatchCondition(par,val,loc,cond): +# match={'Parameter':par,'Value':val,'Location':loc,'Condition':cond} +# return match + + + + +path ="Settings/" +label='Reference' + +order = [] +order.append(MatchStep('Start', 'Laser Heater','SINLH02','SATBD01')) +order.append(MatchStep(None, 'SINSB04', None,'SATBD01','SINSB04',True)) +#order.append(MatchStep('Laser Heater', 'Match to SINSB04','Dependent','Athos')) +#order.append(MatchStep('Laser Heater', 'Bunch Compressor 1','Fixed','Athos')) +#order.append(MatchStep('Bunch Compressor 1', 'Linac 1','Periodic','Athos')) +#order.append(MatchStep('Bunch Compressor 1', 'Match to Linac 1','Dependent','Athos')) +#order.append(MatchStep('Bunch Compressor 1', 'Bunch Compressor 2','Fixed','Athos')) + +parameter={} +var = ['SINLH01-MQUA020', 'SINLH01-MQUA040','SINLH01-MQUA050','SINLH01-MQUA070','SINLH02-MQUA010'] +parameter['Laser Heater'] = MatchParameter(var,[{'Reference':'Laser Heater'}]) +var = ['SINSB04-MQUA130','SINSB04-MQUA230'] +parameter['SINSB04'] = MatchParameter(var,[{'Fixed':{'Location':'#e','Twiss':{'MUX':0.2,'MUY':0.2}}}]) + + +dependence={} +dependence['S10CB01-MQUA230']=['S20CB02-MQUA230','S10DI01-MQUA120'] + ['S20CB%2.2d-MQUA430' %i for i in range(3,9)] +dependence['S10CB01-MQUA430']=['S20CB02-MQUA430'] + ['S20CB%2.2d-MQUA230' %i for i in range(3,9)] + + +#periodic={} +#target=[MatchCondition('MUX',0.2,'#e','='), MatchCondition('MUY',0.2,'#e','=')] +#variable = ['SINSB04-MQUA130','SINSB04-MQUA230'] +#periodic['SINSB04']=MatchPeriodic('SINSB04',variable,target,{}) +#target=[MatchCondition('MUX',0.1883,'#e','='), MatchCondition('MUY',0.1883,'#e','=')] +#variable = ['S10CB01-MQUA230','S10CB01-MQUA430'] +#periodic['Linac 1']=MatchPeriodic('S10CB01',variable,target,{}) + +reference={} +reference['Start'] = MatchReference('start',{'betax':29.971,'alphax':0.003,'betay':26.00,'alphay':-0.288}) +reference['Laser Heater'] = MatchReference('sinlh02.mqua410$start',{'betax': 11.2, 'alphax': 3.2,'betay': 0.8, 'alphay': 0.75,}) +reference['Bunch Compressor 1'] = MatchReference('sindi02.mqua020$start',{'betax': 11.1557, 'alphax': -1.17,'betay': 50, 'alphay': 0.}) +reference['Bunch Compressor 2'] = MatchReference('s10ma01.mqua020$start',{'betax': 6.14, 'alphax': -0.83,'betay': 22.86, 'alphay': -1.18}) +reference['Switchyard'] = MatchReference('s20sy02.mqua070$start',{'betax': 12.99, 'alphax': 3.7011,'betay': 46.339, 'alphay': -6.501}) +reference['Linac3'] = MatchReference('s30cb10.mqua430$start',{'betax': 8.83,'alphax': 0.548,'betay': 30.44,'alphay': -1.866}) +reference['Aramis Stopper'] = MatchReference('sarma01.mqua010$start',{'betax': 2.304, 'alphax': -1.4045, 'betay': 25.929, 'alphay': -6.363}) +reference['Athos HERO'] = MatchReference('satdi01.mqua250$start',{'betax': 35.76, 'alphax': -1.166,'betay': 24.087, 'alphay': 0.648}) +reference['Athos Deflector'] = MatchReference('satbd01.mqua010$start',{'betax': 50, 'alphax': 0,'betay': 50, 'alphay': 0}) + + +settings={'Label':label,'Order':order,'Dependence':dependence,'Reference':reference,'Parameter':parameter} + +with open(path+label+'.json', 'w', encoding='utf-8') as f: + json.dump(settings, f, ensure_ascii=False, indent=4) \ No newline at end of file diff --git a/matching.py b/matching.py index cf54b2d..d6d68c6 100644 --- a/matching.py +++ b/matching.py @@ -1,25 +1,58 @@ -from matchingmanager import MatchManager + +converttwiss= {'betax':'betx','betay':'bety','alphax':'alfx','alphay':'alfy', + 'etax':'dx','etay':'dy','etapx':'dpx','etapy':'dpy', + 'x':'x','y':'y','px':'px','py':'py','energy':'energy'} class Matching: - def __init__(self,parent=None,model=None): + def __init__(self,parent=None,model=None,reference = None): self.parent = parent self.model = model - self.manager = MatchManager(parent=parent) - self.parent.UIMFodoMatchSingle.clicked.connect(self.matchingFodo) + self.reference = reference - def matchingFodo(self): - print('matching') - par = self.manager.getFODOParameters() - if par is None: + self.destination='' + + def match(self): + config = self.reference.getMatchingPoint() + if config is None: return - quads=par['Quads'] - vals=par['Init'] - if par['FlipPol']: - vals = [-val for val in vals] - var = {name:vals[i] for i,name in enumerate(quads)} - cond = {'range':'#e','mux':par['mu'],'muy':par['mu']} - res,twiss,tar = self.model.match(sequence=par['Sequence'], destination=par['Destination'],variables=var, conditions=cond, periodic=True) - par['Result']=tar - par['Twiss']=twiss - print(res) - self.manager.setFODOParameters(par) + vars = {} + for var in config['Variable']: + var0=var.replace('-','.').lower() + if 'mqua' in var0 or 'mqsk' in var0: + var0 += '.k1' + elif 'msex' in var0: + var0 += '.k2' + vars[var0]={'Min':-1e6,'Max':1e6,'Preset':0,'Step':0.00001} + + + + print(vars) + + + return + if not config['End'] == self.destination: + self.destination = config['End'] + self.model.setBranch(self.destination) + start=config['Reference']['Location'] + if not start in self.reference.reference.keys(): + return + twiss_in = self.reference.reference[start]['Twiss'] + twiss0 = {converttwiss[key]: twiss_in[key] for key in twiss_in.keys()} + twiss0['Energy']= 150.*1e-3 + loc = self.reference.reference[start]['Location'] + print(loc) + print(twiss0) + print(config['Variable']) +# + + + def matchold(self,sequence,destination, variables,conditions,periodic=False,plot=True): + self.setBranch(destination.upper()) + twiss={'energy0':150.} + self.madx.updateVariables(twiss) + res,twiss,tar=self.madx.match(sequence,variables,conditions,periodic) + energy = self.calcEnergyProfile(twiss) + matchtwiss={'betax':twiss.betx[0],'betay':twiss.bety[0],'alphax':twiss.alfx[0],'alphay':twiss.alfy[0]} + if plot: + self.parent.plot.newData(twiss, energy) + return res, matchtwiss,tar diff --git a/model.py b/model.py index 099d52a..68ba03a 100644 --- a/model.py +++ b/model.py @@ -6,7 +6,7 @@ from onlinemodel.core import Facility from onlinemodel.madx import CMadX converttwiss= {'betax':'betx','betay':'bety','alphax':'alfx','alphay':'alfy', - 'etax':'dx','etay':'dy','etapx':'dpx','etapy':'dpy', + 'etax':'dx','etay':'dy','etapx':'dpx','etapy':'dpy','mux':'mux','muy':'muy', 'x':'x','y':'y','px':'px','py':'py','energy':'energy'} @@ -26,6 +26,11 @@ class Model: # hook up events self.eventHandling() + def eventHandling(self): + self.parent.UITrack.clicked.connect(self.track) + self.parent.UIMatchSelected.clicked.connect(self.match) + + def getLatticeVersion(self): return self.om.Version @@ -123,9 +128,6 @@ class Model: print(settings['Energy']['energy']) print('Energy in system',self.om.EnergyAt(self.energyReference)[0]) - - - ##### very old code should be become obsolete after some nice matching files def updateModel(self): file ='SwissFELRef.json' @@ -165,20 +167,47 @@ class Model: ##############################33 # tracking - def eventHandling(self): - self.parent.UITrack.clicked.connect(self.track) - def match(self,sequence,destination, variables,conditions,periodic=False,plot=True): - self.setBranch(destination.upper()) - twiss={'energy0':150.} - self.madx.updateVariables(twiss) - res,twiss,tar=self.madx.match(sequence,variables,conditions,periodic) - energy = self.calcEnergyProfile(twiss) - matchtwiss={'betax':twiss.betx[0],'betay':twiss.bety[0],'alphax':twiss.alfx[0],'alphay':twiss.alfy[0]} + def match(self): + config = self.parent.reference.getMatchingPoint() + self.setBranch(config['Destination']) + if config['Reference'] is None: + start='#s' + end='#e' + itwiss=None + else: + start=config['Reference']['Location'] + if start.upper() == 'START': + start='#s' + end = config['End']+'$end' + itwiss = {converttwiss[key.lower()]:config['Reference']['Twiss'][key] for key in config['Reference']['Twiss'].keys()} + var={} + for key in config['Variable'].keys(): + key0=key.replace('-','.').lower() + if 'mqua' or 'mqsk' in key0: + key0+='.k1' + elif 'msex' in key0: + key0+='.k2' + var[key0]=config['Variable'][key] + conf0={} + for key in config['Target'].keys(): + sconf = config['Target'][key] + conf0[key] = {converttwiss[key0.lower()]:sconf[key0] for key0 in sconf.keys()} + + + res,twiss,err=self.madx.match(sequence=config['Sequence'], start=start, end=end, + init=itwiss, var=var, const=conf0, + preset=False,random=False) + print(res) + print(err) + plot = True if plot: - self.parent.plot.newData(twiss, energy) - return res, matchtwiss,tar + energy = self.calcEnergyProfile(twiss) + print('Plotting') + self.parent.plot.newData(twiss,energy) + ################## + # tracking def track(self): start = str(self.parent.UITrackStart.text()).upper() @@ -187,12 +216,11 @@ class Model: start = start[0:7] if len(end)>7: end = end[0:7] - twiss0 = self.parent.reference.getReferencePoint() - refloc = self.parent.reference.getReferenceLocation().upper() - if refloc == 'START': + refloc, twiss0 = self.parent.reference.getReference() + + if refloc.upper() == 'START': refloc = start.upper() twiss0['energy'] = self.startEnergy*1e-3 # convert to GeV for madx - start, end = self.checkRange(start, end, refloc[0:7]) if start is None: return diff --git a/plot.py b/plot.py index 015b797..f4f4795 100644 --- a/plot.py +++ b/plot.py @@ -102,6 +102,7 @@ class OpticsPlot(QtWidgets.QMainWindow, Ui_OpticsPlotGUI): self.energyref=copy.deepcopy(self.energy) def newData(self,twiss,energy): + print('Updating Plotting Data') self.twiss=twiss self.energy=energy self.updateOpticsTable() diff --git a/reference.py b/reference.py index 027945e..755de74 100644 --- a/reference.py +++ b/reference.py @@ -1,7 +1,23 @@ +import json + +from PyQt5 import QtCore, QtGui, QtWidgets +from fontTools.misc.cython import returns + +CBeige = QtGui.QColor(250, 240, 200) +CGreen = QtGui.QColor(100, 255, 100) +CYellow = QtGui.QColor(255, 255, 0) +CRed = QtGui.QColor(255, 100, 100) + + + + class ReferenceManager: def __init__(self, parent): self.parent = parent + self.settings={} self.reference={} + self.label=None + self.twisswidget={'betax':self.parent.UIBetax,'betay':self.parent.UIBetay, 'alphax':self.parent.UIAlphax,'alphay':self.parent.UIAlphay, 'etax':self.parent.UIEtax,'etay':self.parent.UIEtay, @@ -10,25 +26,176 @@ class ReferenceManager: 'px':self.parent.UIPX,'py':self.parent.UIPY} - self.defineReferencePoints() + self.loadReference('Settings/Reference.json') + self.parent.UITrackReference.currentIndexChanged.connect(self.updateReferenceWidgets) + #self.parent.UIMatchOrder.itemClicked.connect(self.updateMatchingPoint) + + + + def loadReference(self, filename): + with open(filename) as f: + self.settings = json.load(f) + self.order={ele['MatchID']:i for i,ele in enumerate(self.settings['Order'])} + self.reference=self.settings['Reference'] + self.label=self.settings['Label'] + self.parameter=self.settings['Parameter'] + self.parent.UIMatchSequenceLabel.setText(self.label) self.updateReferenceComboBox() self.updateReferenceWidgets() - self.parent.UITrackReference.currentIndexChanged.connect(self.updateReferenceWidgets) + self.updateMatchOrder() + def getMatchingPoint(self): + idx = self.parent.UIMatchOrder.currentRow() + if idx < 0: + return None + + ID = str(self.parent.UIMatchOrder.item(idx).text()) + print('Matching Step Label:', ID) + idx = self.order[ID] # get index in the list + order = self.settings['Order'][idx] # getting the specific entry from the order list + if not order['Reference'] is None: # has a fixed referenc epoint instead of periodic solution + twiss0 = self.getReferenceByTag(order['Reference']) # get the starting parameters by its reference + order['Reference'] = twiss0 # put it back into the order variable + order['Variable'] = self.parameter[ID]['Variable'] + nvar = len(order['Variable'].keys()) + target0= self.parameter[ID]['Target'] + target = {} + ncon = 0 + for tar in target0: + if 'Reference' in tar.keys(): + par=self.getReferenceByTag(tar['Reference']) + loc = par['Location'] + con = {key:{'Val':par['Twiss'][key],'Condition':0} for key in par['Twiss'].keys()} + target[loc]=con + ncon += len(con.keys()) + elif 'Fixed' in tar.keys(): + loc=tar['Fixed']['Location'] + con = {key: {'Val': tar['Fixed']['Twiss'][key], 'Condition': 0} for key in tar['Fixed']['Twiss'].keys()} + target[loc]=con + ncon += len(con.keys()) + if nvar>ncon: + dummycon={} + for key in order['Reference']['Twiss'].keys(): + if ncon < nvar: + dummycon[key]={'Val':order['Reference']['Twiss'][key],'Condition':0} + ncon+=1 + target['#s']=dummycon + order['Target'] = target + return order -#### all event selecting some tracking points + +#-------------------------------- +# match info + def updateMatchOrder(self): + self.parent.UIMatchOrder.clear() + for i,ele in enumerate(self.settings['Order']): + self.parent.UIMatchOrder.addItem(ele['MatchID']) + self.parent.UIMatchOrder.item(i).setBackground(CBeige) + + def updateMatchingPoint(self): + idx = self.parent.UIMatchOrder.currentRow() + if idx < 0: + return + ID = str(self.parent.UIMatchOrder.item(idx).text()) + idx = self.order[ID] + order=self.settings['Order'][idx] + reference = order['Reference'] + type = order['Type'] + loc = self.reference[reference]['Location'] + self.parent.UIMatchLabel.setText(ID) + self.parent.UIMatchType.setText(type) + self.parent.UIMatchStart.setText(loc) + if type == 'Periodic': + var,tar=self.updateMatchPointPeriodic(ID) + elif type == 'Fixed': + var,tar=self.updateMatchPointFixed(ID) + else: + return + if var is None: + var =[] + tar = [] + self.updateKnobs(var) + self.updateTargets(tar) + + def updateMatchPointFixed(self, ID): + if not ID in self.reference.keys(): + return + var = self.settings['Fixed'][ID]['Variable'] + reflab = self.settings['Fixed'][ID]['Reference'] + if not reflab in self.reference.keys(): + return None, None + ref=self.reference[reflab] + tar=[] + for ele in ref['Twiss'].keys(): + ele0 = ele.replace('beta','bet').replace('alpha','alf').upper() + tar.append({'Parameter':ele0,'Condition':'=','Value':ref['Twiss'][ele],'Location':ref['Location']}) + return var,tar + + + + def updateMatchPointPeriodic(self,ID): + if not ID in self.settings['Periodic'].keys(): + return None, None + var = self.settings['Periodic'][ID]['Variable'] + tar = self.settings['Periodic'][ID]['Target'] + return var,tar + + def updateKnobs(self,var): + self.parent.UIMatchKnobs.clear() + for ele in var: + self.parent.UIMatchKnobs.addItem(ele) + + def updateTargets(self,tar): + self.parent.UIMatchTargets.clear() + self.parent.UIMatchTargets.setColumnCount(4) + self.parent.UIMatchTargets.setRowCount(len(tar)) + for irow,ele in enumerate(tar): + self.parent.UIMatchTargets.setItem(irow, 0, QtWidgets.QTableWidgetItem(ele['Parameter'])) + self.parent.UIMatchTargets.setItem(irow, 1, QtWidgets.QTableWidgetItem(ele['Condition'])) + self.parent.UIMatchTargets.setItem(irow, 2, QtWidgets.QTableWidgetItem('%7.3f' % ele['Value'])) + self.parent.UIMatchTargets.setItem(irow, 3, QtWidgets.QTableWidgetItem(ele['Location'])) + self.parent.UIMatchTargets.resizeColumnsToContents() + self.parent.UIMatchTargets.verticalHeader().hide() + self.parent.UIMatchTargets.horizontalHeader().hide() + +#-------------------------------- +# obtaining reference data + def getReference(self): + return self.getReferenceLocation(),self.getReferenceTwiss() + + def getReferenceByTag(self,tag): + if not tag in self.reference.keys(): + return None + return self.reference[tag] + + + def getReferenceTwiss(self): + self.updateReferenceWidgets() # enforce that the data is consistent + twiss = {key:float(str(self.twisswidget[key].text())) for key in self.twisswidget.keys()} + return twiss + + def getReferenceLocation(self): + return str(self.parent.UITrackLocation.text()) + + +##### interaction of the tracking reference point + def swithToUserDefinedLocation(self): n = self.parent.UITrackReference.count() self.parent.UITrackReference.setCurrentIndex(n-1) - def updateReferenceLocation(self,location): - self.parent.UITrackLocation.setText(location) + def updateReferenceWidgets(self): + key = str(self.parent.UITrackReference.currentText()) + if key == 'User Defined': + return - def updateReferencePoint(self,twiss): + twiss = self.reference[key]['Twiss'] + name = self.reference[key]['Location'] + self.parent.UITrackLocation.setText(name) for key in self.twisswidget.keys(): if key in twiss.keys(): value = twiss[key] @@ -38,62 +205,9 @@ class ReferenceManager: value = 30 self.twisswidget[key].setText('%7.3f' % value) - def getReferencePoint(self): - self.updateReferenceWidgets() # enforce that the data is consistent - twiss = {key:float(str(self.twisswidget[key].text())) for key in self.twisswidget.keys()} - return twiss - - def getReferenceLocation(self): - return str(self.parent.UITrackLocation.text()) - - - def updateReferenceWidgets(self): - key = str(self.parent.UITrackReference.currentText()) - if key == 'User Defined': - return - elif key == 'Start': - twiss = {key[0:-1]:self.parent.model.startTwiss[key] for key in self.parent.model.startTwiss.keys()} # strip of the zero - name = 'Start' - else: - twiss = self.reference['Reference'][key]['twiss'] - name = self.reference['Reference'][key]['location'] - self.updateReferenceLocation(name) - self.updateReferencePoint(twiss) - def updateReferenceComboBox(self): self.parent.UITrackReference.clear() - self.parent.UITrackReference.addItem('Start') - for ref in self.reference['Reference'].keys(): + for ref in self.reference.keys(): self.parent.UITrackReference.addItem(ref) self.parent.UITrackReference.addItem('User Defined') - def defineReferencePoints(self): - self.reference={'Reference':{}} - self.reference['Reference']['Laser Heater']=self.defineRef('sinlh02.mqua410$start', - {'betax':11.2,'alphax':3.2, - 'betay':0.8,'alphay':0.75}) - self.reference['Reference']['Bunch Compressor1']=self.defineRef('sindi02.mqua020$start', - {'betax': 11.1557,'alphax': -1.17, - 'betay': 50, 'alphay': 0.}) - self.reference['Reference']['Bunch Compressor 2']=self.defineRef('s10ma01.mqua020$start', - {'betax': 6.14, 'alphax': -0.83, - 'betay': 22.86,'alphay': -1.18}) - self.reference['Reference']['Switchyard']=self.defineRef('s20sy02.mqua070$start', - {'betax': 12.99, 'alphax': 3.7011, - 'betay': 46.339,'alphay': -6.501}) - self.reference['Reference']['Linac3']=self.defineRef('s30cb10.mqua430$start', - {'betax': 8.83, 'alphax': 0.548, - 'betay': 30.44, 'alphay': -1.866}) - self.reference['Reference']['Aramis Stopper']=self.defineRef('sarma01.mqua010$start', - {'betax': 2.304, 'alphax': -1.4045, - 'betay': 25.929, 'alphay': -6.363}) - self.reference['Reference']['Athos HERO']=self.defineRef('satdi01.mqua250$start', - {'betax': 35.76, 'alphax': -1.166, - 'betay': 24.087, 'alphay': 0.648}) - self.reference['Reference']['Athos Deflector']=self.defineRef('satbd01.mqua010$start', - {'betax': 50, 'alphax': 0, - 'betay': 50, 'alphay': 0}) - - def defineRef(self,location,twiss): - ref={'location':location,'twiss':twiss} - return ref \ No newline at end of file diff --git a/ui/OpticsToolsGui.py b/ui/OpticsToolsGui.py index 5a01f7f..7a3b7cd 100644 --- a/ui/OpticsToolsGui.py +++ b/ui/OpticsToolsGui.py @@ -34,18 +34,6 @@ class Ui_OpticsGUI(object): self.widget_2.setObjectName("widget_2") self.verticalLayout = QtWidgets.QVBoxLayout(self.widget_2) self.verticalLayout.setObjectName("verticalLayout") - self.UISettingState = QtWidgets.QComboBox(self.widget_2) - font = QtGui.QFont() - font.setPointSize(12) - font.setBold(True) - font.setWeight(75) - self.UISettingState.setFont(font) - self.UISettingState.setObjectName("UISettingState") - self.UISettingState.addItem("") - self.UISettingState.addItem("") - self.UISettingState.addItem("") - self.UISettingState.addItem("") - self.verticalLayout.addWidget(self.UISettingState) self.UITrack = QtWidgets.QPushButton(self.widget_2) font = QtGui.QFont() font.setPointSize(12) @@ -437,6 +425,102 @@ class Ui_OpticsGUI(object): self.TabMaster.addTab(self.tab, "") self.tab_2 = QtWidgets.QWidget() self.tab_2.setObjectName("tab_2") + self.horizontalLayout_9 = QtWidgets.QHBoxLayout(self.tab_2) + self.horizontalLayout_9.setObjectName("horizontalLayout_9") + self.verticalLayout_6 = QtWidgets.QVBoxLayout() + self.verticalLayout_6.setObjectName("verticalLayout_6") + self.label_22 = QtWidgets.QLabel(self.tab_2) + font = QtGui.QFont() + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_22.setFont(font) + self.label_22.setObjectName("label_22") + self.verticalLayout_6.addWidget(self.label_22) + self.horizontalLayout_8 = QtWidgets.QHBoxLayout() + self.horizontalLayout_8.setObjectName("horizontalLayout_8") + self.label_14 = QtWidgets.QLabel(self.tab_2) + self.label_14.setObjectName("label_14") + self.horizontalLayout_8.addWidget(self.label_14) + self.UIMatchSequenceLabel = QtWidgets.QLineEdit(self.tab_2) + self.UIMatchSequenceLabel.setText("") + self.UIMatchSequenceLabel.setObjectName("UIMatchSequenceLabel") + self.horizontalLayout_8.addWidget(self.UIMatchSequenceLabel) + self.verticalLayout_6.addLayout(self.horizontalLayout_8) + self.label_15 = QtWidgets.QLabel(self.tab_2) + self.label_15.setObjectName("label_15") + self.verticalLayout_6.addWidget(self.label_15) + self.UIMatchOrder = QtWidgets.QListWidget(self.tab_2) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.UIMatchOrder.sizePolicy().hasHeightForWidth()) + self.UIMatchOrder.setSizePolicy(sizePolicy) + self.UIMatchOrder.setObjectName("UIMatchOrder") + self.verticalLayout_6.addWidget(self.UIMatchOrder) + self.UIMatchAll = QtWidgets.QPushButton(self.tab_2) + self.UIMatchAll.setObjectName("UIMatchAll") + self.verticalLayout_6.addWidget(self.UIMatchAll) + self.UIMatchFromSelected = QtWidgets.QPushButton(self.tab_2) + self.UIMatchFromSelected.setObjectName("UIMatchFromSelected") + self.verticalLayout_6.addWidget(self.UIMatchFromSelected) + self.UIMatchSelected = QtWidgets.QPushButton(self.tab_2) + self.UIMatchSelected.setObjectName("UIMatchSelected") + self.verticalLayout_6.addWidget(self.UIMatchSelected) + self.horizontalLayout_9.addLayout(self.verticalLayout_6) + self.verticalLayout_7 = QtWidgets.QVBoxLayout() + self.verticalLayout_7.setObjectName("verticalLayout_7") + self.label_21 = QtWidgets.QLabel(self.tab_2) + font = QtGui.QFont() + font.setPointSize(12) + font.setBold(True) + font.setWeight(75) + self.label_21.setFont(font) + self.label_21.setObjectName("label_21") + self.verticalLayout_7.addWidget(self.label_21) + self.gridLayout_5 = QtWidgets.QGridLayout() + self.gridLayout_5.setObjectName("gridLayout_5") + self.label_16 = QtWidgets.QLabel(self.tab_2) + self.label_16.setObjectName("label_16") + self.gridLayout_5.addWidget(self.label_16, 0, 0, 1, 1) + self.UIMatchLabel = QtWidgets.QLineEdit(self.tab_2) + self.UIMatchLabel.setObjectName("UIMatchLabel") + self.gridLayout_5.addWidget(self.UIMatchLabel, 0, 1, 1, 1) + self.label_17 = QtWidgets.QLabel(self.tab_2) + self.label_17.setObjectName("label_17") + self.gridLayout_5.addWidget(self.label_17, 1, 0, 1, 1) + self.UIMatchStart = QtWidgets.QLineEdit(self.tab_2) + self.UIMatchStart.setObjectName("UIMatchStart") + self.gridLayout_5.addWidget(self.UIMatchStart, 1, 1, 1, 1) + self.label_18 = QtWidgets.QLabel(self.tab_2) + self.label_18.setObjectName("label_18") + self.gridLayout_5.addWidget(self.label_18, 2, 0, 1, 1) + self.UIMatchType = QtWidgets.QLineEdit(self.tab_2) + self.UIMatchType.setObjectName("UIMatchType") + self.gridLayout_5.addWidget(self.UIMatchType, 2, 1, 1, 1) + self.verticalLayout_7.addLayout(self.gridLayout_5) + self.label_19 = QtWidgets.QLabel(self.tab_2) + self.label_19.setObjectName("label_19") + self.verticalLayout_7.addWidget(self.label_19) + self.UIMatchKnobs = QtWidgets.QListWidget(self.tab_2) + sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Expanding) + sizePolicy.setHorizontalStretch(0) + sizePolicy.setVerticalStretch(0) + sizePolicy.setHeightForWidth(self.UIMatchKnobs.sizePolicy().hasHeightForWidth()) + self.UIMatchKnobs.setSizePolicy(sizePolicy) + self.UIMatchKnobs.setObjectName("UIMatchKnobs") + self.verticalLayout_7.addWidget(self.UIMatchKnobs) + self.label_20 = QtWidgets.QLabel(self.tab_2) + self.label_20.setObjectName("label_20") + self.verticalLayout_7.addWidget(self.label_20) + self.UIMatchTargets = QtWidgets.QTableWidget(self.tab_2) + self.UIMatchTargets.setObjectName("UIMatchTargets") + self.UIMatchTargets.setColumnCount(0) + self.UIMatchTargets.setRowCount(0) + self.verticalLayout_7.addWidget(self.UIMatchTargets) + self.horizontalLayout_9.addLayout(self.verticalLayout_7) + spacerItem4 = QtWidgets.QSpacerItem(242, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) + self.horizontalLayout_9.addItem(spacerItem4) self.TabMaster.addTab(self.tab_2, "") self.verticalLayout_4.addWidget(self.TabMaster) OpticsGUI.setCentralWidget(self.centralwidget) @@ -567,18 +651,13 @@ class Ui_OpticsGUI(object): self.menubar.addAction(self.menuHelp.menuAction()) self.retranslateUi(OpticsGUI) - self.TabMaster.setCurrentIndex(0) - self.UISettingState.setCurrentIndex(1) + self.TabMaster.setCurrentIndex(3) self.actionQuit.triggered.connect(OpticsGUI.close) # type: ignore QtCore.QMetaObject.connectSlotsByName(OpticsGUI) def retranslateUi(self, OpticsGUI): _translate = QtCore.QCoreApplication.translate OpticsGUI.setWindowTitle(_translate("OpticsGUI", "SwissFEL Optics")) - self.UISettingState.setItemText(0, _translate("OpticsGUI", "Machine")) - self.UISettingState.setItemText(1, _translate("OpticsGUI", "Reference")) - self.UISettingState.setItemText(2, _translate("OpticsGUI", "User Settings")) - self.UISettingState.setItemText(3, _translate("OpticsGUI", "Sandbox")) self.UITrack.setText(_translate("OpticsGUI", "Track")) self.UITrackStart.setText(_translate("OpticsGUI", "SINLH01")) self.label_2.setText(_translate("OpticsGUI", "End-Section")) @@ -634,7 +713,19 @@ class Ui_OpticsGUI(object): self.checkBox.setText(_translate("OpticsGUI", "Random Initialization")) self.label_13.setText(_translate("OpticsGUI", "Result")) self.TabMaster.setTabText(self.TabMaster.indexOf(self.tab), _translate("OpticsGUI", "Absolute Matching")) - self.TabMaster.setTabText(self.TabMaster.indexOf(self.tab_2), _translate("OpticsGUI", "Relative Matching")) + self.label_22.setText(_translate("OpticsGUI", "Matching Procedure")) + self.label_14.setText(_translate("OpticsGUI", "Label")) + self.label_15.setText(_translate("OpticsGUI", "Order")) + self.UIMatchAll.setText(_translate("OpticsGUI", "Match From Start")) + self.UIMatchFromSelected.setText(_translate("OpticsGUI", "Match From Selected")) + self.UIMatchSelected.setText(_translate("OpticsGUI", "Match Selected")) + self.label_21.setText(_translate("OpticsGUI", "Matching Point")) + self.label_16.setText(_translate("OpticsGUI", "Match")) + self.label_17.setText(_translate("OpticsGUI", "Start")) + self.label_18.setText(_translate("OpticsGUI", "Type")) + self.label_19.setText(_translate("OpticsGUI", "Knobs")) + self.label_20.setText(_translate("OpticsGUI", "Target")) + self.TabMaster.setTabText(self.TabMaster.indexOf(self.tab_2), _translate("OpticsGUI", "Matching")) self.menuFile.setTitle(_translate("OpticsGUI", "File")) self.menuHelp.setTitle(_translate("OpticsGUI", "Help")) self.actionOpen_2.setText(_translate("OpticsGUI", "Open Settings...")) diff --git a/ui/OpticsToolsGui.ui b/ui/OpticsToolsGui.ui index b13f107..6ce3b2e 100644 --- a/ui/OpticsToolsGui.ui +++ b/ui/OpticsToolsGui.ui @@ -34,40 +34,6 @@ - - - - - 12 - 75 - true - - - - 1 - - - - Machine - - - - - Reference - - - - - User Settings - - - - - Sandbox - - - - @@ -772,21 +738,176 @@ - Relative Matching + Matching - - - - 10 - 10 - 301 - 241 - - - - GroupBox - - + + + + + + + + 12 + 75 + true + + + + Matching Procedure + + + + + + + + + Label + + + + + + + + + + + + + + + + Order + + + + + + + + 0 + 0 + + + + + + + + Match From Start + + + + + + + Match From Selected + + + + + + + Match Selected + + + + + + + + + + + + 12 + 75 + true + + + + Matching Point + + + + + + + + + Match + + + + + + + + + + Start + + + + + + + + + + Type + + + + + + + + + + + + Knobs + + + + + + + + 0 + 0 + + + + + + + + Target + + + + + + + + + + + + Qt::Horizontal + + + + 242 + 20 + + + + +