def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the Function package.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='Function')
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_gendata_labels = [
_(u"Function Code:"),
_(u"Function Description:"),
_(u"Remarks:")
]
# Initialize private scalar attributes.
self._function_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
# General data page widgets.
self.chkSafetyCritical = ramstk.RAMSTKCheckButton(
label=_(u"Function is safety critical."),
tooltip=_(u"Indicates whether or not the selected function is "
u"safety critical."))
self.txtCode = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"A unique code for the selected function."))
self.txtName = ramstk.RAMSTKEntry(
width=800, tooltip=_(u"The name of the selected function."))
self.txtRemarks = ramstk.RAMSTKTextView(
gtk.TextBuffer(),
width=800,
tooltip=_(u"Enter any remarks associated with the "
u"selected function."))
# Connect to callback functions for editable gtk.Widgets().
self._lst_handler_id.append(
self.txtCode.connect('changed', self._on_focus_out, 0))
self._lst_handler_id.append(
self.txtName.connect('changed', self._on_focus_out, 1))
self._lst_handler_id.append(self.txtRemarks.do_get_buffer().connect(
'changed', self._on_focus_out, 2))
self._lst_handler_id.append(
self.chkSafetyCritical.connect('toggled', self._on_toggled, 3))
self.pack_start(self._make_buttonbox(), expand=False, fill=False)
self.pack_start(self._make_page(), expand=True, fill=True)
self.show_all()
# Subscribe to PyPubSub messages.
pub.subscribe(self._do_load_page, 'selected_function')
pub.subscribe(self._do_clear_page, 'closed_program')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Switch assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"\u03C0<sub>CYC</sub>:")
self._lst_labels.append(u"\u03C0<sub>L</sub>:")
self._lst_labels.append(u"\u03C0<sub>C</sub>:")
self._lst_labels.append(u"\u03C0<sub>N</sub>:")
self._lst_labels.append(u"\u03C0<sub>U</sub>:")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the switch failure "
u"rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtPiCYC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The cycling factor for the switch."))
self.txtPiL = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The load stress factor for the switch."))
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The contact form and quantity factor for the switch."))
self.txtPiN = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The number of active contacts factor for the switch."))
self.txtPiU = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The use factor for the breaker."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Switch assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Application:"))
self._lst_labels.append(_(u"Construction:"))
self._lst_labels.append(_(u"Contact Form:"))
self._lst_labels.append(_(u"Number of Cycles/Hour:"))
self._lst_labels.append(_(u"Number of Active Contacts:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbApplication = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The application of the switch."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=False,
tooltip=_(u"The construction method for "
u"the switch."))
self.cmbContactForm = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The contact form and quantity of the switch."))
self.txtNCycles = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of cycles per hour of the switch."))
self.txtNElements = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of active contacts in the switch."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbApplication.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbContactForm.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.txtNCycles.connect('changed', self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtNElements.connect('changed', self._on_focus_out, 5))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Hardware assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
:param int hardware_id: the hardware ID of the currently selected
hardware item.
:param int subcategory_id: the ID of the hardware item subcategory.
"""
gtk.Fixed.__init__(self)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels = [
u"\u03BB<sub>b</sub>:", u"\u03C0<sub>Q</sub>:",
u"\u03C0<sub>E</sub>:"
]
# Initialize private scalar attributes.
self._dtc_data_controller = controller
self._hardware_id = kwargs['hardware_id']
self._subcategory_id = kwargs['subcategory_id']
self._lblModel = ramstk.RAMSTKLabel(
'',
tooltip=_(u"The assessment model used to calculate the hardware "
u"item failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.fmt = None
self.txtLambdaB = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The base hazard rate of the hardware item."))
self.txtPiQ = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The quality factor for the hardware item."))
self.txtPiE = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The environment factor for the hardware item."))
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Revision Work View general data page.
:param controller: the RAMSTK master data controller instance.
:type controller: :py:class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='revision')
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_gendata_labels = [
_(u"Revision Code:"),
_(u"Revision Name:"),
_(u"Remarks:")
]
# Initialize private scalar attributes.
self._revision_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtCode = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"A unique code for the selected revision."))
self.txtName = ramstk.RAMSTKEntry(
width=800, tooltip=_(u"The name of the selected revision."))
self.txtRemarks = ramstk.RAMSTKTextView(
gtk.TextBuffer(),
width=800,
tooltip=_(u"Enter any remarks associated with the "
u"selected revision."))
self._lst_handler_id.append(
self.txtName.connect('changed', self._on_focus_out, 0))
self._lst_handler_id.append(self.txtRemarks.do_get_buffer().connect(
'changed', self._on_focus_out, 1))
self._lst_handler_id.append(
self.txtCode.connect('changed', self._on_focus_out, 2))
self.pack_start(self._make_buttonbox(), expand=False, fill=False)
self.pack_end(self._make_page(), expand=True, fill=True)
self.show_all()
pub.subscribe(self._on_select, 'selectedRevision')
pub.subscribe(self._on_edit, 'mvwEditedRevision')
pub.subscribe(self._do_clear_page, 'closedProgram')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Miscellaneous assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Application:"))
self._lst_labels.append(_(u"Type:"))
self._lst_labels.append(_(u"Operating Frequency:"))
self._lst_labels.append(_(u"Utilization:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbApplication = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The application of the lamp."))
self.cmbType = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The type of electronic filter."))
self.txtFrequency = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"The operating frequency of the crystal."))
self.txtUtilization = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The utilization factor (illuminate hours / equipment "
u"operate hours) of the lamp."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbApplication.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.txtFrequency.connect('changed', self._on_focus_out, 3))
self._lst_handler_id.append(
self.txtUtilization.connect('changed', self._on_focus_out, 4))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Capacitor assessment result view.
:param controller: the Hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"\u03C0<sub>CV</sub>:")
self._lst_labels.append(u"\u03C0<sub>CF</sub>:")
self._lst_labels.append(u"\u03C0<sub>C</sub>:")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the capacitor failure "
u"rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtPiCV = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The capacitance factor for the capacitor."))
self.txtPiCF = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The configuration factor for the capacitor."))
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The construction factor for the capacitor."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Inductor assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
:param int hardware_id: the hardware ID of the currently selected
inductor.
:param int subcategory_id: the ID of the inductor subcategory.
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"\u03C0<sub>C</sub>:")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the inductive device's "
u"failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The construction factor for the coil."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the Function package.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='Function')
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_assess_labels[1].append(_(u"Total Mode Count:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self._function_id = None
self.txtModeCount = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the total "
u"number of failure modes "
u"associated with the "
u"selected Function."))
self.pack_start(self._make_page(), expand=True, fill=True)
self.show_all()
pub.subscribe(self._on_select, 'selectedFunction')
pub.subscribe(self._on_select, 'calculatedFunction')
def _do_request_edit_function(self, __button):
"""
Request to edit the Similar Item analysis user-defined functions.
:param __button: the gtk.ToolButton() that called this method.
:type __button: :class:`gtk.ToolButton`.
:return: False if successful or True if an error is encountered.
:rtype: bool
"""
(_model, _row) = self.treeview.get_selection().get_selected()
_title = _(u"RAMSTK - Edit Similar Item Analysis Functions")
_label = ramstk.RAMSTKLabel(_(u"You can define up to five functions. "
u"You can use the system failure rate, "
u"selected assembly failure rate, the "
u"change factor, the user float, the "
u"user integer values, and results of "
u"other functions.\n\n \
System hazard rate is hr_sys\n \
Assembly hazard rate is hr\n \
Change factor is pi[1-8]\n \
User float is uf[1-3]\n \
User integer is ui[1-3]\n \
Function result is res[1-5]"),
width=600,
height=-1,
wrap=True)
_label2 = ramstk.RAMSTKLabel(_(u"For example, pi1*pi2+pi3, multiplies "
u"the first two change factors and "
u"adds the value to the third change "
u"factor."),
width=600,
height=-1,
wrap=True)
# Build the dialog assistant.
_dialog = ramstk.RAMSTKDialog(_title)
_fixed = gtk.Fixed()
_y_pos = 10
_fixed.put(_label, 5, _y_pos)
_y_pos += _label.size_request()[1] + 10
_fixed.put(_label2, 5, _y_pos)
_y_pos += _label2.size_request()[1] + 10
_label = ramstk.RAMSTKLabel(_(u"User function 1:"))
_txtFunction1 = ramstk.RAMSTKEntry()
_txtFunction1.set_text(_model.get_value(_row, 30))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction1, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 2:"))
_txtFunction2 = ramstk.RAMSTKEntry()
_txtFunction2.set_text(_model.get_value(_row, 31))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction2, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 3:"))
_txtFunction3 = ramstk.RAMSTKEntry()
_txtFunction3.set_text(_model.get_value(_row, 32))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction3, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 4:"))
_txtFunction4 = ramstk.RAMSTKEntry()
_txtFunction4.set_text(_model.get_value(_row, 33))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction4, 195, _y_pos)
_y_pos += 30
_label = ramstk.RAMSTKLabel(_(u"User function 5:"))
_txtFunction5 = ramstk.RAMSTKEntry()
_txtFunction5.set_text(_model.get_value(_row, 34))
_fixed.put(_label, 5, _y_pos)
_fixed.put(_txtFunction5, 195, _y_pos)
_y_pos += 30
_chkApplyAll = gtk.CheckButton(label=_(u"Apply to all assemblies."))
_fixed.put(_chkApplyAll, 5, _y_pos)
_fixed.show_all()
_dialog.vbox.pack_start(_fixed) # pylint: disable=E1101
# Run the dialog and apply the changes if the 'OK' button is pressed.
if _dialog.run() == gtk.RESPONSE_OK:
if _chkApplyAll.get_active():
_row = _model.get_iter_root()
while _row is not None:
_hardware_id = _model.get_value(_row, 1)
_similaritem = self._dtc_data_controller.request_do_select(
_hardware_id)
_similaritem.function_1 = _txtFunction1.get_text()
_similaritem.function_2 = _txtFunction2.get_text()
_similaritem.function_3 = _txtFunction3.get_text()
_similaritem.function_4 = _txtFunction4.get_text()
_similaritem.function_5 = _txtFunction5.get_text()
_model.set_value(_row, 30, _similaritem.function_1)
_model.set_value(_row, 31, _similaritem.function_2)
_model.set_value(_row, 32, _similaritem.function_3)
_model.set_value(_row, 33, _similaritem.function_4)
_model.set_value(_row, 34, _similaritem.function_5)
self._dtc_data_controller.request_do_update(_hardware_id)
_row = _model.iter_next(_row)
else:
_similaritem = self._dtc_data_controller.request_do_select(
self._hardware_id)
_similaritem.function_1 = _txtFunction1.get_text()
_similaritem.function_2 = _txtFunction2.get_text()
_similaritem.function_3 = _txtFunction3.get_text()
_similaritem.function_4 = _txtFunction4.get_text()
_similaritem.function_5 = _txtFunction5.get_text()
_model.set_value(_row, 30, _similaritem.function_1)
_model.set_value(_row, 31, _similaritem.function_2)
_model.set_value(_row, 32, _similaritem.function_3)
_model.set_value(_row, 33, _similaritem.function_4)
_model.set_value(_row, 34, _similaritem.function_5)
self._dtc_data_controller.request_do_update(self._hardware_id)
_dialog.destroy()
return False
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Integrated Circuit assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.IntegratedCircuitBoMDataController`
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"C1:")
self._lst_labels.append(u"\u03C0<sub>T</sub>:")
self._lst_labels.append(u"C2:")
self._lst_labels.append(u"\u03C0<sub>L</sub>:")
self._lst_labels.append(u"\u03BB<sub>CYC</sub>:")
self._lst_labels.append(u"\u03BB<sub>BD</sub>")
self._lst_labels.append(u"\u03C0<sub>MFG</sub>")
self._lst_labels.append(u"\u03C0<sub>CD</sub>")
self._lst_labels.append(u"\u03BB<sub>BP</sub>")
self._lst_labels.append(u"\u03C0<sub>PT</sub>")
self._lst_labels.append(u"\u03BB<sub>EOS</sub>")
self._lst_labels.append(u"\u03C0<sub>A</sub>")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the integrated circuit "
u"failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtC1 = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The die complexity hazard rate of the integrated "
u"circuit."))
self.txtPiT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The temperature factor for the integrated circuit."))
self.txtC2 = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The package hazard rate for the integrated circuit."))
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The construction factor for the integrated circuit."))
self.txtPiL = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The learning factor for the integrated circuit."))
self.txtLambdaCYC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The read/write cycling induced hazard rate for the "
u"EEPROM."))
self.txtLambdaBD = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The die base hazard rate for the VLSI device."))
self.txtPiMFG = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The manufacturing process correction factor for the "
u"VLSI device."))
self.txtPiCD = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The die complexity correction factor for the VLSI "
u"device."))
self.txtLambdaBP = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The package base hazard rate for the VLSI device."))
self.txtPiPT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The package type correction factor for the VLSI "
u"device."))
self.txtLambdaEOS = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The electrical overstress hazard rate for the VLSI "
u"device."))
self.txtPiA = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The application correction factor for the GaAs "
u"device."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Integrated Circuit assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.IntegratedCircuitDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Package:"))
self._lst_labels.append(_(u"Die Area:"))
self._lst_labels.append(_(u"N Elements:"))
self._lst_labels.append(_(u"\u0398<sub>JC</sub>:"))
self._lst_labels.append(_(u"Active Pins:"))
self._lst_labels.append(_(u"Technology:"))
self._lst_labels.append(_(u"Years in Production:"))
self._lst_labels.append(_(u"Construction"))
self._lst_labels.append(_(u"Programming Cycles:"))
self._lst_labels.append(_(u"Operating Life:"))
self._lst_labels.append(_(u"Error Correction Code:"))
self._lst_labels.append(_(u"Application:"))
self._lst_labels.append(_(u"Device Type:"))
self._lst_labels.append(_(u"Feature Size:"))
self._lst_labels.append(_(u"Manufacturing Process:"))
self._lst_labels.append(_(u"ESD Threshold Voltage:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbApplication = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The application of the integrated circuit."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=False,
tooltip=_(u"The integrated circuit method "
u"of construction."))
self.cmbECC = ramstk.RAMSTKComboBox(
index=0,
simple=False,
tooltip=_(u"The error correction code used by the EEPROM."))
self.cmbManufacturing = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The manufacturing process for the VLSI device."))
self.cmbPackage = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the integrated "
u"circuit."))
self.cmbTechnology = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The technology used to construct the integrated "
u"circuit."))
self.cmbType = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The type of GaAs or VLSI device."))
self.txtArea = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The die area (in mil<sup>2</sup>) of the integrated "
u"circuit."))
self.txtFeatureSize = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The feature size (in microns) of the VLSI device."))
self.txtNActivePins = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of active pins on the integrated circuit."))
self.txtNCycles = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The total number of programming cycles over the "
u"EEPROM life."))
self.txtNElements = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of active elements in the integrated "
u"circuit."))
self.txtOperatingLife = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"The system lifetime operating hours."))
self.txtThetaJC = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"The junction to case thermal resistance."))
self.txtVoltageESD = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The ESD susceptibility threshold voltage of the VLSI "
u"device."))
self.txtYearsInProduction = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of years the generic device type has been "
u"in production."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbApplication.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbECC.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.cmbManufacturing.connect('changed', self._on_combo_changed,
4))
self._lst_handler_id.append(
self.cmbPackage.connect('changed', self._on_combo_changed, 5))
self._lst_handler_id.append(
self.cmbTechnology.connect('changed', self._on_combo_changed, 6))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 7))
self._lst_handler_id.append(
self.txtArea.connect('changed', self._on_focus_out, 8))
self._lst_handler_id.append(
self.txtFeatureSize.connect('changed', self._on_focus_out, 9))
self._lst_handler_id.append(
self.txtNActivePins.connect('changed', self._on_focus_out, 10))
self._lst_handler_id.append(
self.txtNCycles.connect('changed', self._on_focus_out, 11))
self._lst_handler_id.append(
self.txtNElements.connect('changed', self._on_focus_out, 12))
self._lst_handler_id.append(
self.txtOperatingLife.connect('changed', self._on_focus_out, 13))
self._lst_handler_id.append(
self.txtThetaJC.connect('changed', self._on_focus_out, 14))
self._lst_handler_id.append(
self.txtVoltageESD.connect('changed', self._on_focus_out, 15))
self._lst_handler_id.append(
self.txtYearsInProduction.connect('changed', self._on_focus_out,
16))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Semiconductor assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"\u03C0<sub>T</sub>:")
self._lst_labels.append(u"\u03C0<sub>A</sub>:")
self._lst_labels.append(u"\u03C0<sub>C</sub>:")
self._lst_labels.append(u"\u03C0<sub>R</sub>:")
self._lst_labels.append(u"\u03C0<sub>M</sub>:")
self._lst_labels.append(u"\u03C0<sub>I</sub>:")
self._lst_labels.append(u"\u03C0<sub>P</sub>:")
self._lst_labels.append(u"\u03C0<sub>S</sub>:")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the semiconductor "
u"failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtPiT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The temperature factor for the semiconductor."))
self.txtPiA = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The application factor for the semiconductor."))
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The construction factor for the semiconductor."))
self.txtPiR = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The power rating factor for the semiconductor."))
self.txtPiM = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The matching network factor for the semiconductor."))
self.txtPiI = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The forward current factor for the semiconductor."))
self.txtPiP = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The power degradation factor for the semiconductor."))
self.txtPiS = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The electrical stress factor for the semiconductor."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Hardware stress input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
:param int hardware_id: the hardware ID of the currently selected
hardware item.
:param int subcategory_id: the ID of the hardware item subcategory.
"""
gtk.Fixed.__init__(self)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_handler_id = []
# Initialize private scalar attributes.
self._dtc_data_controller = controller
self._hardware_id = kwargs['hardware_id']
self._subcategory_id = kwargs['subcategory_id']
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.fmt = None
self.txtTemperatureRatedMin = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The minimum rated temperature (in \u00B0C) of the "
u"hardware item."))
self.txtTemperatureKnee = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"The break temperature (in \u00B0C) of the hardware item "
u"beyond which it must be derated."))
self.txtTemperatureRatedMax = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"The maximum rated temperature (in \u00B0C) of the hardware "
u"item."))
self.txtCurrentRated = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The rated current (in A) of the hardware item."))
self.txtCurrentOperating = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The operating current (in A) of the hardware item."))
self.txtPowerRated = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The rated power (in W) of the hardware item."))
self.txtPowerOperating = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The operating power (in W) of the hardware item."))
self.txtVoltageRated = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The rated voltage (in V) of the hardware item."))
self.txtVoltageAC = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The operating ac voltage (in V) of the hardware "
u"item."))
self.txtVoltageDC = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The operating DC voltage (in V) of the hardware "
u"item."))
self._lst_handler_id.append(
self.txtTemperatureRatedMin.connect('changed', self._on_focus_out,
0))
self._lst_handler_id.append(
self.txtTemperatureKnee.connect('changed', self._on_focus_out, 1))
self._lst_handler_id.append(
self.txtTemperatureRatedMax.connect('changed', self._on_focus_out,
2))
self._lst_handler_id.append(
self.txtCurrentRated.connect('changed', self._on_focus_out, 3))
self._lst_handler_id.append(
self.txtCurrentOperating.connect('changed', self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtPowerRated.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtPowerOperating.connect('changed', self._on_focus_out, 6))
self._lst_handler_id.append(
self.txtVoltageRated.connect('changed', self._on_focus_out, 7))
self._lst_handler_id.append(
self.txtVoltageAC.connect('changed', self._on_focus_out, 8))
self._lst_handler_id.append(
self.txtVoltageDC.connect('changed', self._on_focus_out, 9))
self._make_page()
self.show_all()
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Work View for the Allocation.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='Allocation')
# Initialize private dictionary attributes.
# Initialize private list attributes.
# Initialize private scalar attributes.
self._parent_id = None
self._allocation_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
_bg_color = '#FFFFFF'
_fg_color = '#000000'
_fmt_file = (
controller.RAMSTK_CONFIGURATION.RAMSTK_CONF_DIR + '/layouts/' +
controller.RAMSTK_CONFIGURATION.RAMSTK_FORMAT_FILE['allocation'])
_fmt_path = "/root/tree[@name='Allocation']/column"
_tooltip = _(u"Displays the Allocation Analysis for the "
u"currently selected Hardware item.")
self.treeview = ramstk.RAMSTKTreeView(_fmt_path,
0,
_fmt_file,
_bg_color,
_fg_color,
pixbuf=False)
self._lst_col_order = self.treeview.order
self.treeview.set_tooltip_text(_tooltip)
self.cmbAllocationGoal = ramstk.RAMSTKComboBox(tooltip=_(
u"Selects the goal measure for the selected hardware assembly."))
self.cmbAllocationMethod = ramstk.RAMSTKComboBox(tooltip=_(
u"Selects the method for allocating the reliability goal for "
u"the selected hardware assembly."))
self.txtHazardRateGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=(
u"Displays the hazard rate goal for the selected hardware "
u"item."))
self.txtMTBFGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"Displays the MTBF goal for the selected hardware item."))
self.txtReliabilityGoal = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"Displays the reliability goal for the selected hardware "
u"item."))
self._lst_handler_id.append(
self.treeview.connect('cursor_changed', self._do_change_row))
self._lst_handler_id.append(
self.treeview.connect('button_press_event', self._on_button_press))
self._lst_handler_id.append(
self.cmbAllocationMethod.connect('changed', self._on_combo_changed,
2))
self._lst_handler_id.append(
self.cmbAllocationGoal.connect('changed', self._on_combo_changed,
3))
self._lst_handler_id.append(
self.txtReliabilityGoal.connect('focus_out_event',
self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtHazardRateGoal.connect('focus_out_event',
self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtMTBFGoal.connect('focus_out_event', self._on_focus_out, 6))
for i in [
self._lst_col_order[3], self._lst_col_order[5],
self._lst_col_order[6], self._lst_col_order[7],
self._lst_col_order[8], self._lst_col_order[9],
self._lst_col_order[10], self._lst_col_order[11]
]:
_cell = self.treeview.get_column(
self._lst_col_order[i]).get_cell_renderers()
try:
_cell[0].connect('edited', self._do_edit_cell, i,
self.treeview.get_model())
except TypeError:
_cell[0].connect('toggled', self._do_edit_cell, 'new text', i,
self.treeview.get_model())
_label = ramstk.RAMSTKLabel(
_(u"Allocation"),
height=30,
width=-1,
justify=gtk.JUSTIFY_CENTER,
tooltip=_(u"Displays the Allocation analysis for the selected "
u"hardware item."))
self.hbx_tab_label.pack_start(_label)
self.pack_start(self._make_buttonbox(), False, True)
_hbox = gtk.HBox()
_hbox.pack_start(self._make_goalbox(), False, True)
_hbox.pack_end(self._make_page(), True, True)
self.pack_end(_hbox, True, True)
self.show_all()
pub.subscribe(self._on_select, 'selectedHardware')
pub.subscribe(self._do_clear_page, 'closedProgram')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Inductor assessment input view.
:param controller: the Hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Specification:"))
self._lst_labels.append(_(u"Insulation Class:"))
self._lst_labels.append(_(u"Area:"))
self._lst_labels.append(_(u"Weight:"))
self._lst_labels.append(_(u"Family:"))
self._lst_labels.append(_(u"Construction:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbInsulation = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The insulation class of the inductive device."))
self.cmbSpecification = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The governing specification for the inductive "
u"device."))
self.cmbFamily = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The application family of the transformer."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the coil."))
self.txtArea = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The case radiating surface (in square inches) of the "
u"inductive device."))
self.txtWeight = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"The transformer weight (in lbf)."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbSpecification.connect('changed', self._on_combo_changed,
1))
self._lst_handler_id.append(
self.cmbInsulation.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbFamily.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 4))
self._lst_handler_id.append(
self.txtArea.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtWeight.connect('changed', self._on_focus_out, 6))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Resistor assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentResults.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(u"\u03C0<sub>R</sub>:")
self._lst_labels.append(u"\u03C0<sub>T</sub>:")
self._lst_labels.append(u"\u03C0<sub>NR</sub>:")
self._lst_labels.append(u"\u03C0<sub>TAPS</sub>")
self._lst_labels.append(u"\u03C0<sub>V</sub>:")
self._lst_labels.append(u"\u03C0<sub>C</sub>:")
# Initialize private scalar attributes.
self._lblModel.set_tooltip_markup(
_(u"The assessment model used to calculate the resistor "
u"failure rate."))
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtPiR = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The resistance factor for the resistor."))
self.txtPiT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The temperature factor for the resistor."))
self.txtPiNR = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The number of resistors factor for the resistor."))
self.txtPiTAPS = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The potentiometer taps factor for the resistor."))
self.txtPiV = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The voltage factor for the resistor."))
self.txtPiC = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The construction class factor for the resistor."))
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Resistor assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Resistance (\u03A9):"))
self._lst_labels.append(_(u"Specification:"))
self._lst_labels.append(_(u"Type:"))
self._lst_labels.append(_(u"Style:"))
self._lst_labels.append(_(u"Construction:"))
self._lst_labels.append(_(u"Number of Elements:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbSpecification = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The governing specification for the resistor."))
self.cmbType = ramstk.RAMSTKComboBox(
index=0, simple=False, tooltip=_(u"The type of thermistor."))
self.cmbStyle = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The style of resistor."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the resistor."))
self.txtResistance = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The resistance (in \u03A9) of the resistor."))
self.txtNElements = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of active resistors in a resistor network "
u"or the number of potentiometer taps."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbSpecification.connect('changed', self._on_combo_changed,
1))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbStyle.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 4))
self._lst_handler_id.append(
self.txtResistance.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtNElements.connect('changed', self._on_focus_out, 6))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Capacitor assessment input view.
:param controller: the Hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Capacitance (F):"))
self._lst_labels.append(_(u"Specification:"))
self._lst_labels.append(_(u"Style:"))
self._lst_labels.append(_(u"Configuration:"))
self._lst_labels.append(_(u"Construction:"))
self._lst_labels.append(_(u"Equivalent Series Resistance (\u03A9):"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.fmt = None
self.cmbSpecification = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The governing specification for the capacitor."))
self.cmbStyle = ramstk.RAMSTKComboBox(
index=0, simple=False, tooltip=_(u"The style of the capacitor."))
self.cmbConfiguration = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The configuration of the capacitor."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the capacitor."))
self.txtCapacitance = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The capacitance rating (in farads) of the capacitor."))
self.txtESR = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The equivalent series resistance of the capcaitor."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbSpecification.connect('changed', self._on_combo_changed,
1))
self._lst_handler_id.append(
self.cmbStyle.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbConfiguration.connect('changed', self._on_combo_changed,
3))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 4))
self._lst_handler_id.append(
self.txtCapacitance.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtESR.connect('changed', self._on_focus_out, 6))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Relay assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Type:"))
self._lst_labels.append(_(u"Load Type"))
self._lst_labels.append(_(u"Contact Form:"))
self._lst_labels.append(_(u"Contact Rating:"))
self._lst_labels.append(_(u"Application:"))
self._lst_labels.append(_(u"Construction:"))
self._lst_labels.append(_(u"Number of Cycles/Hour:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbType = ramstk.RAMSTKComboBox(index=0,
simple=True,
tooltip=_(u"The relay type."))
self.cmbLoadType = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The type of load the relay is switching."))
self.cmbContactForm = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The contact form of the relay."))
self.cmbContactRating = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The rating of the relay contacts."))
self.cmbApplication = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The type of relay appliction."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the relay."))
self.txtCycles = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of relay on/off cycles per hour."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbLoadType.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbContactForm.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.cmbContactRating.connect('changed', self._on_combo_changed,
4))
self._lst_handler_id.append(
self.cmbApplication.connect('changed', self._on_combo_changed, 5))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 6))
self._lst_handler_id.append(
self.txtCycles.connect('changed', self._on_focus_out, 7))
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Hardware assessment result view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
:param int hardware_id: the hardware ID of the currently selected
hardware item.
:param int subcategory_id: the ID of the hardware item subcategory.
"""
gtk.HPaned.__init__(self)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_derate_criteria = [[0.6, 0.6, 0.0], [0.9, 0.9, 0.0]]
# Initialize private scalar attributes.
self._dtc_data_controller = controller
self._hardware_id = kwargs['hardware_id']
self._subcategory_id = kwargs['subcategory_id']
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.fmt = None
self.pltDerate = ramstk.RAMSTKPlot()
self.chkOverstress = ramstk.RAMSTKCheckButton(
label=_(u"Overstressed"),
tooltip=_(u"Indicates whether or not the selected hardware item "
u"is overstressed."))
self.txtCurrentRatio = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The ratio of operating current to rated current for "
u"the hardware item."))
self.txtPowerRatio = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The ratio of operating power to rated power for "
u"the hardware item."))
self.txtVoltageRatio = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"The ratio of operating voltage to rated voltage for "
u"the hardware item."))
self.txtReason = ramstk.RAMSTKTextView(
gtk.TextBuffer(),
width=250,
tooltip=_(u"The reason(s) the selected hardware item is "
u"overstressed."))
self.chkOverstress.set_sensitive(False)
self.txtReason.set_editable(False)
_bg_color = gtk.gdk.Color('#ADD8E6')
self.txtReason.modify_base(gtk.STATE_NORMAL, _bg_color)
self.txtReason.modify_base(gtk.STATE_ACTIVE, _bg_color)
self.txtReason.modify_base(gtk.STATE_PRELIGHT, _bg_color)
self.txtReason.modify_base(gtk.STATE_SELECTED, _bg_color)
self.txtReason.modify_base(gtk.STATE_INSENSITIVE, _bg_color)
self._make_page()
self.show_all()
pub.subscribe(self._do_load_page, 'calculatedHardware')
def __init__(self, controller, **kwargs):
"""
Initialize the RAMSTKWorkView meta-class.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
:keyword str module: the RAMSTK Module this RAMSTKWorkView is the bassis for.
"""
_module = kwargs['module']
gtk.HBox.__init__(self)
ramstk.RAMSTKBaseView.__init__(self, controller, module=_module)
self._module = None
for __, char in enumerate(_module):
if char.isalpha():
self._module = _module.capitalize()
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_gendata_labels = [
_(u"{0:s} Code:").format(self._module),
_(u"{0:s} Name:").format(self._module),
_(u"Remarks:")
]
"""
There are three labels that will appear on all General Data pages.
Insert additional, WorkView specific labels into this list starting at
position 2. In the __init__() method for the WorkView requiring
specific labels, do something like the following:
self._lst_gendata_labels.insert(1, _(u"Specific Label:"))
This will ensure the Remarks widget is always at the bottom of the row
of General Data page widgets. This, then, ensures WorkView specific
widgets don't overlap the Remarks widget.
"""
self._lst_assess_labels = [[
_(u"Active Failure Intensity [\u039B(t)]:"),
_(u"Dormant \u039B(t):"),
_(u"Software \u039B(t):"),
_(u"Predicted h(t):"),
_(u"Mission h(t):"),
_(u"MTBF:"),
_(u"Mission MTBF:"),
_(u"Reliability [R(t)]:"),
_(u"Mission R(t):"),
_(u"Total Parts:")
], [
_(u"Mean Preventive Maintenance Time [MPMT]:"),
_(u"Mean Corrective Maintenance Time [MCMT]:"),
_(u"Mean Time to Repair [MTTR]:"),
_(u"Mean Maintenance Time [MMT]:"),
_(u"Availability [A(t)]:"),
_(u"Mission A(t):"),
_(u"Total Cost:"),
_(u"Cost/Failure:"),
_(u"Cost/Hour:")
]]
"""
There are 10 labels that will appear in the left half and nine labels
that will appear in the right half of all Assessment Results pages.
Append additional, WorkView specific labels onto this list. In the
__init__() method for the WorkView requiring specific labels, do
something like the following:
self._lst_assess_labels[0].append(_(u"Specific Label:"))
"""
# Initialize private scalar attributes.
self._revision_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.txtCode = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"A unique code for the "
u"selected {0:s}.").format(self._module))
self.txtName = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The name of the selected "
u"{0:s}.").format(self._module))
self.txtRemarks = ramstk.RAMSTKTextView(
gtk.TextBuffer(),
width=400,
tooltip=_(u"Enter any remarks "
u"associated with the "
u"selected {0:s}.").format(self._module))
self.txtActiveHt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the active "
u"failure intensity for the "
u"selected {0:s}.").format(self._module))
self.txtDormantHt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the dormant "
u"failure intensity for "
u"the selected {0:s}.").format(self._module))
self.txtSoftwareHt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the software "
u"failure intensity for "
u"the selected {0:s}.").format(self._module))
self.txtPredictedHt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the logistics "
u"failure intensity for "
u"the selected {0:s}. "
u"This is the sum of the "
u"active, dormant, and "
u"software hazard "
u"rates.").format(self._module))
self.txtMissionHt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mission "
u"failure intensity for "
u"the selected {0:s}.").format(self._module))
self.txtMTBF = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the logistics mean "
u"time between failure (MTBF) "
u"for the selected {0:s}.").format(self._module))
self.txtMissionMTBF = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mission "
u"mean time between "
u"failure (MTBF) for the "
u"selected {0:s}.").format(self._module))
self.txtReliability = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the logistics "
u"reliability for the "
u"selected {0:s}.").format(self._module))
self.txtMissionRt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mission "
u"reliability for the "
u"selected {0:s}.").format(self._module))
self.txtMPMT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mean preventive "
u"maintenance time (MPMT) for "
u"the selected {0:s}.").format(self._module))
self.txtMCMT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mean corrective "
u"maintenance time (MCMT) for "
u"the selected {0:s}.").format(self._module))
self.txtMTTR = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mean time to "
u"repair (MTTR) for the "
u"selected {0:s}.").format(self._module))
self.txtMMT = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mean maintenance "
u"time (MMT) for the selected "
u"{0:s}. This includes "
u"preventive and corrective "
u"maintenance.").format(self._module))
self.txtAvailability = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the "
u"logistics "
u"availability for the "
u"selected {0:s}.").format(self._module))
self.txtMissionAt = ramstk.RAMSTKEntry(
width=125,
editable=False,
bold=True,
tooltip=_(u"Displays the mission "
u"availability for the "
u"selected {0:s}.").format(self._module))
self.txtPartCount = ramstk.RAMSTKEntry(
width=125,
editable=False,
tooltip=_(u"Displays the total part "
u"count for the selected "
u"{0:s}.").format(self._module))
self.txtTotalCost = ramstk.RAMSTKEntry(
width=125,
editable=False,
tooltip=_(u"Displays the total cost "
u"of the selected "
u"{0:s}.").format(self._module))
self.txtCostFailure = ramstk.RAMSTKEntry(
width=125,
editable=False,
tooltip=_(u"Displays the cost per "
u"failure of the "
u"selected {0:s}.").format(self._module))
self.txtCostHour = ramstk.RAMSTKEntry(
width=125,
editable=False,
tooltip=_(u"Displays the failure cost "
u"per operating hour for "
u"the selected {0:s}.").format(self._module))
pub.subscribe(self._on_select_revision, 'selectedRevision')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Semiconductor assessment input view.
:param controller: the hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Package:"))
self._lst_labels.append(_(u"Type:"))
self._lst_labels.append(_(u"Application:"))
self._lst_labels.append(_(u"Construction:"))
self._lst_labels.append(_(u"Matching Network:"))
self._lst_labels.append(_(u"Operating Frequency (GHz):"))
self._lst_labels.append(_(u"Number of Characters:"))
self._lst_labels.append(u"\u03B8<sub>JC</sub>:")
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbPackage = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The package type for the semiconductor."))
self.cmbType = ramstk.RAMSTKComboBox(
index=0, simple=False, tooltip=_(u"The type of semiconductor."))
self.cmbApplication = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The application of the semiconductor."))
self.cmbConstruction = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The method of construction of the semiconductor."))
self.cmbMatching = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The matching network of the semiconductor."))
self.txtFrequencyOperating = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The operating frequency of the semiconductor."))
self.txtNElements = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"The number of characters in the optoelectronic display."))
self.txtThetaJC = ramstk.RAMSTKEntry(
width=125,
tooltip=_(
u"The junction-case thermal resistance of the semiconductor."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbApplication.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbConstruction.connect('changed', self._on_combo_changed, 2))
self._lst_handler_id.append(
self.cmbMatching.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.cmbPackage.connect('changed', self._on_combo_changed, 4))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 5))
self._lst_handler_id.append(
self.txtFrequencyOperating.connect('changed', self._on_focus_out,
6))
self._lst_handler_id.append(
self.txtNElements.connect('changed', self._on_focus_out, 7))
self._lst_handler_id.append(
self.txtThetaJC.connect('changed', self._on_focus_out, 8))
def __init__(self, controller, **kwargs): # pylint: disable=unused-argument
"""
Initialize the Requirement Work View.
:param controller: the RAMSTK master data controller instance.
:type controller: :class:`ramstk.RAMSTK.RAMSTK`
"""
RAMSTKWorkView.__init__(self, controller, module='Requirement')
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_gendata_labels = [
_(u"Requirement Code:"),
_(u"Requirement Description:"),
_(u"Requirement Type:"), "",
_(u"Specification:"),
_(u"Page Number:"),
_(u"Figure Number:"),
_(u"Priority:"),
_(u"Owner:"), "",
_(u"Validated Date:")
]
# Initialize private scalar attributes.
self._requirement_id = None
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.btnValidateDate = ramstk.RAMSTKButton(height=25,
width=25,
label="...")
self.chkDerived = ramstk.RAMSTKCheckButton(
label=_(u"Requirement is derived."),
tooltip=_(u"Indicates whether or not the selected requirement is "
u"derived."))
self.chkValidated = ramstk.RAMSTKCheckButton(
label=_(u"Requirement is validated."),
tooltip=_(u"Indicates whether or not the selected requirement is "
u"validated."))
self.cmbOwner = ramstk.RAMSTKComboBox()
self.cmbRequirementType = ramstk.RAMSTKComboBox(index=1, simple=False)
self.cmbPriority = ramstk.RAMSTKComboBox(width=50)
self.txtCode = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"A unique code for the selected requirement."))
self.txtFigNum = ramstk.RAMSTKEntry()
self.txtName = ramstk.RAMSTKEntry(
width=800,
tooltip=_(u"The description of the selected requirement."))
self.txtPageNum = ramstk.RAMSTKEntry()
self.txtSpecification = ramstk.RAMSTKEntry()
self.txtValidatedDate = ramstk.RAMSTKEntry()
# Connect to callback requirements for editable gtk.Widgets().
self._lst_handler_id.append(
self.txtCode.connect('changed', self._on_focus_out, 0))
self._lst_handler_id.append(
self.txtName.connect('changed', self._on_focus_out, 1))
self._lst_handler_id.append(
self.cmbRequirementType.connect('changed', self._on_combo_changed,
2))
self._lst_handler_id.append(
self.chkDerived.connect('toggled', self._on_toggled, 3))
self._lst_handler_id.append(
self.txtSpecification.connect('changed', self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtPageNum.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtFigNum.connect('changed', self._on_focus_out, 6))
self._lst_handler_id.append(
self.cmbPriority.connect('changed', self._on_combo_changed, 7))
self._lst_handler_id.append(
self.cmbOwner.connect('changed', self._on_combo_changed, 8))
self._lst_handler_id.append(
self.chkValidated.connect('toggled', self._on_toggled, 9))
self._lst_handler_id.append(
self.txtValidatedDate.connect('changed', self._on_focus_out, 10))
self._lst_handler_id.append(
self.btnValidateDate.connect('button-release-event',
self._do_select_date,
self.txtValidatedDate))
self.pack_start(self._make_buttonbox(), expand=False, fill=False)
self.pack_start(self._make_page(), expand=True, fill=True)
self.show_all()
pub.subscribe(self._on_select, 'selectedRequirement')
pub.subscribe(self._on_edit, 'mvwEditedRequirement')
pub.subscribe(self._on_edit, 'calculatedRequirement')
pub.subscribe(self._do_clear_page, 'closedProgram')
def __init__(self, controller, **kwargs):
"""
Initialize an instance of the Connection assessment input view.
:param controller: the Hardware data controller instance.
:type controller: :class:`ramstk.hardware.Controller.HardwareBoMDataController`
"""
AssessmentInputs.__init__(self, controller, **kwargs)
# Initialize private dictionary attributes.
# Initialize private list attributes.
self._lst_labels.append(_(u"Connector Type:"))
self._lst_labels.append(_(u"Specification:"))
self._lst_labels.append(_(u"Insert Material:"))
self._lst_labels.append(_(u"Contact Gauge:"))
self._lst_labels.append(_(u"Active Pins:"))
self._lst_labels.append(_(u"Amperes/Contact:"))
self._lst_labels.append(_(u"Mating/Unmating Cycles (per 1000 hours):"))
self._lst_labels.append(_(u"Number of Wave Soldered PTH:"))
self._lst_labels.append(_(u"Number of Hand Soldered PTH:"))
self._lst_labels.append(_(u"Number of Circuit Planes:"))
# Initialize private scalar attributes.
# Initialize public dictionary attributes.
# Initialize public list attributes.
# Initialize public scalar attributes.
self.cmbType = ramstk.RAMSTKComboBox(
index=0,
simple=False,
tooltip=_(u"The type of connector/connection."))
self.cmbSpecification = ramstk.RAMSTKComboBox(
index=0,
simple=True,
tooltip=_(u"The governing specification for the connection."))
self.cmbInsert = ramstk.RAMSTKComboBox(
index=0, simple=True, tooltip=_(u"The connector insert material."))
self.txtContactGauge = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The gauge of the contacts in the connector."))
self.txtActivePins = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of active pins in the connector."))
self.txtAmpsContact = ramstk.RAMSTKEntry(
width=125, tooltip=_(u"The amperes per active contact."))
self.txtMating = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of connector mate and unmate cycles per "
u"1000 hours of operation."))
self.txtNWave = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of wave soldered PTH connections."))
self.txtNHand = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of hand soldered PTH connections."))
self.txtNPlanes = ramstk.RAMSTKEntry(
width=125,
tooltip=_(u"The number of circuit planes for wave soldered "
u"connections."))
self._make_page()
self.show_all()
self._lst_handler_id.append(
self.cmbQuality.connect('changed', self._on_combo_changed, 0))
self._lst_handler_id.append(
self.cmbType.connect('changed', self._on_combo_changed, 1))
self._lst_handler_id.append(
self.cmbSpecification.connect('changed', self._on_combo_changed,
2))
self._lst_handler_id.append(
self.cmbInsert.connect('changed', self._on_combo_changed, 3))
self._lst_handler_id.append(
self.txtContactGauge.connect('changed', self._on_focus_out, 4))
self._lst_handler_id.append(
self.txtActivePins.connect('changed', self._on_focus_out, 5))
self._lst_handler_id.append(
self.txtAmpsContact.connect('changed', self._on_focus_out, 6))
self._lst_handler_id.append(
self.txtMating.connect('changed', self._on_focus_out, 7))
self._lst_handler_id.append(
self.txtNWave.connect('changed', self._on_focus_out, 8))
self._lst_handler_id.append(
self.txtNHand.connect('changed', self._on_focus_out, 9))
self._lst_handler_id.append(
self.txtNPlanes.connect('changed', self._on_focus_out, 10))
