def validate(self): is_invalid = {} if one_is_none([self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) try: self.adjustment_files[DetectorType.to_string(DetectorType.LAB)].validate() self.adjustment_files[DetectorType.to_string(DetectorType.HAB)].validate() except ValueError as e: is_invalid.update({"adjustment_files": str(e)}) if is_invalid: raise ValueError("StateWavelengthAndPixelAdjustment: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() if one_is_none( [self.wavelength_low, self.wavelength_high, self.wavelength_step]): entry = validation_message( "A wavelength entry has not been set.", "Make sure that all entries for the wavelength are set.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step }) is_invalid.update(entry) if is_not_none_and_first_larger_than_second( [self.wavelength_low, self.wavelength_high]): entry = validation_message( "Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high }) is_invalid.update(entry) if is_invalid: raise ValueError( "StateWavelength: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid, indent=4)))
def validate(self): # noqa is_invalid = {} if self.fit_type is FitType.Polynomial and self.polynomial_order == 0: entry = validation_message("You can only select a polynomial fit if you set a polynomial order (2 to 6).", "Make sure that you select a polynomial order.", {"fit_type": self.fit_type, "polynomial_order": self.polynomial_order}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.wavelength_low, self.wavelength_high]): entry = validation_message("Inconsistent wavelength setting.", "Make sure that you have specified both wavelength bounds (or none).", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if is_invalid: raise ValueError("StateTransmissionFit: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} if one_is_none([self.wavelength_interval, self.wavelength_step_type]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_low": self.wavelength_interval, "wavelength_step_type": self.wavelength_step_type}) is_invalid.update(entry) if self.wavelength_step_type is RangeStepType.NOT_SET: entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_step_type": self.wavelength_step_type}) is_invalid.update(entry) try: self.adjustment_files[DetectorType.LAB.value].validate() self.adjustment_files[DetectorType.HAB.value].validate() except ValueError as e: is_invalid.update({"adjustment_files": str(e)}) if is_invalid: raise ValueError("StateWavelengthAndPixelAdjustment: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): # noqa is_invalid = {} if self.fit_type is not FitType.Polynomial and self.polynomial_order != 0: entry = validation_message("You can only set a polynomial order of you selected polynomial fitting.", "Make sure that you select polynomial fitting.", {"fit_type": self.fit_type, "polynomial_order": self.polynomial_order}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.wavelength_low, self.wavelength_high]): entry = validation_message("Inconsistent wavelength setting.", "Make sure that you have specified both wavelength bounds (or none).", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if is_invalid: raise ValueError("StateTransmissionFit: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} # -------------------- # Vertical strip mask # -------------------- range_check(self.range_vertical_strip_start, self.range_vertical_strip_stop, is_invalid, "range_vertical_strip_start", "range_vertical_strip_stop", "range_vertical_strip") # -------------------- # Horizontal strip mask # -------------------- range_check(self.range_horizontal_strip_start, self.range_horizontal_strip_stop, is_invalid, "range_horizontal_strip_start", "range_horizontal_strip_stop", "range_horizontal_strip") # -------------------- # Block mask # -------------------- range_check(self.block_horizontal_start, self.block_horizontal_stop, is_invalid, "block_horizontal_start", "block_horizontal_stop", "block_horizontal") range_check(self.block_vertical_start, self.block_vertical_stop, is_invalid, "block_vertical_start", "block_vertical_stop", "block_vertical") # -------------------- # Time/Bin mask # -------------------- range_check(self.bin_mask_start, self.bin_mask_stop, is_invalid, "bin_mask_start", "bin_mask_stop", "bin_mask") if not self.detector_name: entry = validation_message( "Missing detector name.", "Make sure that the detector names are set.", {"detector_name": self.detector_name}) is_invalid.update(entry) if not self.detector_name_short: entry = validation_message( "Missing short detector name.", "Make sure that the short detector names are set.", {"detector_name_short": self.detector_name_short}) is_invalid.update(entry) # -------------------- # Spectrum Range # -------------------- range_check(self.spectrum_range_start, self.spectrum_range_stop, is_invalid, "spectrum_range_start", "spectrum_range_stop", "spectrum_range") if is_invalid: raise ValueError( "StateMoveDetectorISIS: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() if not is_pure_none_or_not_none([self.start_time, self.end_time]): entry = validation_message( "Missing slice times", "Makes sure that either both or none are set.", { "start_time": self.start_time, "end_time": self.end_time }) is_invalid.update(entry) if self.start_time and self.end_time: # The length of start_time and end_time needs to be identical if len(self.start_time) != len(self.end_time): entry = validation_message( "Bad relation of start and end", "Makes sure that the start time is smaller than the end time.", { "start_time": self.start_time, "end_time": self.end_time }) is_invalid.update(entry) # Each entry in start_time and end_time must be a float if len(self.start_time) == len( self.end_time) and len(self.start_time) > 0: for item in range(0, len(self.start_time)): for element1, element2 in zip(self.start_time, self.end_time): if not isinstance(element1, float) or not isinstance( element2, float): entry = validation_message( "Bad relation of start and end time entries", "The elements need to be floats.", { "start_time": self.start_time, "end_time": self.end_time }) is_invalid.update(entry) # Check that end_time is not smaller than start_time if not is_smaller(self.start_time, self.end_time): entry = validation_message( "Start time larger than end time.", "Make sure that the start time is not smaller than the end time.", { "start_time": self.start_time, "end_time": self.end_time }) is_invalid.update(entry) if is_invalid: raise ValueError( "StateSliceEvent: The provided inputs are illegal. " "Please see: {}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() # A sample scatter must be specified if self.sample_scatter is None: entry = validation_message( "Sample scatter was not specified.", "Make sure that the sample scatter file is specified.", {"sample_scatter": self.sample_scatter}) is_invalid.update(entry) # If the sample transmission/direct was specified, then a sample direct/transmission is required if not is_pure_none_or_not_none( [self.sample_transmission, self.sample_direct]): entry = validation_message( "If the sample transmission is specified then, the direct run needs to be " "specified too.", "Make sure that the transmission and direct runs are both specified (or none).", { "sample_transmission": self.sample_transmission, "sample_direct": self.sample_direct }) is_invalid.update(entry) # If the can transmission/direct was specified, then this requires the can scatter if (self.can_direct or self.can_transmission) and (not self.can_scatter): entry = validation_message( "If the can transmission is specified then the can scatter run needs to be " "specified too.", "Make sure that the can scatter file is set.", { "can_scatter": self.can_scatter, "can_transmission": self.can_transmission, "can_direct": self.can_direct }) is_invalid.update(entry) # If a can transmission/direct was specified, then the other can entries need to be specified as well. if self.can_scatter and not is_pure_none_or_not_none( [self.can_transmission, self.can_direct]): entry = validation_message( "Inconsistent can transmission setting.", "Make sure that the can transmission and can direct runs are set (or none of" " them).", { "can_transmission": self.can_transmission, "can_direct": self.can_direct }) is_invalid.update(entry) if is_invalid: raise ValueError("StateData: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} if self.detector_name == "" or self.detector_name is None: entry = validation_message("Missing detector name", "Make sure that a detector name was specified.", {"detector_name": self.detector_name}) is_invalid.update(entry) if self.detector_name_short == "" or self.detector_name_short is None: entry = validation_message("Missing short detector name", "Make sure that a short detector name was specified.", {"detector_name_short": self.detector_name_short}) is_invalid.update(entry) if is_invalid: raise ValueError("StateMoveDetectorISIS: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() # -------------------- # Radius Mask # -------------------- # Radius mask rule: the min radius must be less or equal to the max radius if self.radius_max is not None and self.radius_min is not None and\ self.radius_max != -1 and self.radius_min != -1: # noqa if self.radius_min > 0 and self.radius_max > 0 and ( self.radius_min > self.radius_max): entry = validation_message( "Incorrect radius bounds.", "Makes sure that the lower radius bound is smaller than the" " upper radius bound.", { "radius_min": self.radius_min, "radius_max": self.radius_max }) is_invalid.update(entry) # -------------------- # General bin mask # -------------------- range_check(self.bin_mask_general_start, self.bin_mask_general_stop, is_invalid, "bin_mask_general_start", "bin_mask_general_stop", "bin_mask_general") # -------------------- # Mask files # -------------------- if self.mask_files: for mask_file in self.mask_files: if not find_full_file_path(mask_file): entry = validation_message( "Mask file not found.", "Makes sure that the mask file is in your path", {"mask_file": self.mask_files}) is_invalid.update(entry) # -------------------- # Detectors # -------------------- for _, value in list(self.detectors.items()): value.validate() if is_invalid: raise ValueError("StateMask: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} # -------------------- # Vertical strip mask # -------------------- range_check(self.range_vertical_strip_start, self.range_vertical_strip_stop, is_invalid, "range_vertical_strip_start", "range_vertical_strip_stop", "range_vertical_strip") # -------------------- # Horizontal strip mask # -------------------- range_check(self.range_horizontal_strip_start, self.range_horizontal_strip_stop, is_invalid, "range_horizontal_strip_start", "range_horizontal_strip_stop", "range_horizontal_strip") # -------------------- # Block mask # -------------------- range_check(self.block_horizontal_start, self.block_horizontal_stop, is_invalid, "block_horizontal_start", "block_horizontal_stop", "block_horizontal") range_check(self.block_vertical_start, self.block_vertical_stop, is_invalid, "block_vertical_start", "block_vertical_stop", "block_vertical") # -------------------- # Time/Bin mask # -------------------- range_check(self.bin_mask_start, self.bin_mask_stop, is_invalid, "bin_mask_start", "bin_mask_stop", "bin_mask") if not self.detector_name: entry = validation_message("Missing detector name.", "Make sure that the detector names are set.", {"detector_name": self.detector_name}) is_invalid.update(entry) if not self.detector_name_short: entry = validation_message("Missing short detector name.", "Make sure that the short detector names are set.", {"detector_name_short": self.detector_name_short}) is_invalid.update(entry) # -------------------- # Spectrum Range # -------------------- range_check(self.spectrum_range_start, self.spectrum_range_stop, is_invalid, "spectrum_range_start", "spectrum_range_stop", "spectrum_range") if is_invalid: raise ValueError("StateMaskDetector: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def range_check(start, stop, invalid_dict, start_name, stop_name, general_name=None): """ Checks a start container against a stop container :param start: The start container :param stop: the stop container :param invalid_dict: The invalid dict to which we write our error messages :param start_name: The name of the start container :param stop_name: The name of the stop container :param general_name: The general name of this container family :return: A (potentially) updated invalid_dict """ if not is_pure_none_or_not_none([start, stop]): entry = validation_message("A range element has not been set.", "Make sure that all entries are set.", { start_name: start, stop_name: stop }) invalid_dict.update(entry) if start is not None and stop is not None: # Start and stop need to have the same length if len(start) != len(stop): entry = validation_message( "Start and stop ranges have different lengths.", "Make sure that all entries for {0} he same length.".format( general_name), { start_name: start, stop_name: stop }) invalid_dict.update(entry) # Start values need to be smaller than the stop values for a, b in zip(start, stop): if a > b: entry = validation_message( "Incorrect start-stop bounds.", "Make sure the lower bound is smaller than the upper bound for {0}." "".format(general_name), { start_name: start, stop_name: stop }) invalid_dict.update(entry) return invalid_dict
def validate(self): is_invalid = {} if one_is_none([ self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type ]): entry = validation_message( "A wavelength entry has not been set.", "Make sure that all entries are set.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type }) is_invalid.update(entry) if self.wavelength_step_type is RangeStepType.NOT_SET: entry = validation_message( "A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_step_type": self.wavelength_step_type}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second( [self.wavelength_low, self.wavelength_high]): entry = validation_message( "Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high }) is_invalid.update(entry) try: self.adjustment_files[DetectorType.LAB.value].validate() self.adjustment_files[DetectorType.HAB.value].validate() except ValueError as e: is_invalid.update({"adjustment_files": str(e)}) if is_invalid: raise ValueError( "StateWavelengthAndPixelAdjustment: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() # -------------------- # Radius Mask # -------------------- # Radius mask rule: the min radius must be less or equal to the max radius if self.radius_max is not None and self.radius_min is not None and\ self.radius_max != -1 and self.radius_min != -1: # noqa if self.radius_min > 0 and self.radius_max > 0 and (self.radius_min > self.radius_max): entry = validation_message("Incorrect radius bounds.", "Makes sure that the lower radius bound is smaller than the" " upper radius bound.", {"radius_min": self.radius_min, "radius_max": self.radius_max}) is_invalid.update(entry) # -------------------- # General bin mask # -------------------- range_check(self.bin_mask_general_start, self.bin_mask_general_stop, is_invalid, "bin_mask_general_start", "bin_mask_general_stop", "bin_mask_general") # -------------------- # Mask files # -------------------- if self.mask_files: for mask_file in self.mask_files: if not find_full_file_path(mask_file): entry = validation_message("Mask file not found.", "Makes sure that the mask file is in your path", {"mask_file": self.mask_files}) is_invalid.update(entry) # -------------------- # Detectors # -------------------- for _, value in list(self.detectors.items()): value.validate() if is_invalid: raise ValueError("StateMask: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() if one_is_none([self.wavelength_low, self.wavelength_high, self.wavelength_step]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries for the wavelength are set.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if is_invalid: raise ValueError("StateWavelength: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid, indent=4)))
def validate(self): is_invalid = dict() if not is_pure_none_or_not_none([self.start_time, self.end_time]): entry = validation_message("Missing slice times", "Makes sure that either both or none are set.", {"start_time": self.start_time, "end_time": self.end_time}) is_invalid.update(entry) if self.start_time and self.end_time: # The length of start_time and end_time needs to be identical if len(self.start_time) != len(self.end_time): entry = validation_message("Bad relation of start and end", "Makes sure that the start time is smaller than the end time.", {"start_time": self.start_time, "end_time": self.end_time}) is_invalid.update(entry) # Each entry in start_time and end_time must be a float if len(self.start_time) == len(self.end_time) and len(self.start_time) > 0: for item in range(0, len(self.start_time)): for element1, element2 in zip(self.start_time, self.end_time): if not isinstance(element1, float) or not isinstance(element2, float): entry = validation_message("Bad relation of start and end time entries", "The elements need to be floats.", {"start_time": self.start_time, "end_time": self.end_time}) is_invalid.update(entry) # Check that end_time is not smaller than start_time if not is_smaller(self.start_time, self.end_time): entry = validation_message("Start time larger than end time.", "Make sure that the start time is not smaller than the end time.", {"start_time": self.start_time, "end_time": self.end_time}) is_invalid.update(entry) if is_invalid: raise ValueError("StateSliceEvent: The provided inputs are illegal. " "Please see: {}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = dict() # A sample scatter must be specified if not self.sample_scatter: entry = validation_message("Sample scatter was not specified.", "Make sure that the sample scatter file is specified.", {"sample_scatter": self.sample_scatter}) is_invalid.update(entry) # If the sample transmission/direct was specified, then a sample direct/transmission is required if not is_pure_none_or_not_none([self.sample_transmission, self.sample_direct]): entry = validation_message("If the sample transmission is specified then, the direct run needs to be " "specified too.", "Make sure that the transmission and direct runs are both specified (or none).", {"sample_transmission": self.sample_transmission, "sample_direct": self.sample_direct}) is_invalid.update(entry) # If the can transmission/direct was specified, then this requires the can scatter if (self.can_direct or self.can_transmission) and (not self.can_scatter): entry = validation_message("If the can transmission is specified then the can scatter run needs to be " "specified too.", "Make sure that the can scatter file is set.", {"can_scatter": self.can_scatter, "can_transmission": self.can_transmission, "can_direct": self.can_direct}) is_invalid.update(entry) # If a can transmission/direct was specified, then the other can entries need to be specified as well. if self.can_scatter and not is_pure_none_or_not_none([self.can_transmission, self.can_direct]): entry = validation_message("Inconsistent can transmission setting.", "Make sure that the can transmission and can direct runs are set (or none of" " them).", {"can_transmission": self.can_transmission, "can_direct": self.can_direct}) is_invalid.update(entry) if is_invalid: raise ValueError("StateData: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def is_spectrum_range_all_on_one_detector(start, stop, invalid_dict, start_name, stop_name, instrument): for a, b in zip(start, stop): detector_a = get_bank_for_spectrum_number(a, instrument) detector_b = get_bank_for_spectrum_number(b, instrument) if detector_a is not detector_b: entry = validation_message("The lower and the upper bounds of the specified spectrum range S{0}{1} are on " "two different banks. They have to be on the same bank.".format(a, b), {start_name: start, stop_name: stop}) invalid_dict.update(entry) return return invalid_dict
def validate(self): is_invalid = dict() if one_is_none([self.wavelength_interval]): entry = validation_message( "A wavelength entry has not been set.", "Make sure that all entries for the wavelength are set.", {"wavelength_binning": self.wavelength_interval}) is_invalid.update(entry) if is_invalid: raise ValueError( "StateWavelength: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid, indent=4)))
def test_that_produces_correct_validation_message(self): # Arrange error_message = "test message." instruction = "do this." variables = {"var1": 12, "var2": "test"} # Act val_message = validation_message(error_message, instruction, variables) # Assert expected_text = "var1: 12\n" \ "var2: test\n" \ "" + instruction self.assertTrue(list(val_message.keys())[0] == error_message) self.assertTrue(val_message[error_message] == expected_text)
def test_that_produces_correct_validation_message(self): # Arrange error_message = "test message." instruction = "do this." variables = {"var1": 12, "var2": "test"} # Act val_message = validation_message(error_message, instruction, variables) # Assert expected_text = "var1: 12\n" \ "var2: test\n" \ "" + instruction self.assertTrue(val_message.keys()[0] == error_message) self.assertTrue(val_message[error_message] == expected_text)
def range_check(start, stop, invalid_dict, start_name, stop_name, general_name=None): """ Checks a start container against a stop container :param start: The start container :param stop: the stop container :param invalid_dict: The invalid dict to which we write our error messages :param start_name: The name of the start container :param stop_name: The name of the stop container :param general_name: The general name of this container family :return: A (potentially) updated invalid_dict """ if not is_pure_none_or_not_none([start, stop]): entry = validation_message("A range element has not been set.", "Make sure that all entries are set.", {start_name: start, stop_name: stop}) invalid_dict.update(entry) if start is not None and stop is not None: # Start and stop need to have the same length if len(start) != len(stop): entry = validation_message("Start and stop ranges have different lengths.", "Make sure that all entries for {0} he same length.".format(general_name), {start_name: start, stop_name: stop}) invalid_dict.update(entry) # Start values need to be smaller than the stop values for a, b in zip(start, stop): if a > b: entry = validation_message("Incorrect start-stop bounds.", "Make sure the lower bound is smaller than the upper bound for {0}." "".format(general_name), {start_name: start, stop_name: stop}) invalid_dict.update(entry) return invalid_dict
def validate(self): is_invalid = {} # ----------------- # incident Monitor # ----------------- if self.incident_monitor is None: is_invalid.update( {"incident_monitor": "An incident monitor must be specified."}) # ----------------- # Prompt peak # ----------------- if not is_pure_none_or_not_none( [self.prompt_peak_correction_min, self.prompt_peak_correction_max ]): entry = validation_message( "A prompt peak correction entry has not been set.", "Make sure that either all prompt peak entries have been set or none.", { "prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max }) is_invalid.update(entry) if is_not_none_and_first_larger_than_second( [self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message( "Incorrect prompt peak correction bounds.", "Make sure that lower prompt peak time bound is smaller then upper bound.", { "prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max }) is_invalid.update(entry) # ----------------- # Wavelength rebin # ----------------- if one_is_none([ self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type ]): entry = validation_message( "A wavelength entry has not been set.", "Make sure that all entries are set.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type }) is_invalid.update(entry) if is_not_none_and_first_larger_than_second( [self.wavelength_low, self.wavelength_high]): entry = validation_message( "Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", { "wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high }) is_invalid.update(entry) # ---------------------- # Background correction # ---------------------- if not is_pure_none_or_not_none([ self.background_TOF_general_start, self.background_TOF_general_stop ]): entry = validation_message( "A general background TOF entry has not been set.", "Make sure that either all general background TOF entries are set or none.", { "background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop }) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([ self.background_TOF_general_start, self.background_TOF_general_stop ]): entry = validation_message( "Incorrect general background TOF bounds.", "Make sure that lower general background TOF bound is smaller then upper bound.", { "background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop }) is_invalid.update(entry) if not is_pure_none_or_not_none([ self.background_TOF_monitor_start, self.background_TOF_monitor_stop ]): entry = validation_message( "A monitor background TOF entry has not been set.", "Make sure that either all monitor background TOF entries are set or none.", { "background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop }) is_invalid.update(entry) if self.background_TOF_monitor_start is not None and self.background_TOF_monitor_stop is not None: if len(self.background_TOF_monitor_start) != len( self.background_TOF_monitor_stop): entry = validation_message( "The monitor background TOF entries have a length mismatch.", "Make sure that all monitor background TOF entries have the same length.", { "background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop }) is_invalid.update(entry) for key_start, value_start in list( self.background_TOF_monitor_start.items()): if key_start not in self.background_TOF_monitor_stop: entry = validation_message( "The monitor background TOF had spectrum number mismatch.", "Make sure that all monitors have entries for start and stop.", { "background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop }) is_invalid.update(entry) else: value_stop = self.background_TOF_monitor_stop[key_start] if value_start > value_stop: entry = validation_message( "Incorrect monitor background TOF bounds.", "Make sure that lower monitor background TOF bound is" " smaller then upper bound.", { "background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop }) is_invalid.update(entry) if is_invalid: raise ValueError( "StateMoveDetector: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): # noqa is_invalid = {} # ----------------- # Incident monitor # ----------------- if self.incident_monitor is None and self.default_incident_monitor is None: entry = validation_message("No incident monitor was specified.", "Make sure that incident monitor has been specified.", {"incident_monitor": self.incident_monitor, "default_incident_monitor": self.default_incident_monitor}) is_invalid.update(entry) # -------------- # Transmission, either we need some ROI (ie radius, roi files /mask files) or a transmission monitor # -------------- has_no_transmission_monitor_setting = self.transmission_monitor is None and\ self.default_transmission_monitor is None # noqa has_no_transmission_roi_setting = self.transmission_radius_on_detector is None and\ self.transmission_roi_files is None # noqa if has_no_transmission_monitor_setting and has_no_transmission_roi_setting: entry = validation_message("No transmission settings were specified.", "Make sure that transmission settings are specified.", {"transmission_monitor": self.transmission_monitor, "default_transmission_monitor": self.default_transmission_monitor, "transmission_radius_on_detector": self.transmission_radius_on_detector, "transmission_roi_files": self.transmission_roi_files}) is_invalid.update(entry) # ----------------- # Prompt peak # ----------------- if not is_pure_none_or_not_none([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("Inconsistent prompt peak setting.", "Make sure that you have specified both prompt peak bounds (or none).", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("Incorrect prompt peak bounds.", "Make sure that lower prompt peak bound is smaller then upper bound.", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) # ----------------- # Wavelength rebin # ----------------- if one_is_none([self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type, self.wavelength_step_type, self.rebin_type]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type, "rebin_type": self.rebin_type}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if self.use_full_wavelength_range: if self.wavelength_full_range_low is None or self.wavelength_full_range_high is None: entry = validation_message("Incorrect full wavelength settings.", "Make sure that both full wavelength entries have been set.", {"wavelength_full_range_low": self.wavelength_full_range_low, "wavelength_full_range_high": self.wavelength_full_range_high}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_full_range_low, self.wavelength_full_range_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower full wavelength bound is smaller then upper bound.", {"wavelength_full_range_low": self.wavelength_full_range_low, "wavelength_full_range_high": self.wavelength_full_range_high}) is_invalid.update(entry) # ---------------------- # Background correction # ---------------------- if not is_pure_none_or_not_none([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("A general background TOF entry has not been set.", "Make sure that either all general background TOF entries are set or none.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("Incorrect general background TOF bounds.", "Make sure that lower general background TOF bound is smaller then upper bound.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.background_TOF_roi_start, self.background_TOF_roi_stop]): entry = validation_message("A ROI background TOF entry has not been set.", "Make sure that either all ROI background TOF entries are set or none.", {"background_TOF_roi_start": self.background_TOF_roi_start, "background_TOF_roi_stop": self.background_TOF_roi_stop}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.background_TOF_roi_start, self.background_TOF_roi_stop]): entry = validation_message("Incorrect ROI background TOF bounds.", "Make sure that lower ROI background TOF bound is smaller then upper bound.", {"background_TOF_roi_start": self.background_TOF_roi_start, "background_TOF_roi_stop": self.background_TOF_roi_stop}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.background_TOF_monitor_start, self.background_TOF_monitor_stop]): entry = validation_message("A monitor background TOF entry has not been set.", "Make sure that either all monitor background TOF entries are set or none.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) if self.background_TOF_monitor_start is not None and self.background_TOF_monitor_stop is not None: if len(self.background_TOF_monitor_start) != len(self.background_TOF_monitor_stop): entry = validation_message("The monitor background TOF entries have a length mismatch.", "Make sure that all monitor background TOF entries have the same length.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) for key_start, value_start in list(self.background_TOF_monitor_start.items()): if key_start not in self.background_TOF_monitor_stop: entry = validation_message("The monitor background TOF had spectrum number mismatch.", "Make sure that all monitors have entries for start and stop.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) else: value_stop = self.background_TOF_monitor_stop[key_start] if value_start > value_stop: entry = validation_message("Incorrect monitor background TOF bounds.", "Make sure that lower monitor background TOF bound is" " smaller then upper bound.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) # ----- # Fit # ----- self.fit[DataType.to_string(DataType.Sample)].validate() self.fit[DataType.to_string(DataType.Can)].validate() if is_invalid: raise ValueError("StateCalculateTransmission: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} # 1D Q settings if not is_pure_none_or_not_none([self.q_min, self.q_max]): entry = validation_message("The q boundaries for the 1D reduction are inconsistent.", "Make sure that both q boundaries are set (or none).", {"q_min": self.q_min, "q_max": self.q_max}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.q_min, self.q_max]): entry = validation_message("Incorrect q bounds for 1D reduction.", "Make sure that the lower q bound is smaller than the upper q bound.", {"q_min": self.q_min, "q_max": self.q_max}) is_invalid.update(entry) if self.reduction_dimensionality is ReductionDimensionality.OneDim: if self.q_min is None or self.q_max is None: entry = validation_message("Q bounds not set for 1D reduction.", "Make sure to set the q boundaries when using a 1D reduction.", {"q_min": self.q_min, "q_max": self.q_max}) is_invalid.update(entry) if self.q_1d_rebin_string is not None: if self.q_1d_rebin_string == "": entry = validation_message("Q rebin string does not seem to be valid.", "Make sure to provide a valid rebin string", {"q_1d_rebin_string": self.q_1d_rebin_string}) is_invalid.update(entry) elif not is_valid_rebin_string(self.q_1d_rebin_string): entry = validation_message("Q rebin string does not seem to be valid.", "Make sure to provide a valid rebin string", {"q_1d_rebin_string": self.q_1d_rebin_string}) is_invalid.update(entry) # QXY settings if self.reduction_dimensionality is ReductionDimensionality.TwoDim: if self.q_xy_max is None or self.q_xy_step is None: entry = validation_message("Q bounds not set for 2D reduction.", "Make sure that the q_max value bound and the step for the 2D reduction.", {"q_xy_max": self.q_xy_max, "q_xy_step": self.q_xy_step}) is_invalid.update(entry) # Q Resolution settings if self.use_q_resolution: if not is_pure_none_or_not_none([self.q_resolution_a1, self.q_resolution_a2]): entry = validation_message("Inconsistent circular geometry.", "Make sure that both diameters for the circular apertures are set.", {"q_resolution_a1": self.q_resolution_a1, "q_resolution_a2": self.q_resolution_a2}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.q_resolution_h1, self.q_resolution_h2, self.q_resolution_w1, self.q_resolution_w2]): entry = validation_message("Inconsistent rectangular geometry.", "Make sure that both diameters for the circular apertures are set.", {"q_resolution_h1": self.q_resolution_h1, "q_resolution_h2": self.q_resolution_h2, "q_resolution_w1": self.q_resolution_w1, "q_resolution_w2": self.q_resolution_w2}) is_invalid.update(entry) if all(element is None for element in [self.q_resolution_a1, self.q_resolution_a2, self.q_resolution_w1, self.q_resolution_w2, self.q_resolution_h1, self.q_resolution_h2]): entry = validation_message("Aperture is undefined.", "Make sure that you set the geometry for a circular or a " "rectangular aperture.", {"q_resolution_a1": self.q_resolution_a1, "q_resolution_a2": self.q_resolution_a2, "q_resolution_h1": self.q_resolution_h1, "q_resolution_h2": self.q_resolution_h2, "q_resolution_w1": self.q_resolution_w1, "q_resolution_w2": self.q_resolution_w2}) is_invalid.update(entry) if self.moderator_file is None: entry = validation_message("Missing moderator file.", "Make sure to specify a moderator file when using q resolution.", {"moderator_file": self.moderator_file}) is_invalid.update(entry) is_invalid.update({"moderator_file": "A moderator file is required for the q resolution calculation."}) if is_invalid: raise ValueError("StateMoveDetectorISIS: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} # 1D Q settings if not is_pure_none_or_not_none([self.q_min, self.q_max]): entry = validation_message( "The q boundaries for the 1D reduction are inconsistent.", "Make sure that both q boundaries are set (or none).", { "q_min": self.q_min, "q_max": self.q_max }) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.q_min, self.q_max]): entry = validation_message( "Incorrect q bounds for 1D reduction.", "Make sure that the lower q bound is smaller than the upper q bound.", { "q_min": self.q_min, "q_max": self.q_max }) is_invalid.update(entry) if self.reduction_dimensionality is ReductionDimensionality.ONE_DIM: if self.q_min is None or self.q_max is None: entry = validation_message( "Q bounds not set for 1D reduction.", "Make sure to set the q boundaries when using a 1D reduction.", { "q_min": self.q_min, "q_max": self.q_max }) is_invalid.update(entry) if self.q_1d_rebin_string is not None: if self.q_1d_rebin_string == "": entry = validation_message( "Q rebin string does not seem to be valid.", "Make sure to provide a valid rebin string", {"q_1d_rebin_string": self.q_1d_rebin_string}) is_invalid.update(entry) elif not is_valid_rebin_string(self.q_1d_rebin_string): entry = validation_message( "Q rebin string does not seem to be valid.", "Make sure to provide a valid rebin string", {"q_1d_rebin_string": self.q_1d_rebin_string}) is_invalid.update(entry) # QXY settings if self.reduction_dimensionality is ReductionDimensionality.TWO_DIM: if self.q_xy_max is None or self.q_xy_step is None: entry = validation_message( "Q bounds not set for 2D reduction.", "Make sure that the q_max value bound and the step for the 2D reduction.", { "q_xy_max": self.q_xy_max, "q_xy_step": self.q_xy_step }) is_invalid.update(entry) # Q Resolution settings if self.use_q_resolution: if not is_pure_none_or_not_none( [self.q_resolution_a1, self.q_resolution_a2]): entry = validation_message( "Inconsistent circular geometry.", "Make sure that both diameters for the circular apertures are set.", { "q_resolution_a1": self.q_resolution_a1, "q_resolution_a2": self.q_resolution_a2 }) is_invalid.update(entry) if not is_pure_none_or_not_none([ self.q_resolution_h1, self.q_resolution_h2, self.q_resolution_w1, self.q_resolution_w2 ]): entry = validation_message( "Inconsistent rectangular geometry.", "Make sure that both diameters for the circular apertures are set.", { "q_resolution_h1": self.q_resolution_h1, "q_resolution_h2": self.q_resolution_h2, "q_resolution_w1": self.q_resolution_w1, "q_resolution_w2": self.q_resolution_w2 }) is_invalid.update(entry) if all(element is None for element in [ self.q_resolution_a1, self.q_resolution_a2, self.q_resolution_w1, self.q_resolution_w2, self.q_resolution_h1, self.q_resolution_h2 ]): entry = validation_message( "Aperture is undefined.", "Make sure that you set the geometry for a circular or a " "rectangular aperture.", { "q_resolution_a1": self.q_resolution_a1, "q_resolution_a2": self.q_resolution_a2, "q_resolution_h1": self.q_resolution_h1, "q_resolution_h2": self.q_resolution_h2, "q_resolution_w1": self.q_resolution_w1, "q_resolution_w2": self.q_resolution_w2 }) is_invalid.update(entry) if self.moderator_file is None: entry = validation_message( "Missing moderator file.", "Make sure to specify a moderator file when using q resolution.", {"moderator_file": self.moderator_file}) is_invalid.update(entry) is_invalid.update({ "moderator_file": "A moderator file is required for the q resolution calculation." }) if is_invalid: raise ValueError( "StateMoveDetectorISIS: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): # noqa is_invalid = {} # ----------------- # Incident monitor # ----------------- if self.incident_monitor is None and self.default_incident_monitor is None: entry = validation_message("No incident monitor was specified.", "Make sure that incident monitor has been specified.", {"incident_monitor": self.incident_monitor, "default_incident_monitor": self.default_incident_monitor}) is_invalid.update(entry) # -------------- # Transmission, either we need some ROI (ie radius, roi files /mask files) or a transmission monitor # -------------- has_no_transmission_monitor_setting = self.transmission_monitor is None and\ self.default_transmission_monitor is None # noqa has_no_transmission_roi_setting = self.transmission_radius_on_detector is None and\ self.transmission_roi_files is None # noqa if has_no_transmission_monitor_setting and has_no_transmission_roi_setting: entry = validation_message("No transmission settings were specified.", "Make sure that transmission settings are specified.", {"transmission_monitor": self.transmission_monitor, "default_transmission_monitor": self.default_transmission_monitor, "transmission_radius_on_detector": self.transmission_radius_on_detector, "transmission_roi_files": self.transmission_roi_files}) is_invalid.update(entry) # ----------------- # Prompt peak # ----------------- if not is_pure_none_or_not_none([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("Inconsistent prompt peak setting.", "Make sure that you have specified both prompt peak bounds (or none).", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("Incorrect prompt peak bounds.", "Make sure that lower prompt peak bound is smaller then upper bound.", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) # ----------------- # Wavelength rebin # ----------------- if one_is_none([self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type, self.rebin_type]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type, "rebin_type": self.rebin_type}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) if self.use_full_wavelength_range: if self.wavelength_full_range_low is None or self.wavelength_full_range_high is None: entry = validation_message("Incorrect full wavelength settings.", "Make sure that both full wavelength entries have been set.", {"wavelength_full_range_low": self.wavelength_full_range_low, "wavelength_full_range_high": self.wavelength_full_range_high}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_full_range_low, self.wavelength_full_range_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower full wavelength bound is smaller then upper bound.", {"wavelength_full_range_low": self.wavelength_full_range_low, "wavelength_full_range_high": self.wavelength_full_range_high}) is_invalid.update(entry) # ---------------------- # Background correction # ---------------------- if not is_pure_none_or_not_none([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("A general background TOF entry has not been set.", "Make sure that either all general background TOF entries are set or none.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("Incorrect general background TOF bounds.", "Make sure that lower general background TOF bound is smaller then upper bound.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.background_TOF_roi_start, self.background_TOF_roi_stop]): entry = validation_message("A ROI background TOF entry has not been set.", "Make sure that either all ROI background TOF entries are set or none.", {"background_TOF_roi_start": self.background_TOF_roi_start, "background_TOF_roi_stop": self.background_TOF_roi_stop}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.background_TOF_roi_start, self.background_TOF_roi_stop]): entry = validation_message("Incorrect ROI background TOF bounds.", "Make sure that lower ROI background TOF bound is smaller then upper bound.", {"background_TOF_roi_start": self.background_TOF_roi_start, "background_TOF_roi_stop": self.background_TOF_roi_stop}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.background_TOF_monitor_start, self.background_TOF_monitor_stop]): entry = validation_message("A monitor background TOF entry has not been set.", "Make sure that either all monitor background TOF entries are set or none.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) if self.background_TOF_monitor_start is not None and self.background_TOF_monitor_stop is not None: if len(self.background_TOF_monitor_start) != len(self.background_TOF_monitor_stop): entry = validation_message("The monitor background TOF entries have a length mismatch.", "Make sure that all monitor background TOF entries have the same length.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) for key_start, value_start in self.background_TOF_monitor_start.items(): if key_start not in self.background_TOF_monitor_stop: entry = validation_message("The monitor background TOF had spectrum number mismatch.", "Make sure that all monitors have entries for start and stop.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) else: value_stop = self.background_TOF_monitor_stop[key_start] if value_start > value_stop: entry = validation_message("Incorrect monitor background TOF bounds.", "Make sure that lower monitor background TOF bound is" " smaller then upper bound.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) # ----- # Fit # ----- self.fit[DataType.to_string(DataType.Sample)].validate() self.fit[DataType.to_string(DataType.Can)].validate() if is_invalid: raise ValueError("StateCalculateTransmission: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))
def validate(self): is_invalid = {} # ----------------- # incident Monitor # ----------------- if self.incident_monitor is None: is_invalid.update({"incident_monitor": "An incident monitor must be specified."}) # ----------------- # Prompt peak # ----------------- if not is_pure_none_or_not_none([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("A prompt peak correction entry has not been set.", "Make sure that either all prompt peak entries have been set or none.", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.prompt_peak_correction_min, self.prompt_peak_correction_max]): entry = validation_message("Incorrect prompt peak correction bounds.", "Make sure that lower prompt peak time bound is smaller then upper bound.", {"prompt_peak_correction_min": self.prompt_peak_correction_min, "prompt_peak_correction_max": self.prompt_peak_correction_max}) is_invalid.update(entry) # ----------------- # Wavelength rebin # ----------------- if one_is_none([self.wavelength_low, self.wavelength_high, self.wavelength_step, self.wavelength_step_type]): entry = validation_message("A wavelength entry has not been set.", "Make sure that all entries are set.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high, "wavelength_step": self.wavelength_step, "wavelength_step_type": self.wavelength_step_type}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.wavelength_low, self.wavelength_high]): entry = validation_message("Incorrect wavelength bounds.", "Make sure that lower wavelength bound is smaller then upper bound.", {"wavelength_low": self.wavelength_low, "wavelength_high": self.wavelength_high}) is_invalid.update(entry) # ---------------------- # Background correction # ---------------------- if not is_pure_none_or_not_none([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("A general background TOF entry has not been set.", "Make sure that either all general background TOF entries are set or none.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if is_not_none_and_first_larger_than_second([self.background_TOF_general_start, self.background_TOF_general_stop]): entry = validation_message("Incorrect general background TOF bounds.", "Make sure that lower general background TOF bound is smaller then upper bound.", {"background_TOF_general_start": self.background_TOF_general_start, "background_TOF_general_stop": self.background_TOF_general_stop}) is_invalid.update(entry) if not is_pure_none_or_not_none([self.background_TOF_monitor_start, self.background_TOF_monitor_stop]): entry = validation_message("A monitor background TOF entry has not been set.", "Make sure that either all monitor background TOF entries are set or none.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) if self.background_TOF_monitor_start is not None and self.background_TOF_monitor_stop is not None: if len(self.background_TOF_monitor_start) != len(self.background_TOF_monitor_stop): entry = validation_message("The monitor background TOF entries have a length mismatch.", "Make sure that all monitor background TOF entries have the same length.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) for key_start, value_start in list(self.background_TOF_monitor_start.items()): if key_start not in self.background_TOF_monitor_stop: entry = validation_message("The monitor background TOF had spectrum number mismatch.", "Make sure that all monitors have entries for start and stop.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) else: value_stop = self.background_TOF_monitor_stop[key_start] if value_start > value_stop: entry = validation_message("Incorrect monitor background TOF bounds.", "Make sure that lower monitor background TOF bound is" " smaller then upper bound.", {"background_TOF_monitor_start": self.background_TOF_monitor_start, "background_TOF_monitor_stop": self.background_TOF_monitor_stop}) is_invalid.update(entry) if is_invalid: raise ValueError("StateMoveDetector: The provided inputs are illegal. " "Please see: {0}".format(json.dumps(is_invalid)))