def set_sp(self):
"""set energy entry for when sp model changes"""
self.sp_table.setRowCount(0)
if self.sp_selector.currentIndex() >= 0:
fr = self.sp_selector.currentData()
self.check_geometry_rmsd("SP")
self.sp_table.insertRow(0)
nrg_label = QLabel("E =")
nrg_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.sp_table.setCellWidget(0, 0, nrg_label)
unit_label = ReadOnlyTableItem()
unit_label.setData(Qt.DisplayRole, "E\u2095")
unit_label.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.sp_table.setItem(0, 2, unit_label)
sp_nrg = SmallLineEdit("%.6f" % fr.other['energy'])
sp_nrg.setReadOnly(True)
sp_nrg.setFrame(False)
self.sp_table.setCellWidget(0, 1, sp_nrg)
self.sp_table.resizeRowToContents(0)
self.sp_table.resizeColumnToContents(0)
self.sp_table.resizeColumnToContents(1)
self.sp_table.resizeColumnToContents(2)
self.update_sum()
def __init__(self):
super().__init__()
if separate_colorbars:
if rescale_colorbars:
self.vmins = tuple(np.min(u[0]) for u in U)
self.vmaxs = tuple(np.max(u[0]) for u in U)
else:
self.vmins = tuple(np.min(u) for u in U)
self.vmaxs = tuple(np.max(u) for u in U)
else:
if rescale_colorbars:
self.vmins = (min(np.min(u[0]) for u in U),) * len(U)
self.vmaxs = (max(np.max(u[0]) for u in U),) * len(U)
else:
self.vmins = (min(np.min(u) for u in U),) * len(U)
self.vmaxs = (max(np.max(u) for u in U),) * len(U)
layout = QHBoxLayout()
plot_layout = QGridLayout()
self.colorbarwidgets = [cbar_widget(self, vmin=vmin, vmax=vmax) if cbar_widget else None
for vmin, vmax in zip(self.vmins, self.vmaxs)]
plots = [widget(self, grid, vmin=vmin, vmax=vmax, bounding_box=bounding_box, codim=codim)
for vmin, vmax in zip(self.vmins, self.vmaxs)]
if legend:
for i, plot, colorbar, l in zip(range(len(plots)), plots, self.colorbarwidgets, legend):
subplot_layout = QVBoxLayout()
caption = QLabel(l)
caption.setAlignment(Qt.AlignHCenter)
subplot_layout.addWidget(caption)
if not separate_colorbars or backend == 'matplotlib':
subplot_layout.addWidget(plot)
else:
hlayout = QHBoxLayout()
hlayout.addWidget(plot)
if colorbar:
hlayout.addWidget(colorbar)
subplot_layout.addLayout(hlayout)
plot_layout.addLayout(subplot_layout, int(i/columns), (i % columns), 1, 1)
else:
for i, plot, colorbar in zip(range(len(plots)), plots, self.colorbarwidgets):
if not separate_colorbars or backend == 'matplotlib':
plot_layout.addWidget(plot, int(i/columns), (i % columns), 1, 1)
else:
hlayout = QHBoxLayout()
hlayout.addWidget(plot)
if colorbar:
hlayout.addWidget(colorbar)
plot_layout.addLayout(hlayout, int(i/columns), (i % columns), 1, 1)
layout.addLayout(plot_layout)
if not separate_colorbars:
layout.addWidget(self.colorbarwidgets[0])
for w in self.colorbarwidgets[1:]:
w.setVisible(False)
self.setLayout(layout)
self.plots = plots
def __init__(self):
super().__init__()
if separate_colorbars:
if rescale_colorbars:
self.vmins = tuple(np.min(u[0]) for u in U)
self.vmaxs = tuple(np.max(u[0]) for u in U)
else:
self.vmins = tuple(np.min(u) for u in U)
self.vmaxs = tuple(np.max(u) for u in U)
else:
if rescale_colorbars:
self.vmins = (min(np.min(u[0]) for u in U),) * len(U)
self.vmaxs = (max(np.max(u[0]) for u in U),) * len(U)
else:
self.vmins = (min(np.min(u) for u in U),) * len(U)
self.vmaxs = (max(np.max(u) for u in U),) * len(U)
layout = QHBoxLayout()
plot_layout = QGridLayout()
self.colorbarwidgets = [cbar_widget(self, vmin=vmin, vmax=vmax) if cbar_widget else None
for vmin, vmax in zip(self.vmins, self.vmaxs)]
plots = [widget(self, grid, vmin=vmin, vmax=vmax, bounding_box=bounding_box, codim=codim)
for vmin, vmax in zip(self.vmins, self.vmaxs)]
if legend:
for i, plot, colorbar, l in zip(range(len(plots)), plots, self.colorbarwidgets, legend):
subplot_layout = QVBoxLayout()
caption = QLabel(l)
caption.setAlignment(Qt.AlignHCenter)
subplot_layout.addWidget(caption)
if not separate_colorbars or backend == 'matplotlib':
subplot_layout.addWidget(plot)
else:
hlayout = QHBoxLayout()
hlayout.addWidget(plot)
if colorbar:
hlayout.addWidget(colorbar)
subplot_layout.addLayout(hlayout)
plot_layout.addLayout(subplot_layout, int(i/columns), (i % columns), 1, 1)
else:
for i, plot, colorbar in zip(range(len(plots)), plots, self.colorbarwidgets):
if not separate_colorbars or backend == 'matplotlib':
plot_layout.addWidget(plot, int(i/columns), (i % columns), 1, 1)
else:
hlayout = QHBoxLayout()
hlayout.addWidget(plot)
if colorbar:
hlayout.addWidget(colorbar)
plot_layout.addLayout(hlayout, int(i/columns), (i % columns), 1, 1)
layout.addLayout(plot_layout)
if not separate_colorbars:
layout.addWidget(self.colorbarwidgets[0])
for w in self.colorbarwidgets[1:]:
w.setVisible(False)
self.setLayout(layout)
self.plots = plots
def update_sum(self):
"""updates the sum of energy and thermo corrections"""
self.sum_table.setRowCount(0)
if not self.sp_table.rowCount():
return
sp_nrg = float(self.sp_table.cellWidget(0, 1).text())
for row in range(0, self.thermo_table.rowCount()):
self.sum_table.insertRow(row)
label = self.thermo_table.cellWidget(row, 0)
tooltip = label.toolTip()
text = label.text().replace("𝛿", "")
sum_label = QLabel(text)
if "href=" in text:
sum_label = QLabel()
sum_label.setText(text)
sum_label.setTextFormat(Qt.RichText)
sum_label.setTextInteractionFlags(Qt.TextBrowserInteraction)
sum_label.linkActivated.connect(self.open_link)
sum_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
sum_label.setToolTip(tooltip)
self.sum_table.setCellWidget(row, 0, sum_label)
thermo = float(self.thermo_table.cellWidget(row, 1).text())
total = sp_nrg + thermo
total_nrg = SmallLineEdit("%.6f" % total)
total_nrg.setFrame(False)
total_nrg.setReadOnly(True)
total_nrg.setToolTip(tooltip)
self.sum_table.setCellWidget(row, 1, total_nrg)
unit_label = ReadOnlyTableItem()
unit_label.setData(Qt.DisplayRole, "E\u2095")
unit_label.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
unit_label.setToolTip(tooltip)
self.sum_table.setItem(row, 2, unit_label)
self.sum_table.resizeRowToContents(row)
self.sum_table.resizeColumnToContents(0)
self.sum_table.resizeColumnToContents(1)
self.sum_table.resizeColumnToContents(2)
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(self.style().standardIcon(QStyle.SP_MediaPlay), 'Play', self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(self.style().standardIcon(QStyle.SP_MediaSeekBackward), 'Rewind', self)
self.a_toend = QAction(self.style().standardIcon(QStyle.SP_MediaSeekForward), 'End', self)
self.a_step_backward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(self.style().standardIcon(QStyle.SP_MediaSkipForward), 'Step', self)
self.a_loop = QAction(self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop', self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(self.style().standardIcon(QStyle.SP_DialogSaveButton), 'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
class MayaShelf(abstract_shelf.AbstractShelf, object):
def __init__(self, name='MayaShelf', label_background=(0, 0, 0, 0), label_color=(0.9, 0.9, 0.9),
category_icon=None, enable_labels=True):
super(MayaShelf, self).__init__(name=name, label_background=label_background, label_color=label_color,
category_icon=category_icon, enable_labels=enable_labels)
@staticmethod
def add_menu_item(parent, label, command='', icon=''):
"""
Adds a menu item with the given attributes
:param parent:
:param label:
:param command:
:param icon:
:return:
"""
return maya.cmds.menuItem(parent=parent, label=label, command=command, image=icon or '')
@staticmethod
def add_sub_menu(parent, label, icon=None):
"""
Adds a sub menu item with the given label and icon to the given parent popup menu
:param parent:
:param label:
:param icon:
:return:
"""
return maya.cmds.menuItem(parent=parent, label=label, icon=icon or '', subMenu=True)
def create(self, delete_if_exists=True):
"""
Creates a new shelf
"""
if delete_if_exists:
if gui.shelf_exists(shelf_name=self._name):
gui.delete_shelf(shelf_name=self._name)
else:
assert not gui.shelf_exists(self._name), 'Shelf with name {} already exists!'.format(self._name)
self._name = gui.create_shelf(name=self._name)
# ========================================================================================================
self._category_btn = QPushButton('')
if self._category_icon:
self._category_btn.setIcon(self._category_icon)
self._category_btn.setIconSize(QSize(18, 18))
self._category_menu = QMenu(self._category_btn)
self._category_btn.setStyleSheet(
'QPushButton::menu-indicator {image: url(myindicator.png);'
'subcontrol-position: right center;subcontrol-origin: padding;left: -2px;}')
self._category_btn.setMenu(self._category_menu)
self._category_lbl = QLabel('MAIN')
self._category_lbl.setAlignment(Qt.AlignCenter)
font = self._category_lbl.font()
font.setPointSize(6)
self._category_lbl.setFont(font)
menu_ptr = maya.OpenMayaUI.MQtUtil.findControl(self._name)
menu_widget = qtutils.wrapinstance(menu_ptr, QWidget)
menu_widget.layout().addWidget(self._category_btn)
menu_widget.layout().addWidget(self._category_lbl)
self.add_separator()
def set_as_active(self):
"""
Sets this shelf as active shelf in current DCC session
"""
main_shelf = maya.mel.eval("$_tempVar = $gShelfTopLevel")
maya.cmds.tabLayout(main_shelf, edit=True, selectTab=self._name)
def add_button(self, label, tooltip=None, icon='customIcon.png', command=None,
double_command=None, command_type='python'):
"""
Adds a shelf button width the given parameters
:param label:
:param tooltip:
:param icon:
:param command:
:param double_command:
:param command_type:
:return:
"""
maya.cmds.setParent(self._name)
command = command or ''
double_command = double_command or ''
if not self._enable_labels:
label = ''
return maya.cmds.shelfButton(width=37, height=37, image=icon or '', label=label, command=command,
doubleClickCommand=double_command, annotation=tooltip or '',
imageOverlayLabel=label, overlayLabelBackColor=self._label_background,
overlayLabelColor=self._label_color, sourceType=command_type)
def add_separator(self):
"""
Adds a separator to shelf
:param parent:
:return:
"""
maya.cmds.separator(
parent=self._name, manage=True, visible=True, horizontal=False, style='shelf',
enableBackground=False, preventOverride=False)
def build_category(self, shelf_file, category_name):
self._category_lbl.setText(category_name.upper())
self.load_category(shelf_file, 'general', clear=True)
if category_name != 'general':
self.add_separator()
self.load_category(shelf_file, category_name, clear=False)
def build_categories(self, shelf_file, categories):
"""
Builds all categories given
:param categories: list<str>, list of categories to build
"""
self._category_lbl.setText('ALL')
self.load_category(shelf_file, 'general', clear=True)
for cat in categories:
if cat == 'general':
continue
self.add_separator()
self.load_category(shelf_file, cat, clear=False)
def load_category(self, shelf_file, category_name, clear=True):
"""
Loads into a shelf all the items of given category name, if exists
:param category_name: str, name of the category
"""
if clear:
self.clear_list()
# self.add_separator()
with open(shelf_file) as f:
shelf_data = json.load(f, object_pairs_hook=OrderedDict)
for item, item_data in shelf_data.items():
if item != category_name:
continue
for i in item_data:
icon = i.get('icon')
command = i.get('command')
annotation = i.get('annotation')
label = i.get('label')
if annotation == 'separator':
self.add_separator()
else:
self.add_button(label=label, command=command, icon=icon, tooltip=annotation)
return
def build(self, shelf_file):
"""
Builds shelf from JSON file
:param shelf_file: str
"""
first_item = None
all_categories = list()
with open(shelf_file) as f:
shelf_data = json.load(f, object_pairs_hook=OrderedDict)
for i, item in enumerate(shelf_data.keys()):
if i == 0:
first_item = item
category_action = self._category_menu.addAction(item.title())
category_action.triggered.connect(partial(self.build_category, shelf_file, item))
all_categories.append(item)
category_action = self._category_menu.addAction('All')
category_action.triggered.connect(partial(self.build_categories, shelf_file, all_categories))
if first_item:
self.load_category(shelf_file, first_item, clear=False)
def clear_list(self):
"""
Clears all the elements of the shelf
"""
if gui.shelf_exists(shelf_name=self._name):
menu_items = maya.cmds.shelfLayout(self._name, query=True, childArray=True)
for item in menu_items:
try:
maya.cmds.deleteUI(item)
except Exception:
pass
class BaseColorDialog(BaseDialog, object):
def_title = 'Select Color'
maya_colors = [(.467, .467, .467), (.000, .000, .000), (.247, .247, .247),
(.498, .498, .498), (0.608, 0, 0.157), (0, 0.016, 0.373),
(0, 0, 1), (0, 0.275, 0.094), (0.145, 0, 0.263),
(0.78, 0, 0.78), (0.537, 0.278, 0.2), (0.243, 0.133, 0.122),
(0.6, 0.145, 0), (1, 0, 0), (0, 1, 0), (0, 0.255, 0.6),
(1, 1, 1), (1, 1, 0), (0.388, 0.863, 1), (0.263, 1, 0.635),
(1, 0.686, 0.686), (0.89, 0.675, 0.475), (1, 1, 0.384),
(0, 0.6, 0.325), (0.627, 0.412, 0.188),
(0.62, 0.627, 0.188), (0.408, 0.627, 0.188),
(0.188, 0.627, 0.365), (0.188, 0.627, 0.627),
(0.188, 0.404, 0.627), (0.435, 0.188, 0.627),
(0.627, 0.188, 0.404)]
def __init__(self, name='MayaColorDialog', parent=None, **kwargs):
parent = parent or dcc.get_main_window()
super(BaseColorDialog, self).__init__(name=name,
parent=parent,
**kwargs)
self._color = None
def get_color(self):
return self._color
color = property(get_color)
def ui(self):
self.color_buttons = list()
super(BaseColorDialog, self).ui()
grid_layout = layouts.GridLayout()
grid_layout.setAlignment(Qt.AlignTop)
self.main_layout.addLayout(grid_layout)
color_index = 0
for i in range(0, 4):
for j in range(0, 8):
color_btn = QPushButton()
color_btn.setMinimumHeight(35)
color_btn.setMinimumWidth(35)
self.color_buttons.append(color_btn)
color_btn.setStyleSheet(
'background-color:rgb(%s,%s,%s);' %
(self.maya_colors[color_index][0] * 255,
self.maya_colors[color_index][1] * 255,
self.maya_colors[color_index][2] * 255))
grid_layout.addWidget(color_btn, i, j)
color_index += 1
selected_color_layout = layouts.HorizontalLayout()
self.main_layout.addLayout(selected_color_layout)
self.color_slider = QSlider(Qt.Horizontal)
self.color_slider.setMinimum(0)
self.color_slider.setMaximum(31)
self.color_slider.setValue(2)
self.color_slider.setStyleSheet(
"QSlider::groove:horizontal {border: 1px solid #999999;height: 25px; /* the groove expands "
"to the size of the slider by default. by giving it a height, it has a fixed size */background: "
"qlineargradient(x1:0, y1:0, x2:0, y2:1, stop:0 #B1B1B1, stop:1 #c4c4c4);margin: 2px 0;}"
"QSlider::handle:horizontal {background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #b4b4b4,"
" stop:1 #8f8f8f);border: 1px solid #5c5c5c;width: 10px;margin: -2px 0; /* handle is placed by "
"default on the contents rect of the groove. Expand outside the groove */border-radius: 1px;}"
)
selected_color_layout.addWidget(self.color_slider)
color_label_layout = layouts.HorizontalLayout(margins=(10, 10, 10, 10))
self.main_layout.addLayout(color_label_layout)
self.color_lbl = QLabel()
self.color_lbl.setStyleSheet(
"border: 1px solid black; background-color:rgb(0, 0, 0);")
self.color_lbl.setMinimumWidth(45)
self.color_lbl.setMaximumWidth(80)
self.color_lbl.setMinimumHeight(80)
self.color_lbl.setAlignment(Qt.AlignCenter)
color_label_layout.addWidget(self.color_lbl)
bottom_layout = layouts.HorizontalLayout()
bottom_layout.setAlignment(Qt.AlignRight)
self.main_layout.addLayout(bottom_layout)
self.ok_btn = QPushButton('Ok')
self.cancel_btn = QPushButton('Cancel')
bottom_layout.addLayout(dividers.DividerLayout())
bottom_layout.addWidget(self.ok_btn)
bottom_layout.addWidget(self.cancel_btn)
def setup_signals(self):
for i, btn in enumerate(self.color_buttons):
btn.clicked.connect(partial(self._on_set_color, i))
self.color_slider.valueChanged.connect(self._on_set_color)
self.ok_btn.clicked.connect(self._on_ok_btn)
self.cancel_btn.clicked.connect(self._on_cancel_btn)
def _on_set_color(self, color_index):
self.color_lbl.setStyleSheet('background-color:rgb(%s,%s,%s);' %
(self.maya_colors[color_index][0] * 255,
self.maya_colors[color_index][1] * 255,
self.maya_colors[color_index][2] * 255))
self.color_slider.setValue(color_index)
def _on_set_slider(self, color_index):
self._set_color(color_index=color_index)
def _on_ok_btn(self):
self._color = self.color_slider.value()
self.close()
def _on_cancel_btn(self):
self._color = None
self.close()
def set_thermo(self):
"""computes thermo corrections and sets thermo entries for when thermo model changes"""
#index of combobox is -1 when combobox has no entries
self.thermo_table.setRowCount(0)
if self.thermo_selector.currentIndex() >= 0:
fr = self.thermo_selector.currentData()
if fr not in self.thermo_co:
self.thermo_co[fr] = CompOutput(fr)
co = self.thermo_co[fr]
v0 = self.v0_edit.value()
if v0 != self.settings.w0:
self.settings.w0 = v0
T = self.temperature_line.value()
if not T:
return
dZPE = co.ZPVE
#compute enthalpy and entropy at this temperature
#AaronTools uses Grimme's Quasi-RRHO, but this is the same as RRHO when w0=0
dE, dH, s = co.therm_corr(temperature=T, v0=0, method="RRHO")
rrho_dg = dH - T * s
#compute G with quasi entropy treatments
qrrho_dg = co.calc_G_corr(v0=v0, temperature=T, method="QRRHO")
qharm_dg = co.calc_G_corr(v0=v0, temperature=T, method="QHARM")
items = [(
"𝛿ZPE =",
dZPE,
None,
"lowest energy the molecule can have\n"
"no rotational or vibrational modes populated\n"
"equal to enthalpy at 0 K",
)]
if fr.other["frequency"].anharm_data:
dZPE_anh = co.calc_zpe(anharmonic=True)
items.append((
"𝛿ZPE<sub>anh</sub> =",
dZPE_anh,
None,
"lowest energy the molecule can have\n"
"no rotational or vibrational modes populated\n"
"includes corrections for anharmonic vibrations",
))
items.extend([
(
"𝛿H<sub>RRHO</sub> =",
dH,
None,
"enthalpy of formation",
),
(
"𝛿G<sub>RRHO</sub> =",
rrho_dg,
None,
"energy after taking into account the average\n"
"population of vibrational, rotational, and translational\n"
"degrees of freedom",
),
(
"𝛿G<sub>Quasi-RRHO</sub> =",
qrrho_dg,
"Grimme's Quasi-RRHO",
"vibrational entropy of each real mode is damped and complemented\n"
"with rotational entropy, with the damping function being stronger for\n"
"frequencies < 𝜔\u2080\n"
"can mitigate error from inaccuracies in the harmonic oscillator\n"
"approximation for low-frequency vibrations",
),
(
"𝛿G<sub>Quasi-Harmonic</sub> =",
qharm_dg,
"Truhlar's Quasi-Harmonic",
"real vibrational frequencies below 𝜔\u2080 are treated as 𝜔\u2080\n"
"can mitigate error from inaccuracies in the harmonic oscillator\n"
"approximation for low-frequency vibrations",
),
])
for i, (label_text, val, link, tooltip) in enumerate(items):
self.thermo_table.insertRow(i)
label = QLabel(label_text)
if link:
label = QLabel()
label.setText(
"<a href=\"%s\" style=\"text-decoration: none;\">%s</a>"
% (link, label_text))
label.setTextFormat(Qt.RichText)
label.setTextInteractionFlags(Qt.TextBrowserInteraction)
label.linkActivated.connect(self.open_link)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
label.setToolTip(tooltip)
self.thermo_table.setCellWidget(i, 0, label)
unit_label = ReadOnlyTableItem()
unit_label.setData(Qt.DisplayRole, "E\u2095")
unit_label.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
unit_label.setToolTip(tooltip)
self.thermo_table.setItem(i, 2, unit_label)
d_nrg = SmallLineEdit("%.6f" % val)
d_nrg.setReadOnly(True)
d_nrg.setFrame(False)
d_nrg.setToolTip(tooltip)
self.thermo_table.setCellWidget(i, 1, d_nrg)
self.thermo_table.resizeRowToContents(i)
self.thermo_table.resizeColumnToContents(0)
self.thermo_table.resizeColumnToContents(1)
self.thermo_table.resizeColumnToContents(2)
self.update_sum()
def _addPin(self,
pinDirection,
dataType,
foo,
hideLabel=False,
bCreateInputWidget=True,
name='',
index=-1,
userStructClass=ENone,
defaultValue=None):
# check if pins with this name already exists and get uniq name
name = self.getUniqPinName(name)
p = CreatePin(name,
self,
dataType,
pinDirection,
userStructClass=userStructClass)
if defaultValue is not None:
p.setDefaultValue(defaultValue)
self.graph().pins[p.uid] = p
if pinDirection == PinDirection.Input and foo is not None:
p.call = foo
connector_name = QGraphicsProxyWidget()
connector_name.setObjectName('{0}PinConnector'.format(name))
connector_name.setContentsMargins(0, 0, 0, 0)
lblName = name
if hideLabel:
lblName = ''
p.bLabelHidden = True
lbl = QLabel(lblName)
p.nameChanged.connect(lbl.setText)
lbl.setContentsMargins(0, 0, 0, 0)
lbl.setAttribute(QtCore.Qt.WA_TranslucentBackground)
font = QtGui.QFont('Consolas')
color = Colors.PinNameColor
font.setPointSize(6)
lbl.setFont(font)
style = 'color: rgb({0}, {1}, {2}, {3});'.format(
color.red(), color.green(), color.blue(), color.alpha())
lbl.setStyleSheet(style)
connector_name.setWidget(lbl)
if pinDirection == PinDirection.Input:
container = self.addContainer(pinDirection)
if hideLabel:
container.setMinimumWidth(15)
lbl.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignTop)
container.layout().addItem(p)
p._container = container
container.layout().addItem(connector_name)
self.inputs[p.uid] = p
self.inputsLayout.insertItem(index, container)
container.adjustSize()
elif pinDirection == PinDirection.Output:
container = self.addContainer(pinDirection)
if hideLabel:
container.setMinimumWidth(15)
lbl.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignTop)
container.layout().addItem(connector_name)
container.layout().addItem(p)
p._container = container
self.outputs[p.uid] = p
self.outputsLayout.insertItem(index, container)
container.adjustSize()
p.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
# create member if created in runtime
if not hasattr(self, name):
setattr(self, name, p)
return p
class ProjectSettingsWidget(base.BaseWidget, object):
exitSettings = Signal()
def __init__(self, project=None, parent=None):
self._project = None
super(ProjectSettingsWidget, self).__init__(parent=parent)
self._fill_version_types_combo()
if project:
self.set_project(project)
def ui(self):
super(ProjectSettingsWidget, self).ui()
image_layout = layouts.HorizontalLayout(spacing=2,
margins=(2, 2, 2, 2))
image_layout.setContentsMargins(2, 2, 2, 2)
image_layout.setSpacing(2)
self.main_layout.addLayout(image_layout)
self._project_image = QLabel()
self._project_image.setAlignment(Qt.AlignCenter)
image_layout.addStretch()
image_layout.addWidget(self._project_image)
image_layout.addStretch()
self._settings_tab = tabs.BaseTabWidget(parent=self)
self.main_layout.addWidget(self._settings_tab)
self._naming_widget = NamingWidget(project=self._project)
self._project_options_widget = rigoptionsviewer.RigOptionsViewer(
option_object=self._project, parent=self)
self._external_code_widget = ExternalCodeDirectoryWidget(parent=self)
version_control_widget = QWidget(parent=self)
version_control_layout = layouts.VerticalLayout(spacing=0,
margins=(2, 2, 2, 2))
version_control_widget.setLayout(version_control_layout)
self._version_type_combo = combobox.BaseComboBox(parent=self)
version_control_layout.addWidget(self._version_type_combo)
version_control_layout.addStretch()
self._settings_tab.addTab(self._project_options_widget, 'Settings')
self._settings_tab.addTab(self._naming_widget, 'Nomenclature')
self._settings_tab.addTab(version_control_widget, 'Version Control')
self._settings_tab.addTab(self._external_code_widget, 'External Code')
bottom_layout = layouts.VerticalLayout(spacing=2, margins=(2, 2, 2, 2))
bottom_layout.setAlignment(Qt.AlignBottom)
self.main_layout.addLayout(bottom_layout)
bottom_layout.addLayout(dividers.DividerLayout())
buttons_layout = layouts.HorizontalLayout(spacing=2,
margins=(2, 2, 2, 2))
bottom_layout.addLayout(buttons_layout)
ok_icon = resources.icon('ok')
self._ok_btn = buttons.BaseButton(parent=self)
self._ok_btn.setIcon(ok_icon)
buttons_layout.addWidget(self._ok_btn)
def setup_signals(self):
self._version_type_combo.currentIndexChanged.connect(
self._on_version_control_type_changed)
self._ok_btn.clicked.connect(self._on_exit)
def get_project(self):
"""
Returns current RigBuilder project used by this widget
:return: Project
"""
return self._project
def set_project(self, project):
"""
Sets current project used by this widget
:param project: Project
"""
self._project = project
self._project_options_widget.set_option_object(self._project)
if self._project:
self._project_image.setPixmap(
QPixmap(self._project.get_project_image()).scaled(
QSize(150, 150), Qt.KeepAspectRatio))
self._naming_widget.set_project(self._project)
self._external_code_widget.set_project(self._project)
if self._project and self._project.settings.has_setting(
'version_control'):
try:
version_control_index = int(
self._project.settings.has_setting('version_control'))
except Exception:
version_control_index = 0
self._version_type_combo.setCurrentIndex(version_control_index)
def update_options(self, do_reload=False):
"""
Update options of the current project
"""
if not self._project:
return
if do_reload:
self._project.reload_options()
self._project_options_widget.update_options()
def _fill_version_types_combo(self):
"""
Internal callback function that fills with the different types of supported version controls
"""
self._version_type_combo.clear()
for version_type in ['none', 'git']:
self._version_type_combo.addItem(resources.icon(version_type),
version_type)
def _on_version_control_type_changed(self, index):
"""
Internal callback function that is called when version control type is updated
:param index: int
:return:
"""
if not self._project:
return
self._project.settings.set('version_control', int(index))
def _on_exit(self):
"""
Internal callback function that is called when the user exists settings widget
"""
self.exitSettings.emit()
def __init__(self, U, plot, length=1, title=None):
super().__init__()
layout = QVBoxLayout()
if title:
title = QLabel('<b>' + title + '</b>')
title.setAlignment(Qt.AlignHCenter)
layout.addWidget(title)
layout.addWidget(plot)
plot.set(U, 0)
if length > 1:
hlayout = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(length - 1)
self.slider.setTickPosition(QSlider.TicksBelow)
hlayout.addWidget(self.slider)
lcd = QLCDNumber(m.ceil(m.log10(length)))
lcd.setDecMode()
lcd.setSegmentStyle(QLCDNumber.Flat)
hlayout.addWidget(lcd)
layout.addLayout(hlayout)
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_play = QAction(
self.style().standardIcon(QStyle.SP_MediaPlay), 'Play',
self)
self.a_play.setCheckable(True)
self.a_rewind = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekBackward),
'Rewind', self)
self.a_toend = QAction(
self.style().standardIcon(QStyle.SP_MediaSeekForward),
'End', self)
self.a_step_backward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipBackward),
'Step Back', self)
self.a_step_forward = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipForward),
'Step', self)
self.a_loop = QAction(
self.style().standardIcon(QStyle.SP_BrowserReload), 'Loop',
self)
self.a_loop.setCheckable(True)
toolbar.addAction(self.a_play)
toolbar.addAction(self.a_rewind)
toolbar.addAction(self.a_toend)
toolbar.addAction(self.a_step_backward)
toolbar.addAction(self.a_step_forward)
toolbar.addAction(self.a_loop)
if hasattr(self, 'save'):
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
self.a_save.triggered.connect(self.save)
hlayout.addWidget(toolbar)
self.speed = QSlider(Qt.Horizontal)
self.speed.setMinimum(0)
self.speed.setMaximum(100)
hlayout.addWidget(QLabel('Speed:'))
hlayout.addWidget(self.speed)
layout.addLayout(hlayout)
self.timer = QTimer()
self.timer.timeout.connect(self.update_solution)
self.slider.valueChanged.connect(self.slider_changed)
self.slider.valueChanged.connect(lcd.display)
self.speed.valueChanged.connect(self.speed_changed)
self.a_play.toggled.connect(self.toggle_play)
self.a_rewind.triggered.connect(self.rewind)
self.a_toend.triggered.connect(self.to_end)
self.a_step_forward.triggered.connect(self.step_forward)
self.a_step_backward.triggered.connect(self.step_backward)
self.speed.setValue(50)
elif hasattr(self, 'save'):
hlayout = QHBoxLayout()
toolbar = QToolBar()
self.a_save = QAction(
self.style().standardIcon(QStyle.SP_DialogSaveButton),
'Save', self)
toolbar.addAction(self.a_save)
hlayout.addWidget(toolbar)
layout.addLayout(hlayout)
self.a_save.triggered.connect(self.save)
self.setLayout(layout)
self.plot = plot
self.U = U
self.length = length
def fill_table(self, ndx):
self.table.setRowCount(0)
self.freq_table.setRowCount(0)
self.fundamental_table.setRowCount(0)
# self.overtone_table.setRowCount(0)
self.combo_table.setRowCount(0)
if ndx < 0:
self.fundamental_table.setVisible(False)
self.combo_table.setVisible(False)
return
fr = self.file_selector.currentData()
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, "name")
val = QTableWidgetItem()
val.setData(Qt.DisplayRole, fr.name)
self.table.insertRow(0)
self.table.setItem(0, 0, item)
self.table.setItem(0, 1, val)
for info in fr.other.keys():
if info == "archive" and not self.settings.archive:
continue
if any(
isinstance(fr.other[info], obj)
for obj in [str, float, int]):
row = self.table.rowCount()
self.table.insertRow(row)
item = QTableWidgetItem()
info_name = info.replace("_", " ")
val = fr.other[info]
if info == "mass":
info_name += " (%s)" % self.settings.mass
if self.settings.mass == "Da":
val /= UNIT.AMU_TO_KG
elif info == "temperature":
info_name += " (K)"
elif (any(info == s for s in nrg_infos)
or info.lower().endswith("energy")
or info.startswith("E(")):
if self.settings.energy == "Hartree":
info_name += " (E<sub>h</sub>)"
else:
info_name += " (%s)" % self.settings.energy
info_name = info_name.replace("orrelation", "orr.")
info_name = info_name.replace("Same-spin", "SS")
info_name = info_name.replace("Opposite-spin", "OS")
if self.settings.energy == "kcal/mol":
val *= UNIT.HART_TO_KCAL
elif self.settings.energy == "kJ/mol":
val *= 4.184 * UNIT.HART_TO_KCAL
val = "%.6f" % val
elif info.startswith("optical rotation"):
info_name += " (°)"
elif any(info == x for x in pg_infos):
info_name = info.replace("_", " ")
if re.search("\d", val):
val = re.sub(r"(\d+)", r"<sub>\1</sub>", val)
# gaussian uses * for infinity
val = val.replace("*", "<sub>∞</sub>")
# psi4 uses _inf_
val = val.replace("_inf_", "<sub>∞</sub>")
if any(val.endswith(char) for char in "vhdsiVHDSI"):
val = val[:-1] + "<sub>" + val[-1].lower() + "</sub>"
if "<sub>" in info_name:
self.table.setCellWidget(row, 0, QLabel(info_name))
else:
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, info_name)
self.table.setItem(row, 0, item)
value = QTableWidgetItem()
val = str(val)
if "<sub>" in val:
self.table.setCellWidget(row, 1, QLabel(val))
else:
value.setData(Qt.DisplayRole, val)
self.table.setItem(row, 1, value)
elif isinstance(fr.other[info], Theory):
theory = fr.other[info]
if theory.method is not None:
row = self.table.rowCount()
self.table.insertRow(row)
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, "method")
self.table.setItem(row, 0, item)
value = QTableWidgetItem()
value.setData(Qt.DisplayRole, theory.method.name)
self.table.setItem(row, 1, value)
if theory.basis is not None:
if theory.basis.basis:
for basis in theory.basis.basis:
row = self.table.rowCount()
self.table.insertRow(row)
item = QTableWidgetItem()
if not basis.elements:
item.setData(Qt.DisplayRole, "basis set")
else:
item.setData(
Qt.DisplayRole,
"basis for %s" % ", ".join(basis.elements))
self.table.setItem(row, 0, item)
value = QTableWidgetItem()
value.setData(Qt.DisplayRole, basis.name)
self.table.setItem(row, 1, value)
if theory.basis.ecp:
for ecp in theory.basis.ecp:
row = self.table.rowCount()
self.table.insertRow(row)
item = QTableWidgetItem()
if ecp.elements is None:
item.setData(Qt.DisplayRole, "ECP")
else:
item.setData(Qt.DisplayRole,
"ECP %s" % " ".join(ecp.elements))
self.table.setItem(row, 0, item)
value = QTableWidgetItem()
value.setData(Qt.DisplayRole, ecp.name)
self.table.setItem(row, 1, value)
elif (hasattr(fr.other[info], "__iter__")
and all(isinstance(x, float) for x in fr.other[info])
and len(fr.other[info]) > 1):
row = self.table.rowCount()
self.table.insertRow(row)
item = QTableWidgetItem()
info_name = info.replace("_", " ")
vals = fr.other[info]
if "rotational_temperature" in info:
info_name = info_name.replace(
"temperature",
"constants (%s)" % self.settings.rot_const)
if self.settings.rot_const == "GHz":
vals = [
x * PHYSICAL.KB / (PHYSICAL.PLANCK * (10**9))
for x in vals
]
item.setData(Qt.DisplayRole, info_name)
self.table.setItem(row, 0, item)
value = QTableWidgetItem()
value.setData(Qt.DisplayRole,
", ".join(["%.4f" % x for x in vals]))
self.table.setItem(row, 1, value)
if "frequency" in fr.other:
self.tabs.setTabEnabled(1, True)
freq_data = fr.other['frequency'].data
for i, mode in enumerate(freq_data):
row = self.freq_table.rowCount()
self.freq_table.insertRow(row)
freq = FreqTableWidgetItem()
freq.setData(
Qt.DisplayRole, "%.2f%s" %
(abs(mode.frequency), "i" if mode.frequency < 0 else ""))
freq.setData(Qt.UserRole, i)
self.freq_table.setItem(row, 0, freq)
if mode.symmetry:
text = mode.symmetry
if re.search("\d", text):
text = re.sub(r"(\d+)", r"<sub>\1</sub>", text)
if text.startswith("SG"):
text = "Σ" + text[2:]
elif text.startswith("PI"):
text = "Π" + text[2:]
elif text.startswith("DLT"):
text = "Δ" + text[3:]
if any(text.endswith(char) for char in "vhdugVHDUG"):
text = text[:-1] + "<sub>" + text[-1].lower(
) + "</sub>"
label = QLabel(text)
label.setAlignment(Qt.AlignCenter)
self.freq_table.setCellWidget(row, 1, label)
intensity = QTableWidgetItem()
if mode.intensity is not None:
intensity.setData(Qt.DisplayRole, round(mode.intensity, 2))
self.freq_table.setItem(row, 2, intensity)
forcek = QTableWidgetItem()
if mode.forcek is not None:
forcek.setData(Qt.DisplayRole, round(mode.forcek, 2))
self.freq_table.setItem(row, 3, forcek)
if fr.other["frequency"].anharm_data:
self.fundamental_table.setVisible(True)
self.combo_table.setVisible(True)
freq = fr.other["frequency"]
self.tabs.setTabEnabled(2, True)
anharm_data = sorted(
freq.anharm_data,
key=lambda x: x.harmonic_frequency,
)
for i, mode in enumerate(anharm_data):
row = self.fundamental_table.rowCount()
self.fundamental_table.insertRow(row)
fund = FreqTableWidgetItem()
fund.setData(
Qt.DisplayRole,
"%.2f%s" % (abs(mode.frequency),
"i" if mode.frequency < 0 else ""))
fund.setData(Qt.UserRole, i)
self.fundamental_table.setItem(row, 0, fund)
delta_anh = QTableWidgetItem()
delta_anh.setData(Qt.DisplayRole, round(mode.delta_anh, 2))
self.fundamental_table.setItem(row, 1, delta_anh)
intensity = QTableWidgetItem()
if mode.intensity is not None:
intensity.setData(Qt.DisplayRole,
round(mode.intensity, 2))
self.fundamental_table.setItem(row, 2, intensity)
for overtone in mode.overtones:
row = self.combo_table.rowCount()
self.combo_table.insertRow(row)
fund = FreqTableWidgetItem()
fund.setData(
Qt.DisplayRole,
"%.2f%s" % (abs(mode.frequency),
"i" if mode.frequency < 0 else ""))
fund.setData(Qt.UserRole, i)
self.combo_table.setItem(row, 0, fund)
fund = FreqTableWidgetItem()
fund.setData(Qt.UserRole, i)
self.combo_table.setItem(row, 1, fund)
ot = FreqTableWidgetItem()
ot.setData(
Qt.DisplayRole,
"%.2f%s" % (abs(overtone.frequency),
"i" if overtone.frequency < 0 else ""))
ot.setData(Qt.UserRole, i)
self.combo_table.setItem(row, 2, ot)
intensity = QTableWidgetItem()
if overtone.intensity is not None:
intensity.setData(Qt.DisplayRole,
round(overtone.intensity, 2))
self.combo_table.setItem(row, 3, intensity)
for key in mode.combinations:
for combination in mode.combinations[key]:
row = self.combo_table.rowCount()
self.combo_table.insertRow(row)
fund = FreqTableWidgetItem()
fund.setData(
Qt.DisplayRole,
"%.2f%s" % (abs(mode.frequency),
"i" if mode.frequency < 0 else ""))
fund.setData(Qt.UserRole, i)
self.combo_table.setItem(row, 0, fund)
other_freq = freq.anharm_data[key].frequency
fund = FreqTableWidgetItem()
fund.setData(
Qt.DisplayRole,
"%.2f%s" % (abs(other_freq),
"i" if other_freq < 0 else ""))
fund.setData(Qt.UserRole,
i + len(freq.anharm_data) * key)
self.combo_table.setItem(row, 1, fund)
combo = FreqTableWidgetItem()
combo.setData(
Qt.DisplayRole, "%.2f%s" %
(abs(combination.frequency),
"i" if combination.frequency < 0 else ""))
combo.setData(Qt.UserRole, i)
self.combo_table.setItem(row, 2, combo)
intensity = QTableWidgetItem()
if combination.intensity is not None:
intensity.setData(
Qt.DisplayRole,
round(combination.intensity, 2))
self.combo_table.setItem(row, 3, intensity)
else:
self.fundamental_table.setVisible(False)
self.combo_table.setVisible(False)
self.tabs.setTabEnabled(2, False)
else:
self.fundamental_table.setVisible(False)
self.combo_table.setVisible(False)
self.tabs.setTabEnabled(1, False)
self.tabs.setTabEnabled(2, False)
self.table.resizeColumnToContents(0)
self.table.resizeColumnToContents(1)
self.freq_table.resizeColumnToContents(0)
self.freq_table.resizeColumnToContents(1)
self.freq_table.resizeColumnToContents(2)
self.apply_filter()
