def __init__(self,
y_obs_lower=-np.Inf,
y_obs_upper=np.Inf,
y_diff_upper=np.Inf,
y_diff_lower=-np.Inf,
x_calc=None,
y_calc=None):
if y_calc is None:
y_calc = [0.0]
if x_calc is None:
x_calc = [0.0]
main = LoggedPathDict(
x_min=np.amin(x_calc).item(),
x_max=np.amax(x_calc).item(),
y_min=(np.amin([np.amin(y_calc),
np.amin(y_obs_lower)]).item()),
y_max=(np.amax([np.amax(y_calc),
np.amax(y_obs_upper)]).item()))
difference = LoggedPathDict(y_min=np.amin(y_diff_lower).item(),
y_max=np.amax(y_diff_upper).item())
super().__init__(main=main, difference=difference)
self._log = logging.getLogger(__class__.__module__)
self._log.debug('Created limits %s', self['main'])
def __init__(self, name: str, bragg_peaks: BraggPeaks,
calculated_pattern: CalculatedPattern, limits: Limits):
super().__init__(name=name,
bragg_peaks=bragg_peaks,
calculated_pattern=calculated_pattern,
limits=limits)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, experiments: Union[Experiment, dict, list]):
"""
Constructor for holding multiple experiments
:param experiments: A collection of experimental dicts
"""
super().__init__(experiments, Experiment)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
self._project_dict = None
self._model = QStandardItemModel()
# set roles
self._label_role = Qt.UserRole + 1
self._type_role = Qt.UserRole + 2
self._chiiso_role = Qt.UserRole + 3
self._chi11_role = Qt.UserRole + 4
self._chi22_role = Qt.UserRole + 5
self._chi33_role = Qt.UserRole + 6
self._chi12_role = Qt.UserRole + 7
self._chi13_role = Qt.UserRole + 8
self._chi23_role = Qt.UserRole + 9
self._model.setItemRoleNames({
self._label_role: b'label',
self._type_role: b'type',
self._chiiso_role: b'chiiso',
self._chi11_role: b'chi11',
self._chi22_role: b'chi22',
self._chi33_role: b'chi33',
self._chi12_role: b'chi12',
self._chi13_role: b'chi13',
self._chi23_role: b'chi23'
})
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
self._calculator = None
# Create the status items
chi_item = StatusItem('chiSq',
title='Current \u03c7\u00b2',
additionalData=1)
chi_item.setReturn(True)
chi_item.title = 'Previous \u03c7\u00b2'
chi_item.setReturn(False)
self._interestedList = StatusList([
chi_item,
StatusItem('numPars', title='Fit parameters', additionalData=1),
StatusItem('numData', title='Experiments', additionalData=0),
StatusItem('numPhases', title='Phases', additionalData=0)
])
# minor properties
self._first_role = Qt.UserRole + 1
self._statusBarModel = QStandardItemModel()
self._chartDisplayModel = QStandardItemModel()
# set role names
self._role_names_list = ['label', 'value']
self._roles_list = []
self._roles_dict = {'status': {}, 'plot': {}}
self._setRolesListAndDict()
self._statusBarModel.setItemRoleNames(self._roles_dict['status'])
self._chartDisplayModel.setItemRoleNames(self._roles_dict['plot'])
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, u_11: Base, u_22: Base, u_33: Base, u_12: Base,
u_13: Base, u_23: Base):
super().__init__(u_11=u_11,
u_22=u_22,
u_33=u_33,
u_12=u_12,
u_13=u_13,
u_23=u_23)
self._log = logging.getLogger(__class__.__module__)
self._log.debug('ADP created: %s', self)
self.setItemByPath(['u_11', 'header'], 'U11')
self.setItemByPath(['u_11', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_11', 'url'], ATOM_DETAILS['ADP']['url'])
self.setItemByPath(['u_12', 'header'], 'U12')
self.setItemByPath(['u_12', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_12', 'url'], ATOM_DETAILS['ADP']['url'])
self.setItemByPath(['u_13', 'header'], 'U13')
self.setItemByPath(['u_13', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_13', 'url'], ATOM_DETAILS['ADP']['url'])
self.setItemByPath(['u_22', 'header'], 'U22')
self.setItemByPath(['u_22', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_22', 'url'], ATOM_DETAILS['ADP']['url'])
self.setItemByPath(['u_23', 'header'], 'U23')
self.setItemByPath(['u_23', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_23', 'url'], ATOM_DETAILS['ADP']['url'])
self.setItemByPath(['u_33', 'header'], 'U33')
self.setItemByPath(['u_33', 'tooltip'], ATOM_DETAILS['ADP']['tooltip'])
self.setItemByPath(['u_33', 'url'], ATOM_DETAILS['ADP']['url'])
def __init__(self,
x: list,
y_obs: list,
sy_obs: list,
y_obs_diff: Union[list, None] = None,
sy_obs_diff: Union[list, None] = None,
y_obs_up: Union[list, None] = None,
sy_obs_up: Union[list, None] = None,
y_obs_down: Union[list, None] = None,
sy_obs_down: Union[list, None] = None):
"""
Constructor for a measured pattern
:param x: Generally a two theta value
:param y_obs: Observed intensity
:param sy_obs: Observed Error
:param y_obs_up: Polarised UP intensity. None if non-polarised
:param sy_obs_up: Polarised UP intensity error. None if non-polarised
:param y_obs_down: Polarised DOWN intensity. None if non-polarised
:param sy_obs_down: Polarised DOWN intensity error. None if non-polarised
"""
# 1d polarised powder diffraction data
# if y_obs_up is not None and sy_obs_up is not None and y_obs_down is not None and sy_obs_down is not None:
super().__init__(x=x,
y_obs=y_obs,
sy_obs=sy_obs,
y_obs_diff=y_obs_diff,
sy_obs_diff=sy_obs_diff,
y_obs_up=y_obs_up,
sy_obs_up=sy_obs_up,
y_obs_down=y_obs_down,
sy_obs_down=sy_obs_down)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, release_config_file_path, parent=None):
self.__log = logger.getLogger(__name__)
self.__log.info("")
super().__init__(parent)
self.info = Config(release_config_file_path)['release']
self.projectChanged.connect(self.onProjectChanged)
self._project_rcif_path = None
self._samples_rcif_path = None
self._experiment_rcif_path = None
self._calculator_interface = QtCalculatorInterface(CryspyCalculator())
self._project_dict_copy = {}
self._project_control = ProjectControl()
self._measured_data_model = MeasuredDataModel()
self._calculated_data_model = CalculatedDataModel()
self._bragg_peaks_model = BraggPeaksModel()
self._cell_parameters_model = CellParametersModel()
self._cell_box_model = CellBoxModel()
self._atom_sites_model = AtomSitesModel()
self._atom_adps_model = AtomAdpsModel()
self._atom_msps_model = AtomMspsModel()
self._fitables_model = FitablesModel()
self._status_model = StatusModel()
self._refine_thread = None
self._refinement_running = False
self._refinement_done = False
self._refinement_result = {}
self._calculator_interface.clearUndoStack()
self._need_to_save = False
def __init__(self, backgrounds: Union[Background, dict, list]):
"""
Constructor for Background data points
:param backgrounds: Background parameters formed from Background dicts
"""
super().__init__(backgrounds, Background)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, atoms: Union[Atom, dict, list]):
"""
Constructor for multiple atoms
:param atoms: Collection of atoms
"""
super().__init__(atoms, Atom, 'atom_site_label')
self._log = logging.getLogger(__class__.__module__)
self._log.debug('Atoms created: %s', self)
def __init__(self, phases: Union[Phase, dict, list]):
"""
Constructor for the phases dict
:param phases: Collection of phases
"""
super().__init__(phases, Phase, 'phasename')
self._log = logging.getLogger(__class__.__module__)
self._log.debug('Phases created: %s', self)
def __init__(self, value: Optional[Any] = None, unit: Optional[Union[str, Unit]] = ''):
"""
Create a data class from a value with a unit. Can be left blank
:param value: default value for the data
:param unit: default unit for the data in the form of a easyInterface.Untils.unit
"""
if not isinstance(unit, Unit):
# Try to convert the unit to a string
unit = Unit(unit)
super().__init__(value=value, unit=unit, min=-np.Inf, max=np.Inf, error=0, constraint=None, hide=True, refine=False)
self._log = logger.getLogger(__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
self._y_obs_column = 1
self._sy_obs_column = 2
self._y_max = 1
self._y_min = 0
self._upperSeriesRefs = [
] # list of references to QML LineSeries (for 2 charts)
self._lowerSeriesRefs = [
] # list of references to QML LineSeries (for 2 charts)
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, length_a: Base, length_b: Base, length_c: Base,
angle_alpha: Base, angle_beta: Base, angle_gamma: Base):
"""
Constructor for the crystallographic unit cell
:param length_a: Unit cell length a
:param length_b: Unit cell length b
:param length_c: Unit cell length c
:param angle_alpha: Unit cell angle alpha
:param angle_beta: Unit cell angle beta
:param angle_gamma: Unit cell angle gamma
"""
super().__init__(length_a=length_a,
length_b=length_b,
length_c=length_c,
angle_alpha=angle_alpha,
angle_beta=angle_beta,
angle_gamma=angle_gamma)
self._log = logging.getLogger(__class__.__module__)
self._log.debug('Cell created: %s', self)
self.setItemByPath(['length_a', 'header'], 'a (Å)')
self.setItemByPath(['length_a', 'tooltip'],
CELL_DETAILS['length']['tooltip'])
self.setItemByPath(['length_a', 'url'], CELL_DETAILS['length']['url'])
self.setItemByPath(['length_b', 'header'], 'b (Å)')
self.setItemByPath(['length_b', 'tooltip'],
CELL_DETAILS['length']['tooltip'])
self.setItemByPath(['length_b', 'url'], CELL_DETAILS['length']['url'])
self.setItemByPath(['length_c', 'header'], 'c (Å)')
self.setItemByPath(['length_c', 'tooltip'],
CELL_DETAILS['length']['tooltip'])
self.setItemByPath(['length_c', 'url'], CELL_DETAILS['length']['url'])
self.setItemByPath(['angle_alpha', 'header'], 'alpha (°)')
self.setItemByPath(['angle_alpha', 'tooltip'],
CELL_DETAILS['angle']['tooltip'])
self.setItemByPath(['angle_alpha', 'url'],
CELL_DETAILS['angle']['url'])
self.setItemByPath(['angle_beta', 'header'], 'beta (°)')
self.setItemByPath(['angle_beta', 'tooltip'],
CELL_DETAILS['angle']['tooltip'])
self.setItemByPath(['angle_beta', 'url'], CELL_DETAILS['angle']['url'])
self.setItemByPath(['angle_gamma', 'header'], 'gamma (°)')
self.setItemByPath(['angle_gamma', 'tooltip'],
CELL_DETAILS['angle']['tooltip'])
self.setItemByPath(['angle_gamma', 'url'],
CELL_DETAILS['angle']['url'])
def __init__(self, name: str, wavelength: Base, offset: Base,
magnetic_field: Base, phase: ExperimentPhases,
background: Backgrounds, resolution: Resolution,
measured_pattern: MeasuredPattern):
"""
Constructor for experimental data container
:param name: The name of the experimental data
:param wavelength: What wavelength was the experiment taken at
:param offset: The experimental offset
:param phase: The experimental phase scale
:param background: Description of the background
:param resolution: Description of the resolution
:param measured_pattern: What was actually measured
"""
refinement_type = RefinementType()
refinement_type.sum = True
super().__init__(name=name,
wavelength=wavelength,
offset=offset,
magnetic_field=magnetic_field,
phase=phase,
background=background,
resolution=resolution,
measured_pattern=measured_pattern,
refinement_type=refinement_type,
polarization=Polarization.default())
self._log = logging.getLogger(__class__.__module__)
self.setItemByPath(['wavelength', 'header'],
EXPERIMENT_DETAILS['wavelength']['header'])
self.setItemByPath(['wavelength', 'tooltip'],
EXPERIMENT_DETAILS['wavelength']['tooltip'])
self.setItemByPath(['wavelength', 'url'],
EXPERIMENT_DETAILS['wavelength']['url'])
self.setItemByPath(['offset', 'header'],
EXPERIMENT_DETAILS['offset']['header'])
self.setItemByPath(['offset', 'tooltip'],
EXPERIMENT_DETAILS['offset']['tooltip'])
self.setItemByPath(['offset', 'url'],
EXPERIMENT_DETAILS['offset']['url'])
self.setItemByPath(['magnetic_field', 'header'],
EXPERIMENT_DETAILS['magnetic_field']['header'])
self.setItemByPath(['magnetic_field', 'tooltip'],
EXPERIMENT_DETAILS['magnetic_field']['tooltip'])
self.setItemByPath(['magnetic_field', 'url'],
EXPERIMENT_DETAILS['magnetic_field']['url'])
def __init__(self, parent=None):
super().__init__(parent)
self._project_dict = None
self._model = QStandardItemModel()
# set roles
self._x_role, self._y_role, self._z_role = [
Qt.UserRole + 1 + i for i in range(3)
]
self._model.setItemRoleNames({
self._x_role: b'xPos',
self._y_role: b'yPos',
self._z_role: b'zPos'
})
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
self._y_calc_name = "y_calc_sum"
self._y_obs_name = "y_obs"
self._sy_obs_name = "sy_obs"
self._y_max = 1
self._y_min = 0
self._y_diff_max = 1
self._y_diff_min = 0
self._calcSeriesRef = None
self._calcBkgSeriesRef = None
self._lowerDiffSeriesRef = None
self._upperDiffSeriesRef = None
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
# set roles
self._phase_role = Qt.UserRole + 1
self._experiment_role = Qt.UserRole + 2
self._calculation_role = Qt.UserRole + 3
self._model.setItemRoleNames({
self._phase_role:
b'phasesRole',
self._experiment_role:
b'experimentsRole',
self._calculation_role:
b'calculationsRole',
})
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, ttheta: float, intensity: Base):
"""
Background dictionary
:param ttheta: Two Theta angle in degrees
:param intensity: Intensity data store
:return: Background data object
"""
super().__init__(name=str(ttheta), ttheta=ttheta, intensity=intensity)
self._log = logging.getLogger(__class__.__module__)
self.setItemByPath(['intensity', 'header'],
INTENSITY_DETAILS['intensity']['header'])
self.setItemByPath(['intensity', 'tooltip'],
INTENSITY_DETAILS['intensity']['tooltip'])
self.setItemByPath(['intensity', 'url'],
INTENSITY_DETAILS['intensity']['url'])
def __init__(self, name: str, scale: Base):
"""
Constructor for the Experimental phase container
:param scale: phase scale as data object
"""
super().__init__(name=name, scale=scale)
self._log = logging.getLogger(__class__.__module__)
self.setItemByPath(['scale', 'header'],
SCALE_DETAILS['scale']['header'])
self.setItemByPath(['scale', 'tooltip'],
SCALE_DETAILS['scale']['tooltip'])
self.setItemByPath(['scale', 'url'], SCALE_DETAILS['scale']['url'])
self._log.debug('Created phase: {}'.format(self))
def __init__(self, bragg_peaks: Union[CrystalBraggPeaks, dict, list]):
"""
Constructor for holding multiple bragg peaks
:param bragg_peaks: A collection of bragg peak dicts
"""
if isinstance(bragg_peaks, CrystalBraggPeaks):
bragg_peaks = {
bragg_peaks['name']: bragg_peaks,
}
if isinstance(bragg_peaks, list):
theseCalculations = dict()
for bragg_peak in bragg_peaks:
theseCalculations[bragg_peak['name']] = bragg_peak
bragg_peaks = theseCalculations
super().__init__(**bragg_peaks)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, calculations: Union[Calculation, dict, list]):
"""
Constructor for holding multiple calculations
:param calculations: A collection of calculation dicts
"""
if isinstance(calculations, Calculation):
calculations = {
calculations['name']: calculations,
}
if isinstance(calculations, list):
theseCalculations = dict()
for calculation in calculations:
theseCalculations[calculation['name']] = calculation
calculations = theseCalculations
super().__init__(**calculations)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, parent=None):
super().__init__(parent)
self._project_dict = None
self._model = QStandardItemModel()
# set roles
self._a_role, self._b_role, self._c_role, self._alpha_role, self._beta_role, self._gamma_role = [
Qt.UserRole + 1 + i for i in range(6)
]
self._model.setItemRoleNames({
self._a_role: b'length_a',
self._b_role: b'length_b',
self._c_role: b'length_c',
self._alpha_role: b'angle_alpha',
self._beta_role: b'angle_beta',
self._gamma_role: b'angle_gamma'
})
self._log = logger.getLogger(self.__class__.__module__)
def __init__(self, MSPtype: Base, chi_11: Base, chi_22: Base, chi_33: Base,
chi_12: Base, chi_13: Base, chi_23: Base):
super().__init__(type=MSPtype,
chi_11=chi_11,
chi_22=chi_22,
chi_33=chi_33,
chi_12=chi_12,
chi_13=chi_13,
chi_23=chi_23)
self._log = logging.getLogger(__class__.__module__)
self._log.debug('MSP created: %s', self)
self.setItemByPath(['type', 'header'], 'Type')
self.setItemByPath(['chi_11', 'header'], 'U11')
self.setItemByPath(['chi_11', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_11', 'url'], ATOM_DETAILS['MSP']['url'])
self.setItemByPath(['chi_12', 'header'], 'U12')
self.setItemByPath(['chi_12', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_12', 'url'], ATOM_DETAILS['MSP']['url'])
self.setItemByPath(['chi_13', 'header'], 'U13')
self.setItemByPath(['chi_13', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_13', 'url'], ATOM_DETAILS['MSP']['url'])
self.setItemByPath(['chi_22', 'header'], 'U22')
self.setItemByPath(['chi_22', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_22', 'url'], ATOM_DETAILS['MSP']['url'])
self.setItemByPath(['chi_23', 'header'], 'U23')
self.setItemByPath(['chi_23', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_23', 'url'], ATOM_DETAILS['MSP']['url'])
self.setItemByPath(['chi_33', 'header'], 'U33')
self.setItemByPath(['chi_33', 'tooltip'],
ATOM_DETAILS['MSP']['tooltip'])
self.setItemByPath(['chi_33', 'url'], ATOM_DETAILS['MSP']['url'])
def __init__(self,
calculator: 'easyInterface.Diffraction.Calculator') -> None:
"""
Initialise an interface with a `calculator` of the `easyInterface.Diffraction.Calculator` class.
:param calculator: Calculator of the `easyInterface.Diffraction.Calculator` class.
"""
self._log: logging.logger = logging.getLogger(__class__.__module__)
self.project_dict: ProjectDict = ProjectDict.default()
self.calculator = calculator
# Set the calculator info
CALCULATOR_INFO = self.calculator.calculatorInfo()
for key in CALCULATOR_INFO.keys():
self.project_dict['calculator'][key] = CALCULATOR_INFO[key]
self.__last_updated: datetime = datetime.max
self.__last_calculated: datetime = datetime.min
self.setProjectFromCalculator()
self._log.info("Created: %s", self)
def __init__(self, u: Base, v: Base, w: Base, x: Base, y: Base):
"""
Dictionary store for resolution parameters
:param u: resolution parameter u
:param v: resolution parameter v
:param w: resolution parameter w
:param x: resolution parameter x
:param y: resolution parameter y
"""
super().__init__(u=u, v=v, w=w, x=x, y=y)
self._log = logging.getLogger(__class__.__module__)
self.setItemByPath(['u', 'header'],
RESOLUTION_DETAILS['UVWXY']['header'])
self.setItemByPath(['u', 'tooltip'],
RESOLUTION_DETAILS['UVWXY']['tooltip'])
self.setItemByPath(['u', 'url'], RESOLUTION_DETAILS['UVWXY']['url'])
self.setItemByPath(['v', 'header'],
RESOLUTION_DETAILS['UVWXY']['header'])
self.setItemByPath(['v', 'tooltip'],
RESOLUTION_DETAILS['UVWXY']['tooltip'])
self.setItemByPath(['v', 'url'], RESOLUTION_DETAILS['UVWXY']['url'])
self.setItemByPath(['w', 'header'],
RESOLUTION_DETAILS['UVWXY']['header'])
self.setItemByPath(['w', 'tooltip'],
RESOLUTION_DETAILS['UVWXY']['tooltip'])
self.setItemByPath(['w', 'url'], RESOLUTION_DETAILS['UVWXY']['url'])
self.setItemByPath(['x', 'header'],
RESOLUTION_DETAILS['UVWXY']['header'])
self.setItemByPath(['x', 'tooltip'],
RESOLUTION_DETAILS['UVWXY']['tooltip'])
self.setItemByPath(['x', 'url'], RESOLUTION_DETAILS['UVWXY']['url'])
self.setItemByPath(['y', 'header'],
RESOLUTION_DETAILS['UVWXY']['header'])
self.setItemByPath(['y', 'tooltip'],
RESOLUTION_DETAILS['UVWXY']['tooltip'])
self.setItemByPath(['y', 'url'], RESOLUTION_DETAILS['UVWXY']['url'])
def time_it(func):
"""
Times a function and reports the time either to the class' log or the base logger
:param func: function to be timed
:return: callable function with timer
"""
name = func.__module__ + '.' + func.__name__
time_logger = logger.getLogger('timer.' + name)
@wraps(func)
def _time_it(*args, **kwargs):
start = int(round(time() * 1000))
try:
return func(*args, **kwargs)
finally:
end_ = int(round(time() * 1000)) - start
time_logger.debug(
f"\033[1;34;49mExecution time: {end_ if end_ > 0 else 0} ms\033[0m"
)
return _time_it
def __init__(self,
x: list,
y_diff_lower: list,
y_diff_upper: list,
y_calc_up: list,
y_calc_down: list = [],
y_calc_bkg: list = []):
y_calc_down_temp = y_calc_down
if len(y_calc_down) == 0:
y_calc_down_temp = [0] * len(y_calc_up)
super().__init__(
x=x,
y_calc_sum=np.array(y_calc_up) + np.array(y_calc_down_temp),
y_calc_diff=np.array(y_calc_up) - np.array(y_calc_down_temp),
y_calc_up=y_calc_up,
y_calc_down=y_calc_down,
y_diff_lower=y_diff_lower,
y_diff_upper=y_diff_upper,
y_calc_bkg=y_calc_bkg)
self._log = logging.getLogger(__class__.__module__)
def __init__(self, name: str, spacegroup: SpaceGroup, cell: Cell,
atoms: Union[Atom, dict, Atoms], sites: dict):
"""
Constructor for a crystallographic phase
:param name: The name of the crystallographic phase
:param spacegroup: The phase spacegroup information
:param cell: The unit cell parameters
:param atoms: A collection of atoms for the unit cell
"""
if isinstance(atoms, Atom):
atoms = {
atoms['atom_site_label']: atoms,
}
atoms = Atoms(atoms)
super().__init__(phasename=name,
spacegroup=spacegroup,
cell=cell,
atoms=atoms,
sites=sites)
self._log = logging.getLogger(__class__.__module__)
self._log.debug('New phase created %s', name)
def __init__(self, parent=None):
super().__init__(parent)
self._project_dict = None
self._model = QStandardItemModel()
# set roles
self._label_role = Qt.UserRole + 1
self._atom_role = Qt.UserRole + 2
self._color_role = Qt.UserRole + 3
self._x_role = Qt.UserRole + 4
self._y_role = Qt.UserRole + 5
self._z_role = Qt.UserRole + 6
self._occupancy_role = Qt.UserRole + 7
self._model.setItemRoleNames({
self._label_role: b'label',
self._atom_role: b'atom',
self._color_role: b'colorStr',
self._x_role: b'xPos',
self._y_role: b'yPos',
self._z_role: b'zPos',
self._occupancy_role: b'occupancy'
})
self._log = logger.getLogger(self.__class__.__module__)
