214 lines
7.9 KiB
Python
214 lines
7.9 KiB
Python
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,
|
|
'etapx':self.parent.UIEtapx,'etapy':self.parent.UIEtapy,
|
|
'x':self.parent.UIX,'y':self.parent.UIY,
|
|
'px':self.parent.UIPX,'py':self.parent.UIPY}
|
|
|
|
|
|
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.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
|
|
|
|
|
|
|
|
#--------------------------------
|
|
# 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 updateReferenceWidgets(self):
|
|
key = str(self.parent.UITrackReference.currentText())
|
|
if key == 'User Defined':
|
|
return
|
|
|
|
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]
|
|
else:
|
|
value = 0
|
|
if 'beta' in key:
|
|
value = 30
|
|
self.twisswidget[key].setText('%7.3f' % value)
|
|
|
|
def updateReferenceComboBox(self):
|
|
self.parent.UITrackReference.clear()
|
|
for ref in self.reference.keys():
|
|
self.parent.UITrackReference.addItem(ref)
|
|
self.parent.UITrackReference.addItem('User Defined')
|
|
|