def __str__(self):
transitions = 'all' if not self.transitions else str(self.transitions)
return u'%s (elevation=%s to %s \u00b0, azimuth=%s to %s \u00b0, transitions=%s)' % \
(camelcase_to_words(self.__class__.__name__),
self.elevation_deg.lower, self.elevation_deg.upper,
self.azimuth_deg.lower, self.azimuth_deg.upper,
transitions)
def setProject(self, project):
# Clear
self.combobox_xaxis.clear()
self.combobox_yaxis.clear()
self.list_columns.clear()
self.list_simulations.clear()
self.canvas.figure.clear()
self._project = project
if project is None:
return
# X axis
df = project.create_options_dataframe(self._settings,
only_different_columns=True)
for column in df.columns:
self.combobox_xaxis.addItem(column, df[column])
# Y axis
for result_class in sorted(project.result_classes,
key=lambda c: c.__name__):
text = camelcase_to_words(result_class.__name__[:-6]).lower()
df = project.create_results_dataframe(self._settings,
[result_class])
self.combobox_yaxis.addItem(text, df)
# Simulations
for index in range(len(project.simulations)):
item = QtWidgets.QListWidgetItem("Simulation #{:d}".format(index))
item.setTextAlignment(QtCore.Qt.AlignLeft)
self.list_simulations.addItem(item)
self.list_simulations.selectAll()
def __init__(self, key, result, options, parent=None):
self._key = key
self._result = result
_BaseResultWidget.__init__(self, options, parent)
self.setTitle(key)
self.setSubTitle(camelcase_to_words(result.__class__.__name__[:-6]))
def __str__(self):
return u"%s (elevation=%s to %s \u00b0, azimuth=%s to %s \u00b0, limits=%s to %s eV, channels=%s)" % \
(camelcase_to_words(self.__class__.__name__),
self.elevation_deg.lower, self.elevation_deg.upper,
self.azimuth_deg.lower, self.azimuth_deg.upper,
self.limits_eV.lower, self.limits_eV.upper,
self.channels)
def convert_document(self, builder):
super().convert_document(builder)
builder.add_title(camelcase_to_words(self.__class__.__name__))
description = builder.require_description(self.DESCRIPTION_BEAM)
description.add_item("Energy", self.energy_eV, "eV",
self.ENERGY_TOLERANCE_eV)
description.add_item("Particle", self.particle)
def convert(self, options, level=1):
root = super().convert(options, level=1)
root += self._create_header(level, 'Program')
dl = tags.dl()
dl += self._create_description('Identifier',
options.program.getidentifier())
root += dl
classname = camelcase_to_words(options.beam.__class__.__name__)
root += self._create_header(level, classname)
root += self._find_and_convert(options.beam, level + 1).children
classname = camelcase_to_words(options.sample.__class__.__name__)
root += self._create_header(level, classname)
root += self._find_and_convert(options.sample, level + 1).children
root += self._create_header(level, 'Detectors')
for clasz, detectors in organize_by_type(options.detectors).items():
classname = camelcase_to_words(clasz.__name__)
root += self._create_header(level + 1, classname)
root += self._create_table_objects(detectors)
root += self._create_header(level, 'Analyses')
for analysis in options.analyses:
classname = camelcase_to_words(analysis.__class__.__name__)
root += self._create_header(level + 1, classname)
root += self._find_and_convert(analysis, level + 1)
root += self._create_header(level, 'Limits')
for limit in options.limits:
classname = camelcase_to_words(limit.__class__.__name__)
root += self._create_header(level + 1, classname)
root += self._find_and_convert(limit, level + 1)
root += self._create_header(level, 'Models')
root += self._create_table_objects(options.models)
return root
def convert_models_document(builder, *models):
table = builder.require_table("models")
table.add_column("Category")
table.add_column("Model")
table.add_column("Reference")
for model in models:
row = {
"Category": camelcase_to_words(model.__class__.__name__[:-5]),
"Model": model.fullname,
"Reference": model.reference,
}
table.add_row(row)
def create_reference(modulepath):
# From sphinx.roles.XRefRole
classes = ['xref', 'ref']
modulename = modulepath.rsplit('.', 1)[-1]
title = ' '.join(camelcase_to_words(modulename).split()[:-1])
target = modulename.lower()
rawtext = ':ref:`%s <%s>`' % (title, target)
refnode = \
addnodes.pending_xref(rawtext, reftype='ref', refdomain='std',
refexplicit=True,
reftarget=target,
refdoc=env.docname)
refnode += nodes.literal(rawtext, title, classes=classes)
return refnode
def create_reference(modulepath):
# From sphinx.roles.XRefRole
classes = ['xref', 'ref']
modulename = modulepath.rsplit('.', 1)[-1]
title = ' '.join(camelcase_to_words(modulename).split()[:-1])
target = modulename.lower()
rawtext = ':ref:`%s <%s>`' % (title, target)
refnode = \
addnodes.pending_xref(rawtext, reftype='ref', refdomain='std',
refexplicit=True,
reftarget=target,
refdoc=env.docname)
refnode += nodes.literal(rawtext, title, classes=classes)
return refnode
def addLimit(self, limit):
clasz = limit.__class__
if clasz in self._tabs:
raise ValueError('Limit (%s) already added' % clasz.__name__)
wdg_limit = get_widget_class(clasz)()
wdg_limit.setValue(limit)
wdg_limit.setReadOnly(self._readonly)
self._widgets[clasz] = wdg_limit
layout = QVBoxLayout()
layout.addWidget(wdg_limit, 1)
widget = QWidget()
widget.setLayout(layout)
class_name = camelcase_to_words(clasz.__name__)
index = self._wdg_tab.addTab(widget, class_name)
self._tabs[clasz] = index
def convert_document(self, builder):
super().convert_document(builder)
builder.add_title(camelcase_to_words(self.__class__.__name__))
section = builder.add_section()
section.add_title("Orientation")
description = section.require_description("angles")
description.add_item(
"Tilt angle", self.tilt_rad, "rad", self.TILT_TOLERANCE_rad
)
description.add_item(
"Azimuth rotation", self.azimuth_rad, "rad", self.AZIMUTH_TOLERANCE_rad
)
section = builder.add_section()
section.add_title("Material" if len(self.materials) < 2 else "Materials")
for material in self.materials:
section.add_entity(material)
def convert_rows(self, model):
row = OrderedDict()
key = self._create_label('Category')
value = self._format_value(camelcase_to_words(
self.CLASS.__name__[:-5]))
row[key] = value
key = self._create_label('Model')
value = self._format_value(model.fullname)
row[key] = value
key = self._create_label('Reference')
value = self._format_value(model.reference)
row[key] = value
rows = super().convert_rows(model)
rows.append(row)
return rows
def convert_document(self, builder):
super().convert_document(builder)
builder.add_title("Program")
section = builder.add_section()
section.add_entity(self.program)
builder.add_title("Beam")
section = builder.add_section()
section.add_entity(self.beam)
builder.add_title("Sample")
section = builder.add_section()
section.add_entity(self.sample)
builder.add_title(
"Detector" if len(self.detectors) < 2 else "Detectors")
for clasz, detectors in organize_by_type(self.detectors).items():
section = builder.add_section()
section.add_title(camelcase_to_words(clasz.__name__))
for detector in detectors:
section.add_entity(detector)
builder.add_title("Analysis" if len(self.analyses) < 2 else "Analyses")
for analysis in self.analyses:
section = builder.add_section()
section.add_entity(analysis)
builder.add_title("Tags")
if self.tags:
bullet_builder = builder.require_bullet("tags")
for tag in self.tags:
bullet_builder.add_item(tag)
else:
builder.add_text("No tags")
def __str__(self):
return '%s (%i transitions, on detector %s, uncertainty=%s %%)' % \
(camelcase_to_words(self.__class__.__name__),
len(self.transition), self.detector_key, self.uncertainty * 100.0)
def testcamelcase_to_words(self):
self.assertEqual('Abc Def', camelcase_to_words('AbcDef'))
self.assertEqual('Abc DEF', camelcase_to_words('AbcDEF'))
self.assertEqual('Abc De F', camelcase_to_words('AbcDeF'))
def testcamelcase_to_words(self):
self.assertEqual('Abc Def', camelcase_to_words('AbcDef'))
self.assertEqual('Abc DEF', camelcase_to_words('AbcDEF'))
self.assertEqual('Abc De F', camelcase_to_words('AbcDeF'))
def getname(cls):
name = cls.__name__
if name.endswith("Result"):
name = name[:-6]
name = camelcase_to_words(name)
return name.capitalize()
def __str__(self):
return u"%s (limits=%s to %s \u00b0, channels=%s)>" % \
(camelcase_to_words(self.__class__.__name__),
self.limits_rad.lower, self.limits_rad.upper, self.channels)
def __str__(self):
return '%s (channels=%s)' % \
(camelcase_to_words(self.__class__.__name__), self.channels)
def __str__(self):
return '%s' % camelcase_to_words(self.__class__.__name__)
def __str__(self):
return '%s (showers=%s)' % \
(camelcase_to_words(self.__class__.__name__), self.showers)
def __str__(self):
return u'%s (elevation=%s to %s \u00b0, azimuth=%s to %s \u00b0, bins=(%s, %s, %s))' % \
(camelcase_to_words(self.__class__.__name__),
self.elevation_deg.lower, self.elevation_deg.upper,
self.azimuth_deg.lower, self.azimuth_deg.upper,
self.xbins, self.ybins, self.zbins)
def __str__(self):
return "%s (x=%s to %s nm (%s), y=%s to %s nm (%s), z=%s to %s nm (%s))" % \
(camelcase_to_words(self.__class__.__name__),
self.xlimits_m.lower * 1e9, self.xlimits_m.upper * 1e9, self.xbins,
self.ylimits_m.lower * 1e9, self.ylimits_m.upper * 1e9, self.ybins,
self.zlimits_m.lower * 1e9, self.zlimits_m.upper * 1e9, self.zbins)
def testcamelcase_to_words(text, expected):
assert camelcase_to_words(text) == expected
def __str__(self):
return '%s (elevation=%s to %s \u00b0, azimuth=%s to %s \u00b0)' % \
(camelcase_to_words(self.__class__.__name__),
self.elevation_deg.lower, self.elevation_deg.upper,
self.azimuth_deg.lower, self.azimuth_deg.upper)
def __str__(self):
return '%s (time=%s s)' % \
(camelcase_to_words(self.__class__.__name__), self.time_s)
def __str__(self):
return '%s (limits=%s to %s eV, channels=%s)' % \
(camelcase_to_words(self.__class__.__name__),
self.limits_eV.lower, self.limits_eV.upper, self.channels)
def convert_document(self, builder):
super().convert_document(builder)
builder.add_title(camelcase_to_words(self.__class__.__name__))
def __str__(self):
prep = 'with' if self.secondary else 'without'
return '%s (%s secondary particles)' % \
(camelcase_to_words(self.__class__.__name__), prep)
