def is_sliceable(workspace): ws = get_workspace_handle(workspace) if isinstance(ws, PixelWorkspace): return True else: validator = WorkspaceUnitValidator('DeltaE') return isinstance(ws, Workspace) and validator.isValid(ws.raw_ws) == ''
def PyInit(self): """ Declare properties """ allowed_units = CompositeValidator([ WorkspaceUnitValidator("DeltaE"), WorkspaceUnitValidator("Momentum") ], relation=CompositeRelation.OR) self.declareProperty( IEventWorkspaceProperty("InputWorkspace", "", direction=Direction.Input, validator=allowed_units), doc="Input workspace. It has to be an event workspace" + " with units of energy transfer or momentum") self.declareProperty(name="XMin", defaultValue=Property.EMPTY_DBL, direction=Direction.Input, validator=FloatMandatoryValidator(), doc="Minimum energy transfer or momentum") self.declareProperty(name="XMax", defaultValue=Property.EMPTY_DBL, direction=Direction.Input, validator=FloatMandatoryValidator(), doc="Maximum energy transfer or momentum") self.declareProperty(WorkspaceProperty('OutputWorkspace', '', direction=Direction.Output), doc='Output workspace')
def PyInit(self): self.declareProperty(MatrixWorkspaceProperty( 'InputWorkspace', '', direction=Direction.Input, validator=WorkspaceUnitValidator("Wavelength")), doc='Flood weighting measurement') self.declareProperty(MatrixWorkspaceProperty( 'TransmissionWorkspace', '', direction=Direction.Input, optional=PropertyMode.Optional, validator=WorkspaceUnitValidator("Wavelength")), doc='Flood weighting measurement') validator = FloatArrayBoundedValidator(lower=0.) self.declareProperty( FloatArrayProperty('Bands', [], direction=Direction.Input, validator=validator), doc='Wavelength bands to use. Single pair min to max.') self.declareProperty(MatrixWorkspaceProperty( 'OutputWorkspace', '', direction=Direction.Output), doc='Normalized flood weighting measurement') self.declareProperty("SolidAngleCorrection", True, direction=Direction.Input, doc="Perform final solid angle correction")
def PyInit(self): """Initialize the input and output properties of the algorithm.""" threeNonnegativeInts = CompositeValidator() threeNonnegativeInts.add(IntArrayLengthValidator(3)) nonnegativeInts = IntArrayBoundedValidator() nonnegativeInts.setLower(0) threeNonnegativeInts.add(nonnegativeInts) self.declareProperty( MatrixWorkspaceProperty( Prop.INPUT_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='An input workspace (units wavelength) to be integrated.') self.declareProperty( MatrixWorkspaceProperty(Prop.OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The integrated foreground divided by the summed direct beam.') self.declareProperty(Prop.SUBALG_LOGGING, defaultValue=SubalgLogging.OFF, validator=StringListValidator( [SubalgLogging.OFF, SubalgLogging.ON]), doc='Enable or disable child algorithm logging.') self.declareProperty( Prop.CLEANUP, defaultValue=common.WSCleanup.ON, validator=StringListValidator( [common.WSCleanup.ON, common.WSCleanup.OFF]), doc='Enable or disable intermediate workspace cleanup.') self.declareProperty(Prop.SUM_TYPE, defaultValue=SumType.IN_LAMBDA, validator=StringListValidator( [SumType.IN_LAMBDA, SumType.IN_Q]), doc='Type of summation to perform.') self.declareProperty( MatrixWorkspaceProperty( Prop.DIRECT_FOREGROUND_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional, validator=WorkspaceUnitValidator('Wavelength')), doc= 'Summed direct beam workspace if output in reflectivity is required.' ) self.declareProperty( IntArrayProperty(Prop.FOREGROUND_INDICES, values=[ Property.EMPTY_INT, Property.EMPTY_INT, Property.EMPTY_INT ], validator=threeNonnegativeInts), doc= 'A three element array of foreground start, centre and end workspace indices.' )
def PyInit(self): """Initialize the input and output properties of the algorithm.""" positiveFloat = FloatBoundedValidator(lower=0., exclusive=True) self.declareProperty( MatrixWorkspaceProperty( Prop.INPUT_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='A reflectivity workspace in wavelength to be converted to Q.') self.declareProperty(MatrixWorkspaceProperty( Prop.OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The input workspace in momentum transfer.') self.declareProperty(Prop.SUBALG_LOGGING, defaultValue=SubalgLogging.OFF, validator=StringListValidator( [SubalgLogging.OFF, SubalgLogging.ON]), doc='Enable or disable child algorithm logging.') self.declareProperty( Prop.CLEANUP, defaultValue=common.WSCleanup.ON, validator=StringListValidator( [common.WSCleanup.ON, common.WSCleanup.OFF]), doc='Enable or disable intermediate workspace cleanup.') self.declareProperty( MatrixWorkspaceProperty( Prop.REFLECTED_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc= 'A non-summed reflected beam workspace, needed for Q resolution calculation.' ) self.declareProperty( MatrixWorkspaceProperty( Prop.DIRECT_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc= 'A non-summed direct beam workspace, needed for Q resolution calculation.' ) self.declareProperty( Prop.POLARIZED, defaultValue=False, doc= 'True if input workspace has been corrected for polarization efficiencies.' ) self.declareProperty( Prop.GROUPING_FRACTION, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, doc= 'If set, group the output by steps of this fraction multiplied by Q resolution' )
def is_cuttable(workspace): workspace = get_workspace_handle(workspace) try: is2D = workspace.raw_ws.getNumDims() == 2 except AttributeError: is2D = False if not is2D: return False if isinstance(workspace, PixelWorkspace): return True else: validator = WorkspaceUnitValidator('DeltaE') return isinstance(workspace, Workspace2D) and validator.isValid(workspace.raw_ws) == ''
def is_cuttable(workspace): workspace = get_workspace_handle(workspace) try: is2D = workspace.raw_ws.getNumDims() == 2 except AttributeError: is2D = False if not is2D: return False if isinstance(workspace, PixelWorkspace): return True else: validator = WorkspaceUnitValidator('DeltaE') return isinstance(workspace, Workspace2D) and validator.isValid( workspace.raw_ws) == ''
def PyInit(self): inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) positiveFloat = FloatBoundedValidator(lower=0) self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, optional=PropertyMode.Mandatory, direction=Direction.Input), doc='Input workspace.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The output of the algorithm.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=common.CLEANUP_ON, validator=StringListValidator( [common.CLEANUP_ON, common.CLEANUP_OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty( ITableWorkspaceProperty(name=common.PROP_EPP_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Mandatory), doc='Table workspace containing results from the FindEPP algorithm.' ) self.declareProperty( name=common.PROP_DWF_CORRECTION, defaultValue=common.DWF_ON, validator=StringListValidator([common.DWF_ON, common.DWF_OFF]), direction=Direction.Input, doc= 'Enable or disable the correction for the Debye-Waller factor for ' + common.PROP_OUTPUT_WS + '.') self.declareProperty( name=common.PROP_TEMPERATURE, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc='Experimental temperature (Vanadium ' + 'reduction type only) for the Debye-Waller correction, in Kelvins.' ) self.setPropertySettings( common.PROP_TEMPERATURE, EnabledWhenProperty(common.PROP_DWF_CORRECTION, PropertyCriterion.IsDefault))
def PyInit(self): """Initialize the algorithm's input and output properties.""" inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) mustBePositive = FloatBoundedValidator(lower=0) # Properties. self.declareProperty( MatrixWorkspaceProperty(name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input), doc='A workspace to which to apply the corrections.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The corrected workspace.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=utils.Cleanup.ON, validator=StringListValidator( [utils.Cleanup.ON, utils.Cleanup.OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to print in the logs.') self.declareProperty( MatrixWorkspaceProperty(name=common.PROP_EC_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input, optional=PropertyMode.Optional), doc= 'An empty container workspace for subtraction from the input workspace.' ) self.declareProperty( name=common.PROP_EC_SCALING, defaultValue=1.0, validator=mustBePositive, direction=Direction.Input, doc= 'A multiplier (transmission, if no self shielding is applied) for the empty container.' ) self.declareProperty( MatrixWorkspaceProperty( name=common.PROP_SELF_SHIELDING_CORRECTION_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='A workspace containing the self shielding correction factors.' )
def PyInit(self): ws_validator = CompositeValidator([WorkspaceUnitValidator('Wavelength'), InstrumentValidator()]) self.declareProperty(MatrixWorkspaceProperty('SampleWorkspace', '', direction=Direction.Input, validator=ws_validator), doc='Name for the input sample workspace') self.declareProperty(name='SampleChemicalFormula', defaultValue='', validator=StringMandatoryValidator(), doc='Sample chemical formula') self.declareProperty(name='SampleNumberDensity', defaultValue=0.1, validator=FloatBoundedValidator(0.0), doc='Sample number density in atoms/Angstrom3') self.declareProperty(name='SampleThickness', defaultValue=0.0, validator=FloatBoundedValidator(0.0), doc='Sample thickness in cm') self.declareProperty(name='SampleAngle', defaultValue=0.0, doc='Sample angle in degrees') self.declareProperty(MatrixWorkspaceProperty('CanWorkspace', '', direction=Direction.Input, optional=PropertyMode.Optional, validator=ws_validator), doc="Name for the input container workspace") self.declareProperty(name='CanChemicalFormula', defaultValue='', doc='Container chemical formula') self.declareProperty(name='CanNumberDensity', defaultValue=0.1, validator=FloatBoundedValidator(0.0), doc='Container number density in atoms/Angstrom3') self.declareProperty(name='CanFrontThickness', defaultValue=0.0, validator=FloatBoundedValidator(0.0), doc='Container front thickness in cm') self.declareProperty(name='CanBackThickness', defaultValue=0.0, validator=FloatBoundedValidator(0.0), doc='Container back thickness in cm') self.declareProperty(name='NumberWavelengths', defaultValue=10, validator=IntBoundedValidator(1), doc='Number of wavelengths for calculation') self.declareProperty(name='Interpolate', defaultValue=True, doc='Interpolate the correction workspaces to match the sample workspace') self.declareProperty(name='Emode', defaultValue='Elastic', validator=StringListValidator(['Elastic', 'Indirect']), doc='Emode: Elastic or Indirect') self.declareProperty(name='Efixed', defaultValue=1.0, doc='Analyser energy') self.declareProperty(WorkspaceGroupProperty('OutputWorkspace', '', direction=Direction.Output), doc='The output corrections workspace group')
def PyInit(self): ws_validator = CompositeValidator([WorkspaceUnitValidator('Wavelength'), InstrumentValidator()]) self.declareProperty(MatrixWorkspaceProperty('SampleWorkspace', '', direction=Direction.Input, validator=ws_validator), doc='Name for the input sample workspace') self.declareProperty(name='SampleChemicalFormula', defaultValue='', validator=StringMandatoryValidator(), doc='Sample chemical formula') self.declareProperty(name='SampleNumberDensity', defaultValue=0.1, validator=FloatBoundedValidator(0.0), doc='Sample number density in atoms/Angstrom3') self.declareProperty(name='SampleInnerRadius', defaultValue=0.05, doc='Sample inner radius') self.declareProperty(name='SampleOuterRadius', defaultValue=0.1, doc='Sample outer radius') self.declareProperty(MatrixWorkspaceProperty('CanWorkspace', '', direction=Direction.Input, optional=PropertyMode.Optional, validator=ws_validator), doc="Name for the input container workspace") self.declareProperty(name='CanChemicalFormula', defaultValue='', doc='Container chemical formula') self.declareProperty(name='CanNumberDensity', defaultValue=0.1, validator=FloatBoundedValidator(0.0), doc='Container number density in atoms/Angstrom3') self.declareProperty(name='CanOuterRadius', defaultValue=0.15, doc='Can outer radius') self.declareProperty(name='BeamHeight', defaultValue=3.0, doc='Height of the beam at the sample.') self.declareProperty(name='BeamWidth', defaultValue=2.0, doc='Width of the beam at the sample.') self.declareProperty(name='StepSize', defaultValue=0.002, doc='Step size for calculation') self.declareProperty(name='Interpolate', defaultValue=True, doc='Interpolate the correction workspaces to match the sample workspace') self.declareProperty(name='Emode', defaultValue='Elastic', validator=StringListValidator(['Elastic', 'Indirect']), doc='Emode: Elastic or Indirect') self.declareProperty(name='Efixed', defaultValue=1.0, doc='Analyser energy') self.declareProperty(WorkspaceGroupProperty('OutputWorkspace', '', direction=Direction.Output), doc='The output corrections workspace group')
def PyInit(self): """Declare properties """ wsValidators = CompositeValidator() # X axis must be a NumericAxis in energy transfer units. wsValidators.add(WorkspaceUnitValidator("DeltaE")) # Workspace must have an Instrument wsValidators.add(InstrumentValidator()) self.declareProperty(MatrixWorkspaceProperty(name="InputWorkspace", defaultValue="", direction=Direction.Input, validator=wsValidators), doc="Workspace name for input") self.declareProperty(FileProperty(name="Filename", defaultValue="", action=FileAction.Save, extensions=""), doc="The name to use when writing the file")
def PyInit(self): # input self.declareProperty(MatrixWorkspaceProperty( "InputWorkspace", "", direction=Direction.Input, validator=WorkspaceUnitValidator("TOF")), doc="Input Sample or Vanadium workspace") # output self.declareProperty( ITableWorkspaceProperty("OutputWorkspace", "", Direction.Output), doc="The name of the table workspace that will be created.")
def PyInit(self): """Initialize the algorithm's input and output properties.""" inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) scalingFactor = FloatBoundedValidator(lower=0, upper=1) # Properties. self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input), doc='Input workspace.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The output of the algorithm.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=common.CLEANUP_ON, validator=StringListValidator( [common.CLEANUP_ON, common.CLEANUP_OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_EC_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input, optional=PropertyMode.Optional), doc='Reduced empty container workspace.') self.declareProperty(name=common.PROP_EC_SCALING, defaultValue=1.0, validator=scalingFactor, direction=Direction.Input, doc='Scaling factor (transmission, if no self ' + 'shielding is applied) for empty container.') self.declareProperty( MatrixWorkspaceProperty( name=common.PROP_SELF_SHIELDING_CORRECTION_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='A workspace containing self shielding correction factors.')
def PyInit(self): """Initialize the input and output properties of the algorithm.""" positiveFloat = FloatBoundedValidator(lower=0., exclusive=True) self.declareProperty( MatrixWorkspaceProperty( Prop.INPUT_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='A reflectivity workspace in wavelength to be converted to Q.') self.declareProperty( MatrixWorkspaceProperty( Prop.OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The input workspace in momentum transfer.') self.declareProperty( Prop.SUBALG_LOGGING, defaultValue=SubalgLogging.OFF, validator=StringListValidator([SubalgLogging.OFF, SubalgLogging.ON]), doc='Enable or disable child algorithm logging.') self.declareProperty( Prop.CLEANUP, defaultValue=utils.Cleanup.ON, validator=StringListValidator([utils.Cleanup.ON, utils.Cleanup.OFF]), doc='Enable or disable intermediate workspace cleanup.') self.declareProperty( MatrixWorkspaceProperty( Prop.DIRECT_FOREGROUND_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='Summed direct beam workspace.') self.declareProperty( Prop.GROUPING_FRACTION, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, doc='If set, group the output by steps of this fraction multiplied by Q resolution')
def PyInit(self): validator = CompositeValidator() validator.add(WorkspaceUnitValidator('Wavelength')) validator.add(HistogramValidator()) validator.add(InstrumentValidator()) self.declareProperty(MatrixWorkspaceProperty('InputWorkspace', defaultValue='', validator = validator, direction = Direction.Input), doc='The input workspace in wavelength') self.declareProperty('BeamRadius', 0.1, FloatBoundedValidator(lower=0.), 'The radius of the beam [m]') self.declareProperty(MatrixWorkspaceProperty('OutputWorkspace', defaultValue='', direction = Direction.Output), doc='The output workspace')
def PyInit(self): # State self.declareProperty( PropertyManagerProperty('SANSState'), doc='A property manager which fulfills the SANSState contract.') # Input workspaces workspace_validator = CompositeValidator() workspace_validator.add(WorkspaceUnitValidator("Wavelength")) self.declareProperty( MatrixWorkspaceProperty("TransmissionWorkspace", '', optional=PropertyMode.Optional, direction=Direction.Input, validator=workspace_validator), doc='The calculated transmission workspace in wavelength units.') self.declareProperty( MatrixWorkspaceProperty("NormalizeToMonitorWorkspace", '', optional=PropertyMode.Mandatory, direction=Direction.Input, validator=workspace_validator), doc='The monitor normalization workspace in wavelength units.') allowed_detector_types = StringListValidator([ DetectorType.to_string(DetectorType.HAB), DetectorType.to_string(DetectorType.LAB) ]) self.declareProperty( "Component", DetectorType.to_string(DetectorType.LAB), validator=allowed_detector_types, direction=Direction.Input, doc= "The component of the instrument which is currently being investigated." ) # Output workspace self.declareProperty(MatrixWorkspaceProperty( "OutputWorkspaceWavelengthAdjustment", '', direction=Direction.Output), doc='A wavelength adjustment output workspace.') self.declareProperty(MatrixWorkspaceProperty( "OutputWorkspacePixelAdjustment", '', direction=Direction.Output), doc='A pixel adjustment output workspace.')
def PyInit(self): # ---------- # INPUT # ---------- # State self.declareProperty(PropertyManagerProperty('SANSState'), doc='A property manager which fulfills the SANSState contract.') # Main workspace workspace_validator = CompositeValidator() workspace_validator.add(WorkspaceUnitValidator("Wavelength")) self.declareProperty(MatrixWorkspaceProperty("InputWorkspace", '', optional=PropertyMode.Mandatory, direction=Direction.Input, validator=workspace_validator), doc='The main input workspace.') # Adjustment workspaces self.declareProperty(MatrixWorkspaceProperty("InputWorkspaceWavelengthAdjustment", '', optional=PropertyMode.Optional, direction=Direction.Input, validator=workspace_validator), doc='The workspace which contains only wavelength-specific adjustments, ie which affects ' 'all spectra equally.') self.declareProperty(MatrixWorkspaceProperty("InputWorkspacePixelAdjustment", '', optional=PropertyMode.Optional, direction=Direction.Input), doc='The workspace which contains only pixel-specific adjustments, ie which affects ' 'all bins within a spectrum equally.') self.declareProperty(MatrixWorkspaceProperty("InputWorkspaceWavelengthAndPixelAdjustment", '', optional=PropertyMode.Optional, direction=Direction.Input, validator=workspace_validator), doc='The workspace which contains wavelength- and pixel-specific adjustments.') self.declareProperty('OutputParts', defaultValue=False, direction=Direction.Input, doc='Set to true to output two additional workspaces which will have the names ' 'OutputWorkspace_sumOfCounts OutputWorkspace_sumOfNormFactors. The division ' 'of _sumOfCounts and _sumOfNormFactors equals the workspace returned by the ' 'property OutputWorkspace (default is false).') # ---------- # Output # ---------- self.declareProperty(MatrixWorkspaceProperty("OutputWorkspace", '', optional=PropertyMode.Mandatory, direction=Direction.Output), doc="The reduced workspace")
def PyInit(self): """ Declare properties """ allowed_units = WorkspaceUnitValidator("MomentumTransfer") self.declareProperty( MatrixWorkspaceProperty("InputWorkspace", "", direction=Direction.Input, validator=allowed_units), doc="Input workspace with units of momentum transfer") functions = [SQ, FQ, FKQ, DCS] self.declareProperty("From", SQ, StringListValidator(functions), "Function type in the input workspace") self.declareProperty("To", SQ, StringListValidator(functions), "Function type in the output workspace") self.declareProperty(WorkspaceProperty('OutputWorkspace', '', direction=Direction.Output), doc='Output workspace')
def PyInit(self): """ Declare properties """ validator = CompositeValidator() validator.add(WorkspaceUnitValidator("TOF")) validator.add(InstrumentValidator()) self.declareProperty(MatrixWorkspaceProperty("InputWorkspace", "", direction=Direction.Input, validator=validator), doc="Input workspace.") self.declareProperty( ITableWorkspaceProperty("EPPTable", "", direction=Direction.Input), doc="Input EPP table. May be produced by FindEPP algorithm.") self.declareProperty( MatrixWorkspaceProperty("OutputWorkspace", "", direction=Direction.Output), doc="Name of the workspace that will contain the results") return
def PyInit(self): """Initialize the input and output properties of the algorithm.""" nonnegativeInt = IntBoundedValidator(lower=0) wsIndexRange = IntBoundedValidator(lower=0, upper=255) nonnegativeIntArray = IntArrayBoundedValidator(lower=0) maxTwoNonnegativeInts = CompositeValidator() maxTwoNonnegativeInts.add(IntArrayLengthValidator(lenmin=0, lenmax=2)) maxTwoNonnegativeInts.add(nonnegativeIntArray) self.declareProperty(MultipleFileProperty( Prop.RUN, action=FileAction.OptionalLoad, extensions=['nxs']), doc='A list of input run numbers/files.') self.declareProperty( MatrixWorkspaceProperty(Prop.INPUT_WS, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator('TOF'), optional=PropertyMode.Optional), doc='An input workspace (units TOF) if no Run is specified.') self.declareProperty( MatrixWorkspaceProperty(Prop.OUTPUT_WS, defaultValue='', direction=Direction.Output), doc= 'The preprocessed output workspace (unit wavelength), single histogram.' ) self.declareProperty( Prop.TWO_THETA, defaultValue=Property.EMPTY_DBL, doc='A user-defined scattering angle 2 theta (unit degrees).') self.declareProperty( name=Prop.LINE_POSITION, defaultValue=Property.EMPTY_DBL, doc= 'A workspace index corresponding to the beam centre between 0.0 and 255.0.' ) self.declareProperty(MatrixWorkspaceProperty( Prop.DIRECT_LINE_WORKSPACE, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='A pre-processed direct beam workspace.') self.declareProperty(Prop.SUBALG_LOGGING, defaultValue=SubalgLogging.OFF, validator=StringListValidator( [SubalgLogging.OFF, SubalgLogging.ON]), doc='Enable or disable child algorithm logging.') self.declareProperty( Prop.CLEANUP, defaultValue=utils.Cleanup.ON, validator=StringListValidator( [utils.Cleanup.ON, utils.Cleanup.OFF]), doc='Enable or disable intermediate workspace cleanup.') self.declareProperty(MatrixWorkspaceProperty( Prop.WATER_REFERENCE, defaultValue='', direction=Direction.Input, validator=WorkspaceUnitValidator("TOF"), optional=PropertyMode.Optional), doc='A (water) calibration workspace (unit TOF).') self.declareProperty(Prop.SLIT_NORM, defaultValue=SlitNorm.OFF, validator=StringListValidator( [SlitNorm.OFF, SlitNorm.ON]), doc='Enable or disable slit normalisation.') self.declareProperty(Prop.FLUX_NORM_METHOD, defaultValue=FluxNormMethod.TIME, validator=StringListValidator([ FluxNormMethod.TIME, FluxNormMethod.MONITOR, FluxNormMethod.OFF ]), doc='Neutron flux normalisation method.') self.declareProperty( IntArrayProperty(Prop.FOREGROUND_HALF_WIDTH, validator=maxTwoNonnegativeInts), doc= 'Number of foreground pixels at lower and higher angles from the centre pixel.' ) self.declareProperty( Prop.BKG_METHOD, defaultValue=BkgMethod.CONSTANT, validator=StringListValidator( [BkgMethod.CONSTANT, BkgMethod.LINEAR, BkgMethod.OFF]), doc='Flat background calculation method for background subtraction.' ) self.declareProperty( Prop.LOW_BKG_OFFSET, defaultValue=7, validator=nonnegativeInt, doc= 'Distance of flat background region towards smaller detector angles from the ' + 'foreground centre, in pixels.') self.declareProperty( Prop.LOW_BKG_WIDTH, defaultValue=5, validator=nonnegativeInt, doc= 'Width of flat background region towards smaller detector angles from the ' + 'foreground centre, in pixels.') self.declareProperty( Prop.HIGH_BKG_OFFSET, defaultValue=7, validator=nonnegativeInt, doc= 'Distance of flat background region towards larger detector angles from the ' + 'foreground centre, in pixels.') self.declareProperty( Prop.HIGH_BKG_WIDTH, defaultValue=5, validator=nonnegativeInt, doc= 'Width of flat background region towards larger detector angles from the ' + 'foreground centre, in pixels.') self.declareProperty( Prop.START_WS_INDEX, validator=wsIndexRange, defaultValue=0, doc='Start workspace index used for peak fitting.') self.declareProperty(Prop.END_WS_INDEX, validator=wsIndexRange, defaultValue=255, doc='Last workspace index used for peak fitting.') self.declareProperty( Prop.XMIN, defaultValue=Property.EMPTY_DBL, doc='Minimum x value (unit Angstrom) used for peak fitting.') self.declareProperty( Prop.XMAX, defaultValue=Property.EMPTY_DBL, doc='Maximum x value (unit Angstrom) used for peak fitting.')
def PyInit(self): """Initialize the algorithm's input and output properties.""" PROPGROUP_BEAM_STOP_DIAGNOSTICS = 'Beam Stop Diagnostics' PROPGROUP_BKG_DIAGNOSTICS = 'Background Diagnostics' PROPGROUP_PEAK_DIAGNOSTICS = 'Elastic Peak Diagnostics' PROPGROUP_USER_MASK = 'Additional Masking' greaterThanUnityFloat = FloatBoundedValidator(lower=1) inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) positiveFloat = FloatBoundedValidator(lower=0) positiveIntArray = IntArrayBoundedValidator() positiveIntArray.setLower(0) scalingFactor = FloatBoundedValidator(lower=0, upper=1) # Properties. self.declareProperty( MatrixWorkspaceProperty(name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input), doc= "A 'raw' workspace from DirectILLCollectData to calculate the diagnostics from." ) self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='A diagnostics mask workspace.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=common.CLEANUP_ON, validator=StringListValidator( [common.CLEANUP_ON, common.CLEANUP_OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty( ITableWorkspaceProperty(name=common.PROP_EPP_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='Table workspace containing results from the FindEPP algorithm.' ) self.declareProperty(name=common.PROP_ELASTIC_PEAK_DIAGNOSTICS, defaultValue=common.ELASTIC_PEAK_DIAGNOSTICS_AUTO, validator=StringListValidator([ common.ELASTIC_PEAK_DIAGNOSTICS_AUTO, common.ELASTIC_PEAK_DIAGNOSTICS_ON, common.ELASTIC_PEAK_DIAGNOSTICS_OFF ]), direction=Direction.Input, doc='Enable or disable elastic peak diagnostics.') self.setPropertyGroup(common.PROP_ELASTIC_PEAK_DIAGNOSTICS, PROPGROUP_PEAK_DIAGNOSTICS) self.declareProperty( name=common.PROP_ELASTIC_PEAK_SIGMA_MULTIPLIER, defaultValue=3.0, validator=positiveFloat, direction=Direction.Input, doc="Integration half width of the elastic peak in multiples " + " of 'Sigma' in the EPP table.") self.setPropertyGroup(common.PROP_ELASTIC_PEAK_SIGMA_MULTIPLIER, PROPGROUP_PEAK_DIAGNOSTICS) self.declareProperty(name=common.PROP_PEAK_DIAGNOSTICS_LOW_THRESHOLD, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc='Multiplier for lower acceptance limit ' + 'used in elastic peak diagnostics.') self.setPropertyGroup(common.PROP_PEAK_DIAGNOSTICS_LOW_THRESHOLD, PROPGROUP_PEAK_DIAGNOSTICS) self.declareProperty(name=common.PROP_PEAK_DIAGNOSTICS_HIGH_THRESHOLD, defaultValue=Property.EMPTY_DBL, validator=greaterThanUnityFloat, direction=Direction.Input, doc='Multiplier for higher acceptance limit ' + 'used in elastic peak diagnostics.') self.setPropertyGroup(common.PROP_PEAK_DIAGNOSTICS_HIGH_THRESHOLD, PROPGROUP_PEAK_DIAGNOSTICS) self.declareProperty( name=common.PROP_PEAK_DIAGNOSTICS_SIGNIFICANCE_TEST, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc= 'To fail the elastic peak diagnostics, the intensity must also exceed ' + 'this number of error bars with respect to the median intensity.') self.setPropertyGroup(common.PROP_PEAK_DIAGNOSTICS_SIGNIFICANCE_TEST, PROPGROUP_PEAK_DIAGNOSTICS) self.declareProperty(name=common.PROP_BKG_DIAGNOSTICS, defaultValue=common.BKG_DIAGNOSTICS_AUTO, validator=StringListValidator([ common.BKG_DIAGNOSTICS_AUTO, common.BKG_DIAGNOSTICS_ON, common.BKG_DIAGNOSTICS_OFF ]), direction=Direction.Input, doc='Control the background diagnostics.') self.setPropertyGroup(common.PROP_BKG_DIAGNOSTICS, PROPGROUP_BKG_DIAGNOSTICS) self.declareProperty( name=common.PROP_BKG_SIGMA_MULTIPLIER, defaultValue=10.0, validator=positiveFloat, direction=Direction.Input, doc= "Width of the range excluded from background integration around " + "the elastic peaks in multiplies of 'Sigma' in the EPP table") self.setPropertyGroup(common.PROP_BKG_SIGMA_MULTIPLIER, PROPGROUP_BKG_DIAGNOSTICS) self.declareProperty(name=common.PROP_BKG_DIAGNOSTICS_LOW_THRESHOLD, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc='Multiplier for lower acceptance limit ' + 'used in noisy background diagnostics.') self.setPropertyGroup(common.PROP_BKG_DIAGNOSTICS_LOW_THRESHOLD, PROPGROUP_BKG_DIAGNOSTICS) self.declareProperty(name=common.PROP_BKG_DIAGNOSTICS_HIGH_THRESHOLD, defaultValue=Property.EMPTY_DBL, validator=greaterThanUnityFloat, direction=Direction.Input, doc='Multiplier for higher acceptance limit ' + 'used in noisy background diagnostics.') self.setPropertyGroup(common.PROP_BKG_DIAGNOSTICS_HIGH_THRESHOLD, PROPGROUP_BKG_DIAGNOSTICS) self.declareProperty( name=common.PROP_BKG_DIAGNOSTICS_SIGNIFICANCE_TEST, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc= 'To fail the background diagnostics, the background level must also exceed ' + 'this number of error bars with respect to the median level.') self.setPropertyGroup(common.PROP_BKG_DIAGNOSTICS_SIGNIFICANCE_TEST, PROPGROUP_BKG_DIAGNOSTICS) self.declareProperty(name=common.PROP_BEAM_STOP_DIAGNOSTICS, defaultValue=common.BEAM_STOP_DIAGNOSTICS_AUTO, validator=StringListValidator([ common.BEAM_STOP_DIAGNOSTICS_AUTO, common.BEAM_STOP_DIAGNOSTICS_ON, common.BEAM_STOP_DIAGNOSTICS_OFF ]), direction=Direction.Input, doc='Control the beam stop diagnostics.') self.setPropertyGroup(common.PROP_BEAM_STOP_DIAGNOSTICS, PROPGROUP_BEAM_STOP_DIAGNOSTICS) self.declareProperty( name=common.PROP_BEAM_STOP_THRESHOLD, defaultValue=0.67, validator=scalingFactor, direction=Direction.Input, doc= 'Multiplier for the lower acceptance limit for beam stop diagnostics.' ) self.setPropertyGroup(common.PROP_BEAM_STOP_THRESHOLD, PROPGROUP_BEAM_STOP_DIAGNOSTICS) self.declareProperty( name=common.PROP_DEFAULT_MASK, defaultValue=common.DEFAULT_MASK_ON, validator=StringListValidator( [common.DEFAULT_MASK_ON, common.DEFAULT_MASK_OFF]), direction=Direction.Input, doc='Enable or disable instrument specific default mask.') self.declareProperty(IntArrayProperty(name=common.PROP_USER_MASK, values='', validator=positiveIntArray, direction=Direction.Input), doc='List of spectra to mask.') self.setPropertyGroup(common.PROP_USER_MASK, PROPGROUP_USER_MASK) self.declareProperty(StringArrayProperty( name=common.PROP_USER_MASK_COMPONENTS, values='', direction=Direction.Input), doc='List of instrument components to mask.') self.setPropertyGroup(common.PROP_USER_MASK_COMPONENTS, PROPGROUP_USER_MASK) # Rest of the output properties self.declareProperty( ITableWorkspaceProperty( name=common.PROP_OUTPUT_DIAGNOSTICS_REPORT_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output table workspace for detector diagnostics reporting.') self.setPropertyGroup(common.PROP_OUTPUT_DIAGNOSTICS_REPORT_WS, common.PROPGROUP_OPTIONAL_OUTPUT) self.declareProperty(name=common.PROP_OUTPUT_DIAGNOSTICS_REPORT, defaultValue='', direction=Direction.Output, doc='Diagnostics report as a string.') self.setPropertyGroup(common.PROP_OUTPUT_DIAGNOSTICS_REPORT, common.PROPGROUP_OPTIONAL_OUTPUT)
def PyInit(self): """Initialize the algorithm's input and output properties.""" PROPGROUP_SIMULATION_INSTRUMENT = 'Simulation Instrument Settings' greaterThanOneInt = IntBoundedValidator(lower=2) greaterThanTwoInt = IntBoundedValidator(lower=3) inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) # Properties. self.declareProperty( MatrixWorkspaceProperty(name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, optional=PropertyMode.Optional, direction=Direction.Input), doc='A workspace for which to simulate the self shielding.') self.declareProperty( MatrixWorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='A workspace containing the self shielding correction factors.' ) self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=common.CLEANUP_ON, validator=StringListValidator( [common.CLEANUP_ON, common.CLEANUP_OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty( name=common.PROP_SIMULATION_INSTRUMENT, defaultValue=common.SIMULATION_INSTRUMEN_SPARSE, validator=StringListValidator([ common.SIMULATION_INSTRUMEN_SPARSE, common.SIMULATION_INSTRUMENT_FULL ]), direction=Direction.Input, doc= 'Select if the simulation should be performed on full or approximated instrument.' ) self.setPropertyGroup(common.PROP_SIMULATION_INSTRUMENT, PROPGROUP_SIMULATION_INSTRUMENT) self.declareProperty( name=common.PROP_SPARSE_INSTRUMENT_ROWS, defaultValue=5, validator=greaterThanTwoInt, direction=Direction.Input, doc='Number of detector rows in sparse simulation instrument.') self.setPropertyGroup(common.PROP_SPARSE_INSTRUMENT_ROWS, PROPGROUP_SIMULATION_INSTRUMENT) self.setPropertySettings( common.PROP_SPARSE_INSTRUMENT_ROWS, EnabledWhenProperty(common.PROP_SIMULATION_INSTRUMENT, PropertyCriterion.IsEqualTo, common.SIMULATION_INSTRUMEN_SPARSE)) self.declareProperty( name=common.PROP_SPARSE_INSTRUMENT_COLUMNS, defaultValue=20, validator=greaterThanOneInt, direction=Direction.Input, doc='Number of detector columns in sparse simulation instrument.') self.setPropertyGroup(common.PROP_SPARSE_INSTRUMENT_COLUMNS, PROPGROUP_SIMULATION_INSTRUMENT) self.setPropertySettings( common.PROP_SPARSE_INSTRUMENT_COLUMNS, EnabledWhenProperty(common.PROP_SIMULATION_INSTRUMENT, PropertyCriterion.IsEqualTo, common.SIMULATION_INSTRUMEN_SPARSE)) self.declareProperty( name=common.PROP_NUMBER_OF_SIMULATION_WAVELENGTHS, defaultValue=Property.EMPTY_INT, validator=greaterThanTwoInt, direction=Direction.Input, doc= 'Number of wavelength points where the simulation is performed (default: all).' )
def PyInit(self): """Initialize the algorithm's input and output properties.""" PROPGROUP_FLAT_BKG = 'Flat Time-Independent Background' PROPGROUP_INCIDENT_ENERGY_CALIBRATION = 'Indicent Energy Calibration' PROPGROUP_MON_NORMALISATION = 'Neutron Flux Normalisation' # Validators. mandatoryPositiveInt = CompositeValidator() mandatoryPositiveInt.add(IntMandatoryValidator()) mandatoryPositiveInt.add(IntBoundedValidator(lower=0)) positiveFloat = FloatBoundedValidator(lower=0) positiveInt = IntBoundedValidator(lower=0) inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) # Properties. self.declareProperty(MultipleFileProperty(name=common.PROP_INPUT_FILE, action=FileAction.OptionalLoad, extensions=['nxs']), doc='An input run number (or a list thereof) or a filename.') self.getProperty(common.PROP_INPUT_FILE).setAutoTrim(False) self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, optional=PropertyMode.Optional, direction=Direction.Input), doc='Input workspace if no run is given.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='A flux normalized and background subtracted workspace.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=utils.Cleanup.ON, validator=StringListValidator([ utils.Cleanup.ON, utils.Cleanup.OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty(name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator([ common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty(name=common.PROP_EPP_METHOD, defaultValue=common.EPP_METHOD_AUTO, validator=StringListValidator([ common.EPP_METHOD_AUTO, common.EPP_METHOD_FIT, common.EPP_METHOD_CALCULATE]), direction=Direction.Input, doc='Method to create the EPP table for detectors (monitor is awlays fitted).') self.declareProperty(name=common.PROP_EPP_SIGMA, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, direction=Direction.Input, doc='Nominal sigma for the EPP table when ' + common.PROP_EPP_METHOD + ' is set to ' + common.EPP_METHOD_CALCULATE + ' (default: 10 times the first bin width).') self.declareProperty(name=common.PROP_ELASTIC_CHANNEL_MODE, defaultValue=common.ELASTIC_CHANNEL_AUTO, validator=StringListValidator([ common.ELASTIC_CHANNEL_AUTO, common.ELASTIC_CHANNEL_SAMPLE_LOG, common.ELASTIC_CHANNEL_FIT]), direction=Direction.Input, doc='How to acquire the nominal elastic channel.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_ELASTIC_CHANNEL_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='A single value workspace containing the nominal elastic channel index' '(can be floating point). Overrides {}.'.format(common.PROP_ELASTIC_CHANNEL_MODE)) self.declareProperty(name=common.PROP_MON_INDEX, defaultValue=Property.EMPTY_INT, validator=positiveInt, direction=Direction.Input, doc='Index of the incident monitor, if not specified in instrument parameters.') self.declareProperty(name=common.PROP_INCIDENT_ENERGY_CALIBRATION, defaultValue=common.INCIDENT_ENERGY_CALIBRATION_AUTO, validator=StringListValidator([ common.INCIDENT_ENERGY_CALIBRATION_AUTO, common.INCIDENT_ENERGY_CALIBRATION_ON, common.INCIDENT_ENERGY_CALIBRATION_OFF]), direction=Direction.Input, doc='Control the incident energy calibration.') self.setPropertyGroup(common.PROP_INCIDENT_ENERGY_CALIBRATION, PROPGROUP_INCIDENT_ENERGY_CALIBRATION) self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INCIDENT_ENERGY_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='A single-valued workspace holding a previously determined ' + 'incident energy.') self.setPropertyGroup(common.PROP_INCIDENT_ENERGY_WS, PROPGROUP_INCIDENT_ENERGY_CALIBRATION) self.declareProperty(name=common.PROP_FLAT_BKG, defaultValue=common.BKG_AUTO, validator=StringListValidator([ common.BKG_AUTO, common.BKG_ON, common.BKG_OFF]), direction=Direction.Input, doc='Control flat background subtraction.') self.setPropertyGroup(common.PROP_FLAT_BKG, PROPGROUP_FLAT_BKG) self.declareProperty(name=common.PROP_FLAT_BKG_SCALING, defaultValue=1.0, validator=positiveFloat, direction=Direction.Input, doc='Flat background multiplication factor.') self.setPropertyGroup(common.PROP_FLAT_BKG_SCALING, PROPGROUP_FLAT_BKG) self.declareProperty(name=common.PROP_FLAT_BKG_WINDOW, defaultValue=30, validator=mandatoryPositiveInt, direction=Direction.Input, doc='Running average window width (in bins) for flat background.') self.setPropertyGroup(common.PROP_FLAT_BKG_WINDOW, PROPGROUP_FLAT_BKG) self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_FLAT_BKG_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='Workspace with previously determined flat background data.') self.setPropertyGroup(common.PROP_FLAT_BKG_WS, PROPGROUP_FLAT_BKG) self.declareProperty(name=common.PROP_DET_HOR_GROUPING, defaultValue=1, doc='Step to use when grouping detectors horizontally (between tubes) to increase' ' the statistics for flat background calculation.') self.setPropertyGroup(common.PROP_DET_HOR_GROUPING, PROPGROUP_FLAT_BKG) self.declareProperty(name=common.PROP_DET_VER_GROUPING, defaultValue=1, doc='Step to use when grouping detectors vertically (inside the same tube)' ' to increase the statistics for flat background calculation.') self.setPropertyGroup(common.PROP_DET_VER_GROUPING, PROPGROUP_FLAT_BKG) self.declareProperty(name=common.PROP_NORMALISATION, defaultValue=common.NORM_METHOD_MON, validator=StringListValidator([ common.NORM_METHOD_MON, common.NORM_METHOD_TIME, common.NORM_METHOD_OFF]), direction=Direction.Input, doc='Normalisation method.') self.setPropertyGroup(common.PROP_NORMALISATION, PROPGROUP_MON_NORMALISATION) self.declareProperty(name=common.PROP_MON_PEAK_SIGMA_MULTIPLIER, defaultValue=7.0, validator=positiveFloat, direction=Direction.Input, doc="Width of the monitor peak in multiples " + " of 'Sigma' in monitor's EPP table.") self.setPropertyGroup(common.PROP_MON_PEAK_SIGMA_MULTIPLIER, PROPGROUP_MON_NORMALISATION) # Rest of the output properties. self.declareProperty(WorkspaceProperty( name=common.PROP_OUTPUT_RAW_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Non-normalized and non-background subtracted output workspace for DirectILLDiagnostics.') self.setPropertyGroup(common.PROP_OUTPUT_RAW_WS, common.PROPGROUP_OPTIONAL_OUTPUT) self.declareProperty(WorkspaceProperty( name=common.PROP_OUTPUT_ELASTIC_CHANNEL_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for elastic channel index.') self.setPropertyGroup(common.PROP_OUTPUT_ELASTIC_CHANNEL_WS, common.PROPGROUP_OPTIONAL_OUTPUT) self.declareProperty(ITableWorkspaceProperty( name=common.PROP_OUTPUT_DET_EPP_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for elastic peak positions.') self.setPropertyGroup(common.PROP_OUTPUT_DET_EPP_WS, common.PROPGROUP_OPTIONAL_OUTPUT) self.declareProperty(WorkspaceProperty( name=common.PROP_OUTPUT_INCIDENT_ENERGY_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for calibrated incident energy.') self.setPropertyGroup(common.PROP_OUTPUT_INCIDENT_ENERGY_WS, common.PROPGROUP_OPTIONAL_OUTPUT) self.declareProperty(WorkspaceProperty( name=common.PROP_OUTPUT_FLAT_BKG_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for flat background.') self.setPropertyGroup(common.PROP_OUTPUT_FLAT_BKG_WS, common.PROPGROUP_OPTIONAL_OUTPUT)
def PyInit(self): self.declareProperty( WorkspaceProperty('InputWorkspace', '', direction=Direction.Input, validator=WorkspaceUnitValidator('TOF')), doc= 'Powder event data, ideally from a highly symmetric space group', ) self.declareProperty(name='OutputWorkspacesPrefix', defaultValue='pdcal_', direction=Direction.Input, doc="Prefix to be added to output workspaces") # PDCalibration properties exposed, grouped property_names = ['TofBinning', 'PeakFunction', 'PeakPositions'] self.copyProperties('PDCalibration', property_names) [ self.setPropertyGroup(name, 'PDCalibration') for name in property_names ] # "Source Position" properties self.declareProperty(name='FixSource', defaultValue=True, doc="Fix source's distance from the sample") self.declareProperty( name='SourceToSampleDistance', defaultValue=20.004, doc= 'Set this value for a fixed distance from source to sample, in meters' ) self.setPropertySettings( 'SourceToSampleDistance', EnabledWhenProperty("FixSource", PropertyCriterion.IsDefault)) self.declareProperty(name='AdjustSource', defaultValue=False, doc='Adjust Z-coordinate of the source') self.declareProperty( name='SourceMaxTranslation', defaultValue=0.1, doc= 'Maximum adjustment of source position along the beam (Z) axis (m)' ) self.setPropertySettings( "SourceMaxTranslation", EnabledWhenProperty("AdjustSource", PropertyCriterion.IsNotDefault)) property_names = [ 'FixSource', 'SourceToSampleDistance', 'AdjustSource', 'SourceMaxTranslation' ] [ self.setPropertyGroup(name, 'Source Calibration') for name in property_names ] # AlignComponents properties self.declareProperty(name='FixY', defaultValue=True, doc="Vertical bank position is left unchanged") self.declareProperty(StringArrayProperty('ComponentList', values=self._banks, direction=Direction.Input), doc='Comma separated list on banks to refine') self.declareProperty( name='ComponentMaxTranslation', defaultValue=0.02, doc= 'Maximum translation of each component along either of the X, Y, Z axes (m)' ) self.declareProperty( name='FixYaw', defaultValue=True, doc="Prevent rotations around the axis normal to the bank") self.declareProperty( name='ComponentMaxRotation', defaultValue=3.0, doc= 'Maximum rotation of each component along either of the X, Y, Z axes (deg)' ) property_names = [ 'FixY', 'ComponentList', 'ComponentMaxTranslation', 'FixYaw', 'ComponentMaxRotation' ] [ self.setPropertyGroup(name, 'Banks Calibration') for name in property_names ] # # Minimization Properties self.declareProperty( name='Minimizer', defaultValue='L-BFGS-B', direction=Direction.Input, validator=StringListValidator( ['L-BFGS-B', 'differential_evolution']), doc= 'Minimizer to use, differential_evolution is more accurate and slower.' ) self.declareProperty( name='MaxIterations', defaultValue=20, direction=Direction.Input, doc= 'Maximum number of iterations for minimizer differential_evolution' ) properties = ['Minimizer', 'MaxIterations'] [self.setPropertyGroup(name, "Minimization") for name in properties]
def PyInit(self): self.declareProperty(MatrixWorkspaceProperty( 'InputWorkspace', '', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='The input workspace.') self.declareProperty(MatrixWorkspaceProperty( 'OutputWorkspace', '', direction=Direction.Output), doc='The output workspace.') self.declareProperty(name='OutputType', defaultValue='I(Q)', validator=StringListValidator( ['I(Q)', 'I(Qx,Qy)', 'I(Phi,Q)']), doc='Choose the output type.') self.declareProperty(name='CalculateResolution', defaultValue='None', validator=StringListValidator( ['MildnerCarpenter', 'None']), doc='Choose to calculate the Q resolution.') output_iq = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Q)') output_iphiq = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Phi,Q)') output_iqxy = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Qx,Qy)') self.declareProperty( name='DefaultQBinning', defaultValue='PixelSizeBased', validator=StringListValidator( ['PixelSizeBased', 'ResolutionBased']), doc='Choose how to calculate the default Q binning.') self.setPropertySettings( 'DefaultQBinning', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty( name='BinningFactor', defaultValue=1., validator=FloatBoundedValidator(lower=0.), doc= 'Specify a multiplicative factor for default Q binning (pixel or resolution based).' ) self.setPropertySettings( 'BinningFactor', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty(FloatArrayProperty('OutputBinning'), doc='The manual Q binning of the output') self.setPropertySettings( 'OutputBinning', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty('NPixelDivision', 1, IntBoundedValidator(lower=1), 'Number of subpixels to split the pixel (NxN)') self.setPropertySettings( 'NPixelDivision', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) iq_without_shapes = EnabledWhenProperty( EnabledWhenProperty("ShapeTable", PropertyCriterion.IsDefault), EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or), LogicOperator.And) self.declareProperty(name='NumberOfWedges', defaultValue=0, validator=IntBoundedValidator(lower=0), doc='Number of wedges to integrate separately.') self.setPropertySettings('NumberOfWedges', iq_without_shapes) iq_with_wedges = EnabledWhenProperty( output_iq, EnabledWhenProperty('NumberOfWedges', PropertyCriterion.IsNotDefault), LogicOperator.And) iq_with_wedges_or_shapes = EnabledWhenProperty( iq_with_wedges, EnabledWhenProperty("ShapeTable", PropertyCriterion.IsNotDefault), LogicOperator.Or) iq_with_wedges_but_no_shapes = EnabledWhenProperty( iq_with_wedges, EnabledWhenProperty("ShapeTable", PropertyCriterion.IsDefault), LogicOperator.And) self.declareProperty( WorkspaceGroupProperty('WedgeWorkspace', '', direction=Direction.Output, optional=PropertyMode.Optional), doc='WorkspaceGroup containing I(Q) for each azimuthal wedge.') self.setPropertySettings('WedgeWorkspace', iq_with_wedges_or_shapes) self.declareProperty(name='WedgeAngle', defaultValue=30., validator=FloatBoundedValidator(lower=0.), doc='Wedge opening angle [degrees].') self.setPropertySettings('WedgeAngle', iq_with_wedges_but_no_shapes) self.declareProperty(name='WedgeOffset', defaultValue=0., validator=FloatBoundedValidator(lower=0.), doc='Wedge offset angle from x+ axis.') self.setPropertySettings('WedgeOffset', iq_with_wedges_but_no_shapes) self.declareProperty(name='AsymmetricWedges', defaultValue=False, doc='Whether to have asymmetric wedges.') self.setPropertySettings('AsymmetricWedges', iq_with_wedges_or_shapes) self.setPropertyGroup('DefaultQBinning', 'I(Q) Options') self.setPropertyGroup('BinningFactor', 'I(Q) Options') self.setPropertyGroup('OutputBinning', 'I(Q) Options') self.setPropertyGroup('NPixelDivision', 'I(Q) Options') self.setPropertyGroup('NumberOfWedges', 'I(Q) Options') self.setPropertyGroup('WedgeWorkspace', 'I(Q) Options') self.setPropertyGroup('WedgeAngle', 'I(Q) Options') self.setPropertyGroup('WedgeOffset', 'I(Q) Options') self.setPropertyGroup('AsymmetricWedges', 'I(Q) Options') self.declareProperty(name='MaxQxy', defaultValue=-1.0, validator=FloatBoundedValidator(lower=-1.0), doc='Maximum of absolute Qx and Qy.') self.setPropertySettings('MaxQxy', output_iqxy) self.declareProperty(name='DeltaQ', defaultValue=-1.0, validator=FloatBoundedValidator(lower=-1.0), doc='The dimension of a Qx-Qy cell.') self.setPropertySettings('DeltaQ', output_iqxy) self.declareProperty( name='IQxQyLogBinning', defaultValue=False, doc='I(Qx, Qy) log binning when binning is not specified.') self.setPropertySettings('IQxQyLogBinning', output_iqxy) self.setPropertyGroup('MaxQxy', 'I(Qx,Qy) Options') self.setPropertyGroup('DeltaQ', 'I(Qx,Qy) Options') self.setPropertyGroup('IQxQyLogBinning', 'I(Qx,Qy) Options') self.declareProperty( WorkspaceGroupProperty('PanelOutputWorkspaces', '', direction=Direction.Output, optional=PropertyMode.Optional), doc='The name of the output workspace group for detector panels.') self.declareProperty( ITableWorkspaceProperty('ShapeTable', '', direction=Direction.Input, optional=PropertyMode.Optional), doc= 'The name of the table workspace containing drawn shapes on which to integrate. ' 'If provided, NumberOfWedges, WedgeOffset and WedgeAngle arguments are ignored. ' ) self.setPropertyGroup('PanelOutputWorkspaces', 'I(Q) Options') self.setPropertyGroup('ShapeTable', 'I(Q) Options') lambda_range_validator = CompositeValidator() lambda_range_validator.add(FloatArrayOrderedPairsValidator()) lambda_range_validator.add(FloatArrayLengthValidator(2)) self.declareProperty( FloatArrayProperty('WavelengthRange', [1., 10.], validator=lambda_range_validator), doc= 'Wavelength range [Angstrom] to be used in integration (TOF only).' )
def PyInit(self): """Initialize the algorithm's input and output properties.""" PROPGROUP_REBINNING = 'Rebinning for SofQW' inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) positiveFloat = FloatBoundedValidator(0., exclusive=True) validRebinParams = RebinParamsValidator(AllowEmpty=True) # Properties. self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input), doc='A workspace to reduce.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The reduced S(Q, DeltaE) workspace.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=utils.Cleanup.ON, validator=StringListValidator( [utils.Cleanup.ON, utils.Cleanup.OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty( name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator( [common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_VANA_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input, optional=PropertyMode.Optional), doc='An integrated vanadium workspace.') self.declareProperty( name=common.PROP_ABSOLUTE_UNITS, defaultValue=common.ABSOLUTE_UNITS_OFF, validator=StringListValidator( [common.ABSOLUTE_UNITS_OFF, common.ABSOLUTE_UNITS_ON]), direction=Direction.Input, doc='Enable or disable normalisation to absolute units.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_DIAGNOSTICS_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='Detector diagnostics workspace for masking.') self.declareProperty( name=common.PROP_GROUPING_ANGLE_STEP, defaultValue=Property.EMPTY_DBL, validator=positiveFloat, doc= 'A scattering angle step to which to group detectors, in degrees.') self.declareProperty(FloatArrayProperty( name=common.PROP_REBINNING_PARAMS_W, validator=validRebinParams), doc='Manual energy rebinning parameters.') self.setPropertyGroup(common.PROP_REBINNING_PARAMS_W, PROPGROUP_REBINNING) self.declareProperty( name=common.PROP_REBINNING_W, defaultValue='', doc= 'Energy rebinning when mixing manual and automatic binning parameters.' ) self.declareProperty(FloatArrayProperty( name=common.PROP_BINNING_PARAMS_Q, validator=validRebinParams), doc='Manual q rebinning parameters.') self.setPropertyGroup(common.PROP_BINNING_PARAMS_Q, PROPGROUP_REBINNING) self.declareProperty( name=common.PROP_TRANSPOSE_SAMPLE_OUTPUT, defaultValue=common.TRANSPOSING_ON, validator=StringListValidator( [common.TRANSPOSING_ON, common.TRANSPOSING_OFF]), direction=Direction.Input, doc='Enable or disable ' + common.PROP_OUTPUT_WS + ' transposing.') self.declareProperty( WorkspaceProperty(name=common.PROP_OUTPUT_THETA_W_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for reduced S(theta, DeltaE).') self.setPropertyGroup(common.PROP_OUTPUT_THETA_W_WS, common.PROPGROUP_OPTIONAL_OUTPUT)
def PyInit(self): # input self.declareProperty(MatrixWorkspaceProperty( 'InputWorkspace', '', direction=Direction.Input, optional=PropertyMode.Mandatory), doc='Particle counts as a function of wavelength') self.declareProperty(MatrixWorkspaceProperty( 'InputMaskingWorkspace', '', direction=Direction.Input, optional=PropertyMode.Optional), doc='Mask for the scattering data') # blocked beam, beam shape and detector corrections self.declareProperty(MatrixWorkspaceProperty( 'BlockedBeamWorkspace', '', direction=Direction.Input, optional=PropertyMode.Optional), doc='Blocked beam scattering') self.declareProperty( MatrixWorkspaceProperty( 'EmptyBeamSpectrumShapeWorkspace', '', direction=Direction.Input, optional=PropertyMode.Mandatory, validator=WorkspaceUnitValidator("Wavelength")), doc= 'Empty beam transmission, where only a given wavelength slice is considered' ) self.declareProperty(MatrixWorkspaceProperty( 'SensitivityCorrectionMatrix', '', direction=Direction.Input, optional=PropertyMode.Optional), doc='Detector sensitivity calibration data set') self.declareProperty(MatrixWorkspaceProperty( 'TransmissionWorkspace', '', direction=Direction.Input, optional=PropertyMode.Mandatory), doc='Sample transmission workspace') self.declareProperty(MatrixWorkspaceProperty( 'TransmissionEmptyBeamWorkspace', '', direction=Direction.Input, optional=PropertyMode.Mandatory), doc='Empty beam transmission workspace') self.declareProperty(MatrixWorkspaceProperty( 'TransmissionMaskingWorkspace', '', direction=Direction.Input, optional=PropertyMode.Mandatory), doc='Mask for the transmission data') self.declareProperty( name='FitMethod', defaultValue='log', doc='Function to use to fit transmission; can be Linear,' ' Log, Polynomial (first letter shall be capital)') self.declareProperty( name='PolynomialOrder', defaultValue='3', doc= 'Used only for Polynomial function, but needed as an input parameter anyway' ) self.declareProperty(name='ScalingFactor', defaultValue=1.0, validator=FloatBoundedValidator(lower=0.0), doc='Attenuating factor') self.declareProperty(name='SampleThickness', defaultValue=1.0, validator=FloatBoundedValidator(lower=0.0), doc='Thickness of sample') self.declareProperty( FloatArrayProperty('BinningWavelength', direction=Direction.Input, validator=FloatArrayMandatoryValidator()), doc= 'Wavelength boundaries for reduction: a comma separated list of first bin boundary,' ' width, last bin boundary') self.declareProperty( FloatArrayProperty('BinningWavelengthTransm', direction=Direction.Input, validator=FloatArrayMandatoryValidator()), doc= 'Wavelengths boundaries for transmission binning: a comma separated list of first bin' ' boundary, width, last bin') self.declareProperty( FloatArrayProperty('BinningQ', direction=Direction.Input, validator=FloatArrayMandatoryValidator()), doc= 'Output Q-boundaries: a comma separated list of first bin boundary,' ' width, last bin boundary') self.declareProperty( name='Timemode', defaultValue=True, doc='If data collected in ToF or monochromatic mode') self.declareProperty( name='AccountForGravity', defaultValue=True, doc='Whether to correct for the effects of gravity') self.declareProperty( name='SolidAngleWeighting', defaultValue=True, doc='If True, pixels will be weighted by their solid angle') self.declareProperty( name='RadiusCut', defaultValue=1.0, validator=FloatBoundedValidator(lower=0.0), doc= 'To increase resolution some wavelengths are excluded within this distance from the' ' beam center (mm). Note that RadiusCut and WaveCut both need to be larger than 0 to' ' affect the effective cutoff. See the algorithm description for a detailed' ' explanation of the cutoff.') self.declareProperty( name='WaveCut', defaultValue=1.0, validator=FloatBoundedValidator(lower=0.0), doc= 'To increase resolution by starting to remove some wavelengths below this threshold' ' (angstrom). Note that WaveCut and RadiusCut both need to be larger than 0 to affect' ' on the effective cutoff. See the algorithm description for a detailed explanation' ' of the cutoff.') self.declareProperty( name='WideAngleCorrection', defaultValue=True, doc= 'If true, the wide angle correction for transmissions will be applied' ) self.declareProperty( name='Reduce2D', defaultValue=False, doc='If true, 2D data reduction will be performed') self.declareProperty( MatrixWorkspaceProperty('OutputWorkspace', '', direction=Direction.Output), doc= 'Name of the workspace that contains the result of the calculation. ' 'Created automatically.') self.declareProperty( MatrixWorkspaceProperty('OutputWorkspaceTransmissionFit', '', direction=Direction.Output), # This works only when transmission is True. Problems starts when it is not... doc='Counts vs wavelength, fit for the sample transmission')
def PyInit(self): """Initialize the input and output properties of the algorithm.""" threeNonnegativeInts = CompositeValidator() threeNonnegativeInts.add(IntArrayLengthValidator(3)) nonnegativeInts = IntArrayBoundedValidator(lower=0) threeNonnegativeInts.add(nonnegativeInts) nonnegativeFloatArray = FloatArrayBoundedValidator(lower=0.) inWavelength = WorkspaceUnitValidator('Wavelength') self.declareProperty( MatrixWorkspaceProperty( Prop.INPUT_WS, defaultValue='', direction=Direction.Input, validator=inWavelength), doc='A reflected beam workspace (units wavelength).') self.declareProperty( MatrixWorkspaceProperty( Prop.OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The summed foreground workspace.') self.declareProperty( Prop.SUBALG_LOGGING, defaultValue=SubalgLogging.OFF, validator=StringListValidator([SubalgLogging.OFF, SubalgLogging.ON]), doc='Enable or disable child algorithm logging.') self.declareProperty( Prop.CLEANUP, defaultValue=utils.Cleanup.ON, validator=StringListValidator([utils.Cleanup.ON, utils.Cleanup.OFF]), doc='Enable or disable intermediate workspace cleanup.') self.declareProperty( Prop.SUM_TYPE, defaultValue=SumType.IN_LAMBDA, validator=StringListValidator([SumType.IN_LAMBDA, SumType.IN_Q]), doc='Type of summation to perform.') self.declareProperty( MatrixWorkspaceProperty( Prop.DIRECT_FOREGROUND_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional, validator=inWavelength), doc='Summed direct beam workspace (units wavelength).') self.declareProperty( IntArrayProperty( Prop.FOREGROUND_INDICES, values=[Property.EMPTY_INT, Property.EMPTY_INT, Property.EMPTY_INT], validator=threeNonnegativeInts), doc='A three element array of foreground start, centre and end workspace indices.') self.declareProperty( MatrixWorkspaceProperty( Prop.DIRECT_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional, validator=inWavelength), doc='The (not summed) direct beam workspace (units wavelength).') self.declareProperty( FloatArrayProperty( Prop.WAVELENGTH_RANGE, values=[0.], validator=nonnegativeFloatArray), doc='The wavelength bounds.')
def PyInit(self): self.declareProperty(MatrixWorkspaceProperty('InputWorkspace', '', direction=Direction.Input, validator=WorkspaceUnitValidator('Wavelength')), doc='The input workspace.') self.declareProperty(MatrixWorkspaceProperty('OutputWorkspace', '', direction=Direction.Output), doc='The output workspace.') self.declareProperty(name='OutputType', defaultValue='I(Q)', validator=StringListValidator(['I(Q)', 'I(Qx,Qy)', 'I(Phi,Q)']), doc='Choose the output type.') self.declareProperty(name='CalculateResolution', defaultValue='MildnerCarpenter', validator=StringListValidator(['MildnerCarpenter', 'None']), doc='Choose to calculate the Q resolution.') output_iq = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Q)') output_iphiq = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Phi,Q)') output_iqxy = EnabledWhenProperty('OutputType', PropertyCriterion.IsEqualTo, 'I(Qx,Qy)') self.declareProperty(name='DefaultQBinning', defaultValue='PixelSizeBased', validator=StringListValidator(['PixelSizeBased', 'ResolutionBased']), doc='Choose how to calculate the default Q binning.') self.setPropertySettings('DefaultQBinning', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty(name='BinningFactor', defaultValue=1., validator=FloatBoundedValidator(lower=0.), doc='Specify a multiplicative factor for default Q binning (pixel or resolution based).') self.setPropertySettings('BinningFactor', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty(FloatArrayProperty('OutputBinning'), doc='The manual Q binning of the output') self.setPropertySettings('OutputBinning', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty('NPixelDivision', 1, IntBoundedValidator(lower=1), 'Number of subpixels to split the pixel (NxN)') self.setPropertySettings('NPixelDivision', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) self.declareProperty(name='NumberOfWedges', defaultValue=0, validator=IntBoundedValidator(lower=0), doc='Number of wedges to integrate separately.') self.setPropertySettings('NumberOfWedges', EnabledWhenProperty(output_iq, output_iphiq, LogicOperator.Or)) iq_with_wedges = EnabledWhenProperty(output_iq, EnabledWhenProperty('NumberOfWedges', PropertyCriterion.IsNotDefault), LogicOperator.And) self.declareProperty(WorkspaceGroupProperty('WedgeWorkspace', '', direction=Direction.Output, optional=PropertyMode.Optional), doc='WorkspaceGroup containing I(Q) for each azimuthal wedge.') self.setPropertySettings('WedgeWorkspace', iq_with_wedges) self.declareProperty(name='WedgeAngle', defaultValue=30., validator=FloatBoundedValidator(lower=0.), doc='Wedge opening angle [degrees].') self.setPropertySettings('WedgeAngle', iq_with_wedges) self.declareProperty(name='WedgeOffset', defaultValue=0., validator=FloatBoundedValidator(lower=0.), doc='Wedge offset angle from x+ axis.') self.setPropertySettings('WedgeOffset', iq_with_wedges) self.declareProperty(name='AsymmetricWedges', defaultValue=False, doc='Whether to have asymmetric wedges.') self.setPropertySettings('AsymmetricWedges', iq_with_wedges) self.setPropertyGroup('DefaultQBinning', 'I(Q) Options') self.setPropertyGroup('BinningFactor', 'I(Q) Options') self.setPropertyGroup('OutputBinning', 'I(Q) Options') self.setPropertyGroup('NPixelDivision', 'I(Q) Options') self.setPropertyGroup('NumberOfWedges', 'I(Q) Options') self.setPropertyGroup('WedgeWorkspace', 'I(Q) Options') self.setPropertyGroup('WedgeAngle', 'I(Q) Options') self.setPropertyGroup('WedgeOffset', 'I(Q) Options') self.setPropertyGroup('AsymmetricWedges', 'I(Q) Options') self.declareProperty(name='MaxQxy', defaultValue=0., validator=FloatBoundedValidator(lower=0.), doc='Maximum of absolute Qx and Qy.') self.setPropertySettings('MaxQxy', output_iqxy) self.declareProperty(name='DeltaQ', defaultValue=0., validator=FloatBoundedValidator(lower=0), doc='The dimension of a Qx-Qy cell.') self.setPropertySettings('DeltaQ', output_iqxy) self.declareProperty(name='IQxQyLogBinning', defaultValue=False, doc='I(Qx, Qy) log binning when binning is not specified.') self.setPropertySettings('IQxQyLogBinning', output_iqxy) self.setPropertyGroup('MaxQxy', 'I(Qx,Qy) Options') self.setPropertyGroup('DeltaQ', 'I(Qx,Qy) Options') self.setPropertyGroup('IQxQyLogBinning', 'I(Qx,Qy) Options') self.declareProperty(name='BinMaskingCriteria', defaultValue='', doc='Criteria to mask bins, used for TOF mode,' ' for example to discard high and low lambda ranges;' 'see MaskBinsIf algorithm for details.')
def PyInit(self): """Initialize the algorithm's input and output properties.""" PROPGROUP_REBINNING = 'Rebinning for SofQW' inputWorkspaceValidator = CompositeValidator() inputWorkspaceValidator.add(InstrumentValidator()) inputWorkspaceValidator.add(WorkspaceUnitValidator('TOF')) # Properties. self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_INPUT_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input), doc='A workspace to reduce.') self.declareProperty(WorkspaceProperty(name=common.PROP_OUTPUT_WS, defaultValue='', direction=Direction.Output), doc='The reduced S(Q, DeltaE) workspace.') self.declareProperty(name=common.PROP_CLEANUP_MODE, defaultValue=common.CLEANUP_ON, validator=StringListValidator([ common.CLEANUP_ON, common.CLEANUP_OFF]), direction=Direction.Input, doc='What to do with intermediate workspaces.') self.declareProperty(name=common.PROP_SUBALG_LOGGING, defaultValue=common.SUBALG_LOGGING_OFF, validator=StringListValidator([ common.SUBALG_LOGGING_OFF, common.SUBALG_LOGGING_ON]), direction=Direction.Input, doc='Enable or disable subalgorithms to ' + 'print in the logs.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_VANA_WS, defaultValue='', validator=inputWorkspaceValidator, direction=Direction.Input, optional=PropertyMode.Optional), doc='An integrated vanadium workspace.') self.declareProperty(name=common.PROP_ABSOLUTE_UNITS, defaultValue=common.ABSOLUTE_UNITS_OFF, validator=StringListValidator([ common.ABSOLUTE_UNITS_OFF, common.ABSOLUTE_UNITS_ON]), direction=Direction.Input, doc='Enable or disable normalisation to absolute units.') self.declareProperty(MatrixWorkspaceProperty( name=common.PROP_DIAGNOSTICS_WS, defaultValue='', direction=Direction.Input, optional=PropertyMode.Optional), doc='Detector diagnostics workspace for masking.') self.declareProperty(FloatArrayProperty(name=common.PROP_REBINNING_PARAMS_W), doc='Manual energy rebinning parameters.') self.setPropertyGroup(common.PROP_REBINNING_PARAMS_W, PROPGROUP_REBINNING) self.declareProperty(FloatArrayProperty(name=common.PROP_BINNING_PARAMS_Q), doc='Manual q rebinning parameters.') self.setPropertyGroup(common.PROP_BINNING_PARAMS_Q, PROPGROUP_REBINNING) self.declareProperty(name=common.PROP_TRANSPOSE_SAMPLE_OUTPUT, defaultValue=common.TRANSPOSING_ON, validator=StringListValidator([ common.TRANSPOSING_ON, common.TRANSPOSING_OFF]), direction=Direction.Input, doc='Enable or disable ' + common.PROP_OUTPUT_WS + ' transposing.') self.declareProperty(WorkspaceProperty( name=common.PROP_OUTPUT_THETA_W_WS, defaultValue='', direction=Direction.Output, optional=PropertyMode.Optional), doc='Output workspace for reduced S(theta, DeltaE).') self.setPropertyGroup(common.PROP_OUTPUT_THETA_W_WS, common.PROPGROUP_OPTIONAL_OUTPUT)