コード例 #1
0
    def parameters(cls):
        cls._exp_defs_param   = ParameterFactory.experiment_definition()

        parameters = [
                      cls._exp_defs_param,
                     ]
        return parameters
コード例 #2
0
    def parameters(cls):
        cls._file_param = ParameterFactory.file("Image stack tgz file.")
        cls._exp_defs_param = ParameterFactory.experiment_definition()
        cls._name_param = ParameterFactory.cs_string(
            NAME, "Unique name to give this image stack.")
        cls._short_desc_param = ParameterFactory.cs_string(
            DESCRIPTION, "Short description of image stack.")

        parameters = [
            cls._file_param,
            cls._exp_defs_param,
            cls._name_param,
            cls._short_desc_param,
        ]
        return parameters
コード例 #3
0
    def parameters(cls):
        cls.job_uuid_param  = ParameterFactory.job_uuid(SA_ASSAY_CALLER_COLLECTION)
        cls.job_name_param  = ParameterFactory.lc_string(JOB_NAME, JOB_NAME_DESC)
        cls.exp_defs_param  = ParameterFactory.experiment_definition()
        cls.req_drops_param = ParameterFactory.integer(REQUIRED_DROPS,
                                                       REQ_DROPS_DESCRIPTION,
                                                       required=True, default=0,
                                                       minimum=0)

        parameters = [
                      cls.job_uuid_param,
                      cls.job_name_param,
                      cls.exp_defs_param,
                      cls.req_drops_param,
                      ]
        return parameters
コード例 #4
0
    def parameters(cls):
        cls.job_uuid_param = ParameterFactory.job_uuid(SA_IDENTITY_COLLECTION)
        cls.job_name_param  = ParameterFactory.lc_string(JOB_NAME, 'Unique '\
                                                         'name to give this '
                                                         'job.')
        cls.exp_defs_param = ParameterFactory.experiment_definition()
        cls.training_param = ParameterFactory.integer(
            TRAINING_FACTOR,
            TRAINING_FACTOR_DESCRIPTION,
            default=AC_TRAINING_FACTOR,
            minimum=1,
            required=True)
        cls.ctrl_thresh = ParameterFactory.float(CTRL_THRESH,
                                                 CTRL_THRESH_DESCRIPTION,
                                                 default=AC_CTRL_THRESHOLD,
                                                 minimum=0.0,
                                                 maximum=100.0)
        cls.ctrl_filter = ParameterFactory.boolean(CTRL_FILTER,
                                                   CTRL_FILTER_DESCRIPTION,
                                                   default_value=False,
                                                   required=True)
        cls.ac_method = ParameterFactory.ac_method(AC_METHOD,
                                                   AC_METHOD_DESCRIPTION)
        cls.ac_model = ParameterFactory.cs_string(
            AC_MODEL,
            AC_MODEL_DESCRIPTION,
            required=False,
            enum=[
                m for model_dict in MODEL_FILES.values() for m in model_dict
            ])

        parameters = [
            cls.job_uuid_param,
            cls.job_name_param,
            cls.exp_defs_param,
            cls.training_param,
            cls.ctrl_thresh,
            cls.ctrl_filter,
            cls.ac_method,
            cls.ac_model,
        ]
        return parameters
コード例 #5
0
    def parameters(cls):
        # required parameters
        cls.job_name_param = ParameterFactory.lc_string(
            JOB_NAME, 'Unique name for this job.', required=True)
        cls.exp_def_param = ParameterFactory.experiment_definition()
        cls.mask_param = ParameterFactory.cs_string(
            VARIANT_MASK, 'Mask code for variant selection.', required=False)

        # primary analysis parameters
        cls.pa_data_src_param = ParameterFactory.cs_string(
            PA_DATA_SOURCE,
            "Primary analysis data source (HDF5 or image stack).",
            required=True)
        cls.dyes_param = ParameterFactory.dyes(required=False)
        cls.device_param = ParameterFactory.device(required=False,
                                                   default='katahdin')
        cls.major_param = ParameterFactory.integer(MAJOR,
                                                   'Major dye version',
                                                   minimum=0,
                                                   required=False,
                                                   default=1)
        cls.minor_param = ParameterFactory.integer(MINOR,
                                                   'Minor dye version',
                                                   minimum=0,
                                                   required=False,
                                                   default=0)
        cls.offset = ParameterFactory.integer(
            OFFSETS,
            'Offset used to infer a dye model.',
            default=abs(DEFAULT_OFFSETS[0]),
            minimum=1,
            required=False)
        cls.use_iid_param = ParameterFactory.boolean(USE_IID,
                                                     'Use IID Peak Detection.',
                                                     default_value=False,
                                                     required=False)

        # identity parameters
        cls.dye_levels_param = ParameterFactory.dye_levels(required=False)
        cls.ignored_dyes_param = ParameterFactory.dyes(name=IGNORED_DYES,
                                                       required=False)
        cls.filtered_dyes_param = ParameterFactory.dyes(name=FILTERED_DYES,
                                                        required=False)
        cls.pico1_dye_param = ParameterFactory.dye(PICO1_DYE,
                                                   'picoinjection 1 dye.',
                                                   required=False,
                                                   default=None)
        cls.pico2_dye_param = ParameterFactory.dye(PICO2_DYE,
                                                   'picoinjection 2 dye.',
                                                   required=False,
                                                   default=DEFAULT_PICO2_DYE)
        cls.assay_dye_param = ParameterFactory.dye(ASSAY_DYE,
                                                   'Assay dye.',
                                                   required=False,
                                                   default=DEFAULT_ASSAY_DYE)
        cls.n_probes_param = ParameterFactory.integer(NUM_PROBES,
                                                      NUM_PROBES_DESCRIPTION,
                                                      minimum=4,
                                                      required=False)
        cls.id_training_param = ParameterFactory.integer(
            ID_TRAINING_FACTOR,
            TRAINING_FACTOR_DESCRIPTION,
            minimum=1,
            required=False,
            default=DEFAULT_ID_TRAINING_FACTOR,
        )
        cls.ui_threshold_param = ParameterFactory.float(
            UI_THRESHOLD,
            UI_THRESHOLD_DESCRIPTION,
            minimum=0.0,
            required=False,
            default=DEFAULT_UNINJECTED_THRESHOLD)
        cls.continuous_phase_param = ParameterFactory.boolean(
            CONTINUOUS_PHASE,
            CONTINUOUS_PHASE_DESCRIPTION,
            default_value=False,
            required=False)
        cls.max_ui_ratio_param = ParameterFactory.float(
            MAX_UNINJECTED_RATIO,
            MAX_UI_RATIO_DESCRIPTION,
            default=DEFAULT_UNINJECTED_RATIO,
            minimum=0.0)
        cls.ignore_lowest_barcode = ParameterFactory.boolean(
            IGNORE_LOWEST_BARCODE,
            IGNORE_LOWEST_BARCODE_DESCRIPTION,
            default_value=True,
            required=False)
        cls.use_pico1_filter = ParameterFactory.boolean(
            USE_PICO1_FILTER,
            USE_PICO1_FILTER_DESCRIPTION,
            default_value=True,
            required=False)
        cls.use_pico2_filter = ParameterFactory.boolean(
            USE_PICO2_FILTER,
            USE_PICO2_FILTER_DESCRIPTION,
            default_value=True,
            required=False)
        cls.dev_mode_param = ParameterFactory.boolean(
            DEV_MODE,
            'Use development mode (more forgiving of mistakes).',
            default_value=DEFAULT_DEV_MODE,
            required=False)
        cls.drift_compensate_param = ParameterFactory.boolean(
            DRIFT_COMPENSATE,
            'Compensate for data drift.',
            default_value=DEFAULT_DRIFT_COMPENSATE,
            required=False)

        # assay caller params
        cls.ac_training_param = ParameterFactory.integer(
            AC_TRAINING_FACTOR,
            TRAINING_FACTOR_DESCRIPTION,
            minimum=1,
            required=False,
            default=DEFAULT_AC_TRAINING_FACTOR)

        cls.ctrl_thresh = ParameterFactory.float(
            CTRL_THRESH,
            CTRL_THRESH_DESCRIPTION,
            default=DEFAULT_AC_CTRL_THRESHOLD,
            minimum=0.0,
            maximum=100.0)

        cls.ctrl_filter = ParameterFactory.boolean(CTRL_FILTER,
                                                   CTRL_FILTER_DESCRIPTION,
                                                   default_value=False,
                                                   required=True)
        cls.ac_method = ParameterFactory.ac_method(AC_METHOD,
                                                   AC_METHOD_DESCRIPTION)
        cls.ac_model = ParameterFactory.cs_string(
            AC_MODEL,
            AC_MODEL_DESCRIPTION,
            required=False,
            enum=[
                m for model_dict in MODEL_FILES.values() for m in model_dict
            ])

        # genotyper params
        cls.req_drops_param = ParameterFactory.integer(REQUIRED_DROPS,
                                                       REQ_DROPS_DESCRIPTION,
                                                       required=False,
                                                       minimum=0,
                                                       default=0)

        parameters = [
            cls.pa_data_src_param,
            cls.dyes_param,
            cls.device_param,
            cls.major_param,
            cls.minor_param,
            cls.job_name_param,
            cls.offset,
            cls.use_iid_param,
            cls.pico1_dye_param,
            cls.pico2_dye_param,
            cls.assay_dye_param,
            cls.n_probes_param,
            cls.id_training_param,
            cls.dye_levels_param,
            cls.ignored_dyes_param,
            cls.dev_mode_param,
            cls.drift_compensate_param,
            cls.use_pico1_filter,
            cls.use_pico2_filter,
            cls.filtered_dyes_param,
            cls.ui_threshold_param,
            cls.continuous_phase_param,
            cls.max_ui_ratio_param,
            cls.ignore_lowest_barcode,
            cls.ac_training_param,
            cls.ctrl_thresh,
            cls.ctrl_filter,
            cls.ac_method,
            cls.ac_model,
            cls.req_drops_param,
            cls.exp_def_param,
            cls.mask_param,
        ]
        return parameters