annotate ident_params.xml @ 61:3ec27b4cee7c draft default tip

"planemo upload for repository https://github.com/galaxyproteomics/tools-galaxyp/tree/master/tools/peptideshaker commit fc2810c412d9954fa584ae74497562b986c52764"

<tool id="ident_params"
      name="Identification Parameters"
      version="@SEARCHGUI_VERSION@+galaxy@SEARCHGUI_VERSION_SUFFIX@"
      profile="20.01"
>
    <description>
        Sets the identification parameters to be used in SearchGUI and PeptideShaker apps
    </description>
    <macros>
        <import>macros_basic.xml</import>
        <import>macros_modifications.xml</import>
    </macros>
    <requirements>
      	<requirement type="package" version="@SEARCHGUI_VERSION@">searchgui</requirement>
    </requirements>
    <expand macro="stdio" />
    <command>
<![CDATA[
        #set $bin_dir = "bin"

        mkdir output;
        cwd=`pwd`;
        export HOME=\$cwd;



        echo 'running Identification Parameters CLI' &&
        #####################################################
        ## generate IdentificationParameters for SearchGUI ##
        #####################################################
        searchgui eu.isas.searchgui.cmd.IdentificationParametersCLI
            --exec_dir="./bin/"
            -use_log_folder 0
            -out './IdentificationParametersOutput.par'
            ## SPECTRUM MATCHING PARAMETERS

            -frag_tol '${spectrum_matching_options.fragment_tol}'
            -frag_ppm '${spectrum_matching_options.fragment_tol_units}'
            -prec_tol '${spectrum_matching_options.precursor_ion_tol}'
            -prec_ppm '${spectrum_matching_options.precursor_ion_tol_units}'

            #if $spectrum_matching_options.digestion.cleavage == 'default':
              -mc $spectrum_matching_options.digestion.missed_cleavages
            #elif $spectrum_matching_options.digestion.cleavage == '0' and len($spectrum_matching_options.digestion.digests) > 0:
              #set $enzymes = []
              #set $missed_cleavages = []
              #set $specificities = []
              #for $i, $digest in enumerate($spectrum_matching_options.digestion.digests):
                  #silent $enzymes.append(str($digest.enzyme))
                  #silent $missed_cleavages.append(str($digest.missed_cleavages))
                  #silent $specificities.append(str($digest.specificity))
              #end for
              -enzyme "#echo ','.join($enzymes)#"
              -mc "#echo ','.join($missed_cleavages)#"
              -specificity "#echo ','.join($specificities)#"
            #else:
               -digestion $spectrum_matching_options.digestion.cleavage
            #end if


            #set $fixed_mods_str = $spectrum_matching_options.fixed_modifications or ''
            #set $variable_mods_str = $spectrum_matching_options.variable_modifications or ''
            #if $fixed_mods_str
                -fixed_mods "$fixed_mods_str"
            #end if
            #if $variable_mods_str
                -variable_mods "$variable_mods_str"
            #end if


            -min_charge $spectrum_matching_options.min_charge
            -max_charge $spectrum_matching_options.max_charge
            -fi $spectrum_matching_options.forward_ion
            -ri $spectrum_matching_options.reverse_ion
            -min_isotope ${spectrum_matching_options.min_isotope}
            -max_isotope ${spectrum_matching_options.max_isotope}
            ## TODO: TO CHECK, these last two both are also present in the app in the import filters section.


            ## -- SEARCH ENGINES SPECIFIC PARAMETERS --

            ## XTANDEM ADVANCED SETTINGS

            #if $searchengines_options.xtandem.xtandem_advanced == "yes"

                ## Spectrum import
                #if $searchengines_options.xtandem.xtandem_spectrum.xtandem_spectrum_selector == "yes"
                    -xtandem_dynamic_range ${searchengines_options.xtandem.xtandem_spectrum.xtandem_dynamic_range}
                    -xtandem_npeaks ${searchengines_options.xtandem.xtandem_spectrum.xtandem_npeaks}
                    -xtandem_min_frag_mz ${searchengines_options.xtandem.xtandem_spectrum.xtandem_min_frag_mz}
                    -xtandem_min_peaks ${searchengines_options.xtandem.xtandem_spectrum.xtandem_min_peaks}
                    -xtandem_noise_suppr ${searchengines_options.xtandem.xtandem_spectrum.xtandem_noise_suppr}
                    -xtandem_min_prec_mass ${searchengines_options.xtandem.xtandem_spectrum.xtandem_min_prec_mass}
                    -xtandem_parent_isotope_correction ${searchengines_options.xtandem.xtandem_spectrum.xtandem_parent_isotope_correction}
                #end if

                ## Advanced search
                #if $searchengines_options.xtandem.xtandem_asearch.xtandem_asearch_selector == "yes"
                    -xtandem_quick_acetyl ${searchengines_options.xtandem.xtandem_asearch.xtandem_quick_acetyl}
                    -xtandem_quick_pyro ${searchengines_options.xtandem.xtandem_asearch.xtandem_quick_pyro}
                    -xtandem_stp_bias ${searchengines_options.xtandem.xtandem_asearch.xtandem_stp_bias}
                    -xtandem_ptm_complexity ${searchengines_options.xtandem.xtandem_asearch.xtandem_ptm_complexity}
                #end if

                ## Output
                #if $searchengines_options.xtandem.xtandem_output.xtandem_output_selector == "yes"
                    -xtandem_output_results $searchengines_options.xtandem.xtandem_output.xtandem_output_results_conditional.xtandem_output_results_selector
                    #if $searchengines_options.xtandem.xtandem_output.xtandem_output_results_conditional.xtandem_output_results_selector != "all"
                      -xtandem_evalue ${searchengines_options.xtandem.xtandem_output.xtandem_output_results_conditional.xtandem_evalue}
                    #end if
                    -xtandem_output_proteins ${searchengines_options.xtandem.xtandem_output.xtandem_output_proteins}
                    -xtandem_output_sequences ${searchengines_options.xtandem.xtandem_output.xtandem_output_sequences}
                    -xtandem_output_spectra ${searchengines_options.xtandem.xtandem_output.xtandem_output_spectra}
                    -xtandem_output_histograms ${searchengines_options.xtandem.xtandem_output.xtandem_output_histograms}
                    ## TODO: Integration with Skyline not ready yet: -xtandem_skyline_path ${searchengines_options.xtandem.xtandem_output.xtandem_skyline_path}
                #end if

                ## Refinement
                #if $searchengines_options.xtandem.xtandem_refine.xtandem_refine_selector == "yes"
                    -xtandem_refine 1
                    -xtandem_refine_evalue ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_evalue}
                    -xtandem_refine_unc ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_unc}
                    -xtandem_refine_semi ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_semi}
                    -xtandem_refine_pot ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_pot}
                    -xtandem_refine_p_mut ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_p_mut}
                    -xtandem_refine_snaps ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_snaps}
                    -xtandem_refine_spec_synt ${searchengines_options.xtandem.xtandem_refine.xtandem_refine_spec_synt}
                #else
                    -xtandem_refine 0
                #end if
            #else
                -xtandem_output_spectra 1
            #end if

            ## MYRIMATCH ADVANCED SETTINGS

            #if $searchengines_options.myrimatch.myrimatch_advanced == "yes"
                -myrimatch_min_pep_length ${searchengines_options.myrimatch.myrimatch_min_pep_length}
                -myrimatch_max_pep_length ${searchengines_options.myrimatch.myrimatch_max_pep_length}
                -myrimatch_min_prec_mass ${searchengines_options.myrimatch.myrimatch_min_prec_mass}
                -myrimatch_max_prec_mass ${searchengines_options.myrimatch.myrimatch_max_prec_mass}
                -myrimatch_num_matches ${searchengines_options.myrimatch.myrimatch_num_matches}
                -myrimatch_num_ptms ${searchengines_options.myrimatch.myrimatch_num_ptms}
                -myrimatch_fragmentation ${searchengines_options.myrimatch.myrimatch_fragmentation}
                -myrimatch_termini ${searchengines_options.myrimatch.myrimatch_termini}
                -myrimatch_plus_three ${searchengines_options.myrimatch.myrimatch_plus_three}
                -myrimatch_xcorr ${searchengines_options.myrimatch.myrimatch_xcorr}
                -myrimatch_tic_cutoff ${searchengines_options.myrimatch.myrimatch_tic_cutoff}
                -myrimatch_intensity_classes ${searchengines_options.myrimatch.myrimatch_intensity_classes}
                -myrimatch_class_multiplier ${searchengines_options.myrimatch.myrimatch_class_multiplier}
                -myrimatch_num_batches ${searchengines_options.myrimatch.myrimatch_num_batches}
                -myrimatch_max_peak ${searchengines_options.myrimatch.myrimatch_max_peak}
                -myrimatch_output ${searchengines_options.myrimatch.myrimatch_output}
            #else
                -myrimatch_output mzIdentML
            #end if


            ## MSGF+ ADVANCED SETTINGS

            #if $searchengines_options.msgf.msgf_advanced == "yes"
                -msgf_decoy ${searchengines_options.msgf.msgf_decoy}
                -msgf_instrument ${searchengines_options.msgf.msgf_instrument}
                -msgf_fragmentation ${searchengines_options.msgf.msgf_fragmentation}
                -msgf_protocol ${searchengines_options.msgf.msgf_protocol}
                -msgf_termini ${searchengines_options.msgf.msgf_termini}
                -msgf_min_pep_length ${searchengines_options.msgf.msgf_min_pep_length}
                -msgf_max_pep_length ${searchengines_options.msgf.msgf_max_pep_length}
                -msgf_num_ptms ${searchengines_options.msgf.msgf_num_ptms}
                -msgf_num_matches ${searchengines_options.msgf.msgf_num_matches}
                -msgf_additional ${searchengines_options.msgf.msgf_additional}
                #if $searchengines_options.msgf.msgf_tasks.msgf_tasks_custom == "yes"
                -msgf_num_tasks ${searchengines_options.msgf.msgf_tasks.msgf_num_tasks}
                #end if
            #end if


            ## MSAMANDA ADVANCED SETTINGS

            #if $searchengines_options.ms_amanda.ms_amanda_advanced == "yes"
                 -ms_amanda_decoy ${searchengines_options.ms_amanda.ms_amanda_decoy}
                 -ms_amanda_instrument "${searchengines_options.ms_amanda.ms_amanda_instrument}"
                 -ms_amanda_max_rank ${searchengines_options.ms_amanda.ms_amanda_max_rank}
                 -ms_amanda_mono ${searchengines_options.ms_amanda.ms_amanda_mono}
            #end if


            ## ANDROMEDA ADVANCED SETTINGS

            #* Not working in tests
            #if $searchengines_options.andromeda.andromeda_advanced == "yes"
                -andromeda_max_pep_mass ${searchengines_options.andromeda.andromeda_max_pep_mass}
                -andromeda_max_comb ${searchengines_options.andromeda.andromeda_max_comb}
                -andromeda_top_peaks ${searchengines_options.andromeda.andromeda_top_peaks}
                -andromeda_top_peaks_window ${searchengines_options.andromeda.andromeda_top_peaks_window}
                -andromeda_incl_water ${searchengines_options.andromeda.andromeda_incl_water}
                -andromeda_incl_ammonia ${searchengines_options.andromeda.andromeda_incl_ammonia}
                -andromeda_neutral_losses ${searchengines_options.andromeda.andromeda_neutral_losses}
                -andromeda_fragment_all ${searchengines_options.andromeda.andromeda_fragment_all}
                -andromeda_emp_correction ${searchengines_options.andromeda.andromeda_emp_correction}
                -andromeda_higher_charge ${searchengines_options.andromeda.andromeda_higher_charge}
                -andromeda_equal_il ${searchengines_options.andromeda.andromeda_equal_il}
                -andromeda_frag_method ${searchengines_options.andromeda.andromeda_frag_method}
                -andromeda_max_mods ${searchengines_options.andromeda.andromeda_max_mods}
                -andromeda_min_pep_length ${searchengines_options.andromeda.andromeda_min_pep_length}
                -andromeda_max_pep_length ${searchengines_options.andromeda.andromeda_max_pep_length}
                -andromeda_max_psms ${searchengines_options.andromeda.andromeda_max_psms}
                -andromeda_decoy_mode ${searchengines_options.andromeda.andromeda_decoy_mode}
            #end if
            *#


            ## OMSSA ADVANCED SETTINGS

            #if $searchengines_options.omssa.omssa_advanced == "yes"
                ## Spectrum
                #if $searchengines_options.omssa.omssa_spectrum.omssa_spectrum_selector == "yes"
                    -omssa_low_intensity "${searchengines_options.omssa.omssa_spectrum.omssa_low_intensity}"
                    -omssa_high_intensity ${searchengines_options.omssa.omssa_spectrum.omssa_high_intensity}
                    -omssa_intensity_incr ${searchengines_options.omssa.omssa_spectrum.omssa_intensity_incr}
                    -omssa_min_peaks ${searchengines_options.omssa.omssa_spectrum.omssa_min_peaks}
                    -omssa_remove_prec ${searchengines_options.omssa.omssa_spectrum.omssa_remove_prec}
                    -omssa_estimate_charge ${searchengines_options.omssa.omssa_spectrum.omssa_estimate_charge}
                    -omssa_plus_one ${searchengines_options.omssa.omssa_spectrum.omssa_plus_one}
                    -omssa_fraction ${searchengines_options.omssa.omssa_spectrum.omssa_fraction}
                    -omssa_prec_per_spectrum ${searchengines_options.omssa.omssa_spectrum.omssa_prec_per_spectrum}
                    -omssa_scale_prec ${searchengines_options.omssa.omssa_spectrum.omssa_scale_prec}
                #end if

                ## Spectrum
                #if $searchengines_options.omssa.omssa_database.omssa_database_selector == "yes"
                    -omssa_memory ${searchengines_options.omssa.omssa_database.omssa_memory}
                    -omssa_methionine ${searchengines_options.omssa.omssa_database.omssa_methionine}
                #end if

                ## Database
                #if $searchengines_options.omssa.omssa_search.omssa_search_selector == "yes"
                    -omssa_neutron ${searchengines_options.omssa.omssa_search.omssa_neutron}
                    -omssa_single_window_wd ${searchengines_options.omssa.omssa_search.omssa_single_window_wd}
                    -omssa_double_window_wd ${searchengines_options.omssa.omssa_search.omssa_double_window_wd}
                    -omssa_single_window_pk ${searchengines_options.omssa.omssa_search.omssa_single_window_pk}
                    -omssa_double_window_pk ${searchengines_options.omssa.omssa_search.omssa_double_window_pk}
                    -omssa_min_ann_int_pks ${searchengines_options.omssa.omssa_search.omssa_min_ann_int_pks}
                    -omssa_min_annotated_peaks ${searchengines_options.omssa.omssa_search.omssa_min_annotated_peaks}
                    -omssa_max_ladders ${searchengines_options.omssa.omssa_search.omssa_max_ladders}
                    -omssa_max_frag_charge ${searchengines_options.omssa.omssa_search.omssa_max_frag_charge}
                    -omssa_charge ${searchengines_options.omssa.omssa_search.omssa_charge}
                    -omssa_forward ${searchengines_options.omssa.omssa_search.omssa_forward}
                    -omssa_rewind ${searchengines_options.omssa.omssa_search.omssa_rewind}
                    -omssa_max_frag_series ${searchengines_options.omssa.omssa_search.omssa_max_frag_series}
                    -omssa_corr ${searchengines_options.omssa.omssa_search.omssa_corr}
                    -omssa_consecutive_p ${searchengines_options.omssa.omssa_search.omssa_consecutive_p}
                    -omssa_hitlist_charge ${searchengines_options.omssa.omssa_search.omssa_hitlist_charge}
                #end if

                ## Iterative Search
                #if $searchengines_options.omssa.omssa_isearch.omssa_isearch_selector == "yes"
                    -omssa_it_sequence_evalue ${searchengines_options.omssa.omssa_isearch.omssa_it_sequence_evalue}
                    -omssa_it_spectrum_evalue ${searchengines_options.omssa.omssa_isearch.omssa_it_spectrum_evalue}
                    -omssa_it_replace_evalue ${searchengines_options.omssa.omssa_isearch.omssa_it_replace_evalue}
                #end if

                ## Semi-enzymatic
                #if $searchengines_options.omssa.omssa_senzymatic.omssa_senzymatic_selector == "yes"
                    -omssa_min_pep_length ${searchengines_options.omssa.omssa_senzymatic.omssa_min_pep_length}
                    -omssa_max_pep_length ${searchengines_options.omssa.omssa_senzymatic.omssa_max_pep_length}
                #end if

                ## Output
                #if $searchengines_options.omssa.omssa_output_conditional.omssa_output_conditional_selector == "yes"
                    -omssa_max_evalue ${searchengines_options.omssa.omssa_output_conditional.omssa_max_evalue}
                    -omssa_hitlist_length ${searchengines_options.omssa.omssa_output_conditional.omssa_hitlist_length}
                    -omssa_format ${searchengines_options.omssa.omssa_output_conditional.omssa_format}
                #end if
            #end if


            ## COMET ADVANCED SETTINGS

            #if $searchengines_options.comet.comet_advanced == "yes"

                #if $searchengines_options.comet.comet_spectrum.comet_spectrum_selector == "yes"
                    -comet_min_peaks ${searchengines_options.comet.comet_spectrum.comet_min_peaks}
                    -comet_min_peak_int ${searchengines_options.comet.comet_spectrum.comet_min_peak_int}
                    -comet_remove_prec ${searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec}
                     #if $searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec == "1"
                        -comet_remove_prec_tol ${searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec_tol}
                     #end if
                     #if $searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec == "2"
                        -comet_remove_prec_tol ${searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec_tol}
                     #end if
                     #if $searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec == "3"
                        -comet_remove_prec_tol ${searchengines_options.comet.comet_spectrum.comet_prec.comet_remove_prec_tol}
                     #end if
                    -comet_clear_mz_range_lower ${searchengines_options.comet.comet_spectrum.comet_clear_mz_range_lower}
                    -comet_clear_mz_range_upper ${searchengines_options.comet.comet_spectrum.comet_clear_mz_range_upper}
                #end if

                #if $searchengines_options.comet.comet_search.comet_search_selector == "yes"
                    -comet_enzyme_type ${searchengines_options.comet.comet_search.comet_enzyme_type}
                    -comet_isotope_correction ${searchengines_options.comet.comet_search.comet_isotope_correction}
                    -comet_min_prec_mass ${searchengines_options.comet.comet_search.comet_min_prec_mass}
                    -comet_max_prec_mass ${searchengines_options.comet.comet_search.comet_max_prec_mass}
                    -comet_max_frag_charge ${searchengines_options.comet.comet_search.comet_max_frag_charge}
                    -comet_remove_meth ${searchengines_options.comet.comet_search.comet_remove_meth}
                    -comet_batch_size ${searchengines_options.comet.comet_search.comet_batch_size}
                    -comet_num_ptms ${searchengines_options.comet.comet_search.comet_num_ptms}
                    -comet_req_ptms ${searchengines_options.comet.comet_search.comet_req_ptms}
                #end if

                #if $searchengines_options.comet.comet_fragment_ions.comet_fragment_ions_selector == "yes"
                    -comet_theoretical_fragment_ions ${searchengines_options.comet.comet_fragment_ions.comet_theoretical_fragment_ions}
                    -comet_frag_bin_offset ${searchengines_options.comet.comet_fragment_ions.comet_frag_bin_offset}
                #end if

                #if $searchengines_options.comet.comet_output.comet_output_selector == "yes"
                    -comet_num_matches ${searchengines_options.comet.comet_output.comet_num_matches}
                    -comet_output ${searchengines_options.comet.comet_output.comet_output_type}
                #end if
            #end if


            ## TIDE ADVANCED SETTINGS

            #if $searchengines_options.tide.tide_advanced == "yes"
                ## Index parameters
                #if $searchengines_options.tide.tide_index.tide_index_selector == "yes"
                    -tide_min_pep_length ${searchengines_options.tide.tide_index.tide_min_pep_length}
                    -tide_max_pep_length ${searchengines_options.tide.tide_index.tide_max_pep_length}
                    -tide_min_prec_mass ${searchengines_options.tide.tide_index.tide_min_prec_mass}
                    -tide_max_prec_mass ${searchengines_options.tide.tide_index.tide_max_prec_mass}
                    -tide_monoisotopic ${searchengines_options.tide.tide_index.tide_monoisotopic}
                    -tide_clip_n_term ${searchengines_options.tide.tide_index.tide_clip_n_term}
                    #if str($searchengines_options.tide.tide_index.tide_num_ptms).strip() != '':
                      -tide_num_ptms ${searchengines_options.tide.tide_index.tide_num_ptms}
                    #end if
                    -tide_num_ptms_per_type ${searchengines_options.tide.tide_index.tide_num_ptms_per_type}
                    -tide_digestion_type ${searchengines_options.tide.tide_index.tide_digestion_type}
                    -tide_print_peptides ${searchengines_options.tide.tide_index.tide_print_peptides}
                    -tide_decoy_format ${searchengines_options.tide.tide_index.tide_decoy_format}
                    -tide_keep_terminals ${searchengines_options.tide.tide_index.tide_keep_terminals}
                    -tide_decoy_seed ${searchengines_options.tide.tide_index.tide_decoy_seed}
                    -tide_remove_temp ${searchengines_options.tide.tide_index.tide_remove_temp}
                #end if

                ## Search parameters
                #if $searchengines_options.tide.tide_search.tide_search_selector == "yes"
                    -tide_compute_p ${searchengines_options.tide.tide_search.tide_compute_p}
                    -tide_compute_sp ${searchengines_options.tide.tide_search.tide_compute_sp}
                    -tide_min_spectrum_mz ${searchengines_options.tide.tide_search.tide_min_spectrum_mz}
                    #if str($searchengines_options.tide.tide_search.tide_max_spectrum_mz).strip() != '':
                      -tide_max_spectrum_mz ${searchengines_options.tide.tide_search.tide_max_spectrum_mz}
                    #end if
                    -tide_min_spectrum_peaks ${searchengines_options.tide.tide_search.tide_min_spectrum_peaks}
                    -tide_spectrum_charges ${searchengines_options.tide.tide_search.tide_spectrum_charges}
                    -tide_remove_prec ${searchengines_options.tide.tide_search.tide_remove_prec}
                    -tide_remove_prec_tol ${searchengines_options.tide.tide_search.tide_remove_prec_tol}
                    -tide_use_flanking ${searchengines_options.tide.tide_search.tide_use_flanking}
                    -tide_use_neutral_losses ${searchengines_options.tide.tide_search.tide_use_neutral_losses}
                    -tide_mz_bin_width ${searchengines_options.tide.tide_search.tide_mz_bin_width}
                    -tide_mz_bin_offset ${searchengines_options.tide.tide_search.tide_mz_bin_offset}
                    -tide_max_psms ${searchengines_options.tide.tide_search.tide_max_psms}

                    #set $format_list = str($searchengines_options.tide.tide_search.tide_export).split(',')
                    #set $formats_available = ["tide_export_text", "tide_export_sqt", "tide_export_pepxml", "tide_export_mzid", "tide_export_pin"]
                    #for $format_available in $formats_available:
                        #if $format_available in $format_list:
                          -$format_available 1
                        #else:
                          -$format_available 0
                        #end if
                    #end for
                #end if
                    -tide_output_folder ${searchengines_options.tide.tide_output_folder}
                    -tide_verbosity ${searchengines_options.tide.tide_verbosity}
                    -tide_progress_indicator ${searchengines_options.tide.tide_progress_indicator}
                    -tide_concat ${searchengines_options.tide.tide_concat}
                    #if str($searchengines_options.tide.tide_store_spectra).strip() != '':
                      -tide_store_spectra ${searchengines_options.tide.tide_store_spectra}
                    #end if

            #end if


            ## DIRECTTAG ADVANCED SETTINGS

            #if $searchengines_options.directtag.directtag_advanced == "yes"
                -directag_tag_length ${searchengines_options.directtag.directag_tag_length}
                -directag_max_var_mods ${searchengines_options.directtag.directag_max_var_mods}
                -directag_charge_states ${searchengines_options.directtag.directag_charge_states}
                -directag_duplicate_spectra ${searchengines_options.directtag.directag_duplicate_spectra}
                -directag_isotope_tolerance ${searchengines_options.directtag.directag_isotope_tolerance}
                -directag_deisotoping ${searchengines_options.directtag.directag_deisotoping}
                -directag_intensity_classes ${searchengines_options.directtag.directag_intensity_classes}
                #if str($searchengines_options.directtag.directag_output_suffix).strip() != '':
                -directag_output_suffix ${searchengines_options.directtag.directag_output_suffix}
                #end if
                -directag_max_peak_count ${searchengines_options.directtag.directag_max_peak_count}
                -directag_max_tag_count ${searchengines_options.directtag.directag_max_tag_count}
                -directag_tic_cutoff ${searchengines_options.directtag.directag_tic_cutoff}
                -directag_complement_tolerance ${searchengines_options.directtag.directag_complement_tolerance}
                -directag_adjustment_step ${searchengines_options.directtag.directag_adjustment_step}
                -directag_min_adjustment ${searchengines_options.directtag.directag_min_adjustment}
                -directag_max_adjustment ${searchengines_options.directtag.directag_max_adjustment}
                -directag_intensity_weight ${searchengines_options.directtag.directag_intensity_weight}
                -directag_fidelity_weight ${searchengines_options.directtag.directag_fidelity_weight}
                -directag_complement_weight ${searchengines_options.directtag.directag_complement_weight}
                -directag_adjust_precursor ${searchengines_options.directtag.directag_adjust_precursor}
                -directag_ms_charge_state ${searchengines_options.directtag.directag_ms_charge_state}
            #end if

            ## METAMORPHEUS ADVANCED SETTINGS

            #if $searchengines_options.metamorpheus.metamorpheus_advanced == "yes"
                ## Search options
                #if $searchengines_options.metamorpheus.metamorpheus_search.metamorpheus_search_selector == "yes"
                    -meta_morpheus_search_type ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_search_type}
                    -meta_morpheus_num_partitions ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_num_partitions}
                    -meta_morpheus_dissociation_type ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_dissociation_type}
                    -meta_morpheus_max_mods_for_peptide ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_max_mods_for_peptide}
                    -meta_morpheus_score_cutoff ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_score_cutoff}
                    -meta_morpheus_use_delta_score ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_use_delta_score}
                    -meta_morpheus_mass_diff_acceptor_type ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_mass_diff_acceptor_type}
                    -meta_morpheus_min_pep_length ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_min_pep_length}
                    -meta_morpheus_max_pep_length ${searchengines_options.metamorpheus.metamorpheus_search.meta_morpheus_max_pep_length}
                #end if

                ## Output options
                #if $searchengines_options.metamorpheus.metamorpheus_output.metamorpheus_output_selector == "yes"
                    -meta_morpheus_write_mzid ${searchengines_options.metamorpheus.metamorpheus_output.meta_morpheus_write_mzid}
                    -meta_morpheus_write_pepxml ${searchengines_options.metamorpheus.metamorpheus_output.meta_morpheus_write_pepxml}
                #end if

                ## Deisotoping options
                #if $searchengines_options.metamorpheus.metamorpheus_deisotoping.metamorpheus_deisotoping_selector == "yes"
                    -meta_morpheus_use_provided_prec ${searchengines_options.metamorpheus.metamorpheus_deisotoping.meta_morpheus_use_provided_prec}
                    -meta_morpheus_do_prec_deconv ${searchengines_options.metamorpheus.metamorpheus_deisotoping.meta_morpheus_do_prec_deconv}
                    -meta_morpheus_deconv_int_ratio ${searchengines_options.metamorpheus.metamorpheus_deisotoping.meta_morpheus_deconv_int_ratio}
                    -meta_morpheus_deconv_mass_tol ${searchengines_options.metamorpheus.metamorpheus_deisotoping.meta_morpheus_deconv_mass_tol}
                    -meta_morpheus_deconv_mass_tol_type ${searchengines_options.metamorpheus.metamorpheus_deisotoping.meta_morpheus_deconv_mass_tol_type}
                #end if

                ## Protein grouping options
                #if $searchengines_options.metamorpheus.metamorpheus_proteingrouping.metamorpheus_proteingrouping_selector == "yes"
                    -meta_morpheus_mod_peptides_are_different ${searchengines_options.metamorpheus.metamorpheus_proteingrouping.meta_morpheus_mod_peptides_are_different}
                    -meta_morpheus_no_one_hit_wonders ${searchengines_options.metamorpheus.metamorpheus_proteingrouping.meta_morpheus_no_one_hit_wonders}
                #end if

                ## Peak trimming options
                #if $searchengines_options.metamorpheus.metamorpheus_peaktrimming.metamorpheus_peaktrimming_selector == "yes"
                    -meta_morpheus_trim_ms1 ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_trim_ms1}
                    -meta_morpheus_trim_msms ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_trim_msms}
                    -meta_morpheus_num_peaks_per_window ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_num_peaks_per_window}
                    -meta_morpheus_min_allowed_int_ratio_to_base_peak ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_min_allowed_int_ratio_to_base_peak}
                    -meta_morpheus_window_with_thompson ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_window_with_thompson}
                    -meta_morpheus_num_windows ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_num_windows}
                    -meta_morpheus_norm_across_all_windows ${searchengines_options.metamorpheus.metamorpheus_peaktrimming.meta_morpheus_norm_across_all_windows}
                #end if

                ## Silico digestion related options
                #if $searchengines_options.metamorpheus.metamorpheus_silico.metamorpheus_silico_selector == "yes"
                    -meta_morpheus_frag_term ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_frag_term}
                    -meta_morpheus_max_frag_size ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_max_frag_size}
                    -meta_morpheus_search_target ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_search_target}
                    -meta_morpheus_decoy_type ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_decoy_type}
                    -meta_morpheus_max_mod_isoforms ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_max_mod_isoforms}
                    -meta_morpheus_min_variant_depth ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_min_variant_depth}
                    -meta_morpheus_min_variant_depth ${searchengines_options.metamorpheus.metamorpheus_silico.meta_morpheus_min_variant_depth}
                #end if

                ## G-PTM search related options
                #if $searchengines_options.metamorpheus.metamorpheus_gptm.metamorpheus_gptm_selector == "yes"
                    -meta_morpheus_gptm ${searchengines_options.metamorpheus.metamorpheus_gptm.meta_morpheus_gptm}

                    ## Need to transform the list of gptm acronyms to real gptm values for SearchGUI
                    #if str($searchengines_options.metamorpheus.metamorpheus_gptm.meta_morpheus_gptm_categories) != "None" and str($searchengines_options.metamorpheus.metamorpheus_gptm.meta_morpheus_gptm_categories) != ""
                        #set $meta_morpheus_gptm_categories_list = set(str($searchengines_options.metamorpheus.metamorpheus_gptm.meta_morpheus_gptm_categories).split(','))
                    #else
                        #set $meta_morpheus_gptm_categories_list = set()
                    #end if
                    #set $meta_morpheus_categories_mapping = {'common_fixed_variable': 'Common Fixed and Variable', 'common_biological': 'Common Biological','common_artifact': 'Common Artifact', 'metal': 'Metal','less_common': 'Less Common','labeling': 'Labeling','subs_1n': 'Substitution (1 Nucleotide)','subs_2n': 'Substitution (2+ Nucleotides)','other': 'Other'}
                    #set $meta_morpheus_gptm_real_categories_list = []
                    #for $meta_morpheus_gptm_category_item in $meta_morpheus_gptm_categories_list:
                        $meta_morpheus_gptm_real_categories_list.append("'"+$meta_morpheus_categories_mapping[$meta_morpheus_gptm_category_item]+"'")
                    #end for

                    #if len($meta_morpheus_gptm_real_categories_list) > 0
                            -meta_morpheus_gptm_categories #echo ','.join($meta_morpheus_gptm_real_categories_list)#
                    #end if

                #end if

            #end if

            ## NOVOR ADVANCED SETTINGS

            #if $searchengines_options.novor.novor_advanced == "yes"
                -novor_fragmentation ${searchengines_options.novor.novor_fragmentation}
                -novor_mass_analyzer ${searchengines_options.novor.novor_mass_analyzer}
            #end if


            ## PEPNOVO+ ADVANCED SETTINGS

            #if $searchengines_options.pepnovo.pepnovo_advanced == "yes"
                -pepnovo_hitlist_length ${searchengines_options.pepnovo.pepnovo_hitlist_length}
                -pepnovo_estimate_charge ${searchengines_options.pepnovo.pepnovo_estimate_charge}
                -pepnovo_correct_prec_mass ${searchengines_options.pepnovo.pepnovo_correct_prec_mass}
                -pepnovo_discard_spectra ${searchengines_options.pepnovo.pepnovo_discard_spectra}
                -pepnovo_generate_blast ${searchengines_options.pepnovo.pepnovo_generate_blast}
            #end if


            ## PNOVO+ ADVANCED SETTINGS

            #if $searchengines_options.pnovo.pnovo_advanced == "yes"
                -pnovo_num_peptides ${searchengines_options.pnovo.pnovo_num_peptides}
                -pnovo_lower_prec ${searchengines_options.pnovo.pnovo_lower_prec}
                -pnovo_upper_prec ${searchengines_options.pnovo.pnovo_upper_prec}
                -pnovo_activation ${searchengines_options.pnovo.pnovo_activation}
            #end if


            ## -- ADVANCED PARAMETERS

            ## SPECTRUM ANNOTATION
            -annotation_level $advanced_options.spectrum_annotation_options.annotation_level

            ## if the user modifies fragment_tol but he does not modify annotation_mz_tolerance,
            ## we must overwrite default annotation_mz_tolerance value with fragment_tol value

            #if not ($spectrum_matching_options.fragment_tol != 0.5 and $advanced_options.spectrum_annotation_options.annotation_mz_tolerance == 0.5)
            -annotation_mz_tolerance $advanced_options.spectrum_annotation_options.annotation_mz_tolerance
            #end if
            -annotation_high_resolution $advanced_options.spectrum_annotation_options.annotation_high_resolution
            ## TODO: There are still many options from the GUI to be incorporated to the CLI


            ## SEQUENCE MATCHING
            -sequence_matching_type $advanced_options.sequence_matching_options.sequence_matching_type
            -sequence_matching_x $advanced_options.sequence_matching_options.sequence_matching_x
            -sequence_matching_enzymatic_tags $advanced_options.sequence_matching_options.sequence_matching_enzymatic_tags
            -sequence_matching_max_ptms_per_tag $advanced_options.sequence_matching_options.sequence_matching_max_ptms_per_tag
            -sequence_matching_min_amino_acid_score $advanced_options.sequence_matching_options.sequence_matching_min_amino_acid_score
            -sequence_matching_min_tag_length $advanced_options.sequence_matching_options.sequence_matching_min_tag_length


            ## IMPORT FILTERS

            -import_peptide_length_min '${advanced_options.import_filters_options.min_peptide_length}'
            -import_peptide_length_max '${advanced_options.import_filters_options.max_peptide_length}'
            -import_precursor_mz '${advanced_options.import_filters_options.max_precursor_error}'
            -import_precursor_mz_ppm '${advanced_options.import_filters_options.max_precursor_error_type}'
            #if $advanced_options.import_filters_options.missed_cleavages_min
              -import_missed_cleavages_min '${advanced_options.import_filters_options.missed_cleavages_min}'
            #end if
            #if $advanced_options.import_filters_options.missed_cleavages_max
              -import_missed_cleavages_max '${advanced_options.import_filters_options.missed_cleavages_max}'
            #end if
            -exclude_unknown_ptms '${advanced_options.import_filters_options.exclude_unknown_ptms}'


            ## PTM LOCALIZATION

            -ptm_score '${advanced_options.ptm_localization_options.ptm_score.ptm_score_selector}'
                #if $advanced_options.ptm_localization_options.ptm_score.ptm_score_selector == 1
                    -score_neutral_losses '${advanced_options.ptm_localization_options.ptm_score.neutral_losses}'
                    #if str($advanced_options.ptm_localization_options.ptm_score.ptm_threshold) != ''
                        -ptm_threshold '${advanced_options.ptm_localization_options.ptm_score.ptm_threshold}'
                    #end if
                #end if
            -ptm_alignment '${advanced_options.ptm_localization_options.ptm_alignment}'
            -ptm_sequence_matching_type '${advanced_options.ptm_localization_options.ptm_sequence_matching_type}'


            ## GENE ANNOTATION

            $advanced_options.gene_annotation_options.use_gene_mapping
            #if $advanced_options.gene_annotation_options.use_gene_mapping:
                $advanced_options.gene_annotation_options.update_gene_mapping
            #else:
                -updateGeneMapping 0
            #end if


            ## PROTEIN INFERENCE

            #if $advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_selector == "yes"
                -simplify_groups 1
                -simplify_evidence ${advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_evidence}
                -simplify_confidence ${advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_confidence}
                -simplify_confidence_threshold ${advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_confidence_threshold}
                -simplify_enzymaticity ${advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_enzymaticity}
                -simplify_variant ${advanced_options.protein_inference_options.simplify_protein_groups_conditional.simplify_protein_groups_variant}
            #else
                -simplify_groups 0
            #end if
            -pi_modifications ${advanced_options.protein_inference_options.simplify_protein_pi_modifications}




            ## VALIDATION LEVELS

            -protein_fdr '${advanced_options.validation_levels_options.protein_fdr}'
            -peptide_fdr '${advanced_options.validation_levels_options.peptide_fdr}'
            -psm_fdr '${advanced_options.validation_levels_options.psm_fdr}'


            ## FRACTION ANALYSIS

            -protein_fraction_mw_confidence '${advanced_options.fraction_analysis_options.protein_fraction_mw_confidence}'



            ## DATABASE PROCESSING OPTIONS

            #if $advanced_options.database_processing_options.decoy_conditional.create_decoy_selector == "yes"
                -fasta_target_decoy 1
                -fasta_decoy_tag $advanced_options.database_processing_options.decoy_conditional.decoy_tag
                -fasta_decoy_type $advanced_options.database_processing_options.decoy_conditional.decoy_type
            #end if
                -fasta_target_decoy 0
                -fasta_decoy_file_tag $advanced_options.database_processing_options.decoy_file_tag
]]>
    </command>
    <inputs>


        <!-- SPECTRUM MATCHING PARAMETERS -->

        <section name="spectrum_matching_options" expanded="false" title="Spectrum Matching Options">

            <param name="fixed_modifications" type="select" label="Fixed Modifications" multiple="true"
                help="Occurs in known places on peptide sequence. Hold the appropriate key while clicking to select multiple items">
                <expand macro="modifications"/>
            </param>
            <param name="variable_modifications" type="select" label="Variable Modifications" multiple="true"
                help="Can occur anywhere on the peptide sequence; adds additional error to search score. Hold the appropriate key while clicking to select multiple items">
                <expand macro="modifications"/>
            </param>

            <conditional name="digestion">
                <param name="cleavage" type="select" label="Digestion">
                    <option value="0">Select Enzymes</option>
                    <option value="1">Unspecific Cleavage</option>
                    <option value="2">Whole Protein</option>
                </param>
                <when value="0">
                    <repeat name="digests" min="1" title="Enzymes">
                        <param name="enzyme" type="select" label="Enzyme"
                            help="Which enzyme was used for protein digest in experiment? In most cases, trypsin is used">
                            <option value="Trypsin">Trypsin</option>
                            <option value="Trypsin (no P rule)">Trypsin (no P rule)</option>
                            <option value="Arg-C">Arg-C</option>
                            <option value="Arg-C (no P rule)">Arg-C</option>
                            <option value="Arg-N">Arg-N</option>
                            <option value="Glu-C">Glu-C</option>
                            <option value="Lys-C">Lys-C</option>
                            <option value="Lys-C (no P rule)">Lys-C (no P rule)</option>
                            <option value="Lys-N">Lys-N</option>
                            <option value="Asp-N">Asp-N</option>
                            <option value="Asp-N (ambic)">Asp-N (ambic)</option>
                            <option value="Chymotrypsin">Chymotrypsin</option>
                            <option value="Chymotrypsin (no P rule)">Chymotrypsin (no P rule)</option>
                            <option value="Pepsin A">Pepsin A</option>
                            <option value="CNBr">CNBr</option>
                            <option value="Thermolysin">Thermolysin</option>
                            <option value="LysargiNase">LysargiNase</option>
                        </param>
                        <param name="missed_cleavages" type="integer" value="2" label="Maximum Missed Cleavages"
                            help="Allow peptides to contain up to this many missed enzyme cleavage sites."/>

                        <param name="specificity" type="select" label="Specificity">
                            <option value="0" selected="true">Specific at both termini</option>
                            <option value="1">Semi-Specific - one terminus</option>
                            <option value="2">Specific at the N-terminus only</option>
                            <option value="3">Specific at the C-terminus only</option>
                        </param>

                    </repeat>
                </when>
                <when value="1"/>
                <when value="2"/>
            </conditional>

            <param name="precursor_ion_tol_units" type="select" label="Precursor Ion Tolerance Units"
                help="Select based on instrument used, as different machines provide different quality of spectra. ppm is a standard for most precursor ions">
                <option value="1">Parts per million (ppm)</option>
                <option value="0">Daltons</option>
            </param>
            <param name="precursor_ion_tol" type="float" value="10" label="Precursor Ion Tolerance"
                help="Provide error value for precursor ion, based on instrument used. 10 ppm recommended for Orbitrap instrument"/>
            <param name="fragment_tol_units" type="select" label="Fragment Tolerance Units"
                help="Select based on instrument used, as different machines provide different quality of spectra. ppm is a standard for most precursor ions">
                <option value="1">Parts per million (ppm)</option>
                <option value="0" selected="true">Daltons</option>
            </param>
            <param name="fragment_tol" type="float" value="0.5" label="Fragment Tolerance"
                help="Provide error value for fragment ions, based on instrument used"/>
            <param name="min_charge" label="Minimum Charge" value="2" type="integer" help="Lowest searched charge value for fragment ions"/>
            <param name="max_charge" label="Maximum Charge" value="4" type="integer" help="Highest searched charge value for fragment ions"/>
            <param name="forward_ion" label="Forward Ion" type="select" help="Searched fragment ion type. Select a, b or c based on collisions induced in experiment">
                <option value="a">a</option>
                <option value="b" selected="true">b</option>
                <option value="c">c</option>
            </param>
            <param name="reverse_ion" label="Reverse Ion" type="select" help="Searched fragment ion type. Select x, y, or z based on collisions induced in experiment">
                <option value="x">x</option>
                <option value="y" selected="true">y</option>
                <option value="z">z</option>
            </param>
            <param name="min_isotope" label="Minimum precursor isotope" type="integer" value="0" help="default: 0" />
            <param name="max_isotope" label="Maximum precursor isotope" type="integer" value="1" help="default: 1" />
        </section>


        <!-- - SEARCH ENGINES OPTIONS -->

        <section name="searchengines_options" expanded="false" title="Search Engines Options">

            <!-- X!TANDEM ADVANCED PARAMETERS -->
            <conditional name="xtandem">
                <param name="xtandem_advanced" type="select" label="X!Tandem Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <!-- Spectrum Import -->
                    <conditional name="xtandem_spectrum">
                        <param name="xtandem_spectrum_selector" type="select" label="X!Tandem: Spectrum Import Related">
                            <option value="yes" selected="True">Set Spectrum Import Parameters</option>
                            <option value="no">Keep Default Spectrum Import Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                          <param name="xtandem_dynamic_range" help="Sets the dynamic range for scoring spectra"
                              label="X!Tandem: Dynamic Range" value="100" type="integer" />
                          <param name="xtandem_npeaks" type="integer" value="50"
                              label="X!Tandem: Total Peaks" help="Maximum number of peaks to be used from a spectrum"/>
                          <param name="xtandem_min_frag_mz" type="integer" value="200"
                              label="X!Tandem: Min Frag m/z" help="Fragment mass peaks with m/z less than this value will be discarded"/>
                          <param name="xtandem_min_peaks" type="integer" value="5"
                              label="X!Tandem: Min Peaks" help="Minimum number of peaks required for a spectrum to be considered"/>
                          <param name="xtandem_noise_suppr" type="boolean" checked="false" truevalue="1" falsevalue="0"
                              label="X!Tandem: Noise Suppression" help="Use noise suppression"/>
                          <param name="xtandem_min_prec_mass" type="integer" value="500"
                              label="X!Tandem: Min Precursor Mass" help="Minimum mass of 1+ mass of parent ion to be considered"/>
                          <param name="xtandem_parent_isotope_correction" type="boolean" checked="true" truevalue="1" falsevalue="0"
                              label="X!Tandem: Parent monoisotopic mass isotope error" help="when activated, the parent ion mass tolerance is expanded by opening up multiple tolerance windows centered on the first and second 13C isotope peaks for a peptide. "/>
                        </when>
                    </conditional>
                    <!-- Advanced search -->
                    <conditional name="xtandem_asearch">
                        <param name="xtandem_asearch_selector" type="select" label="X!Tandem: Advanced Search Related">
                            <option value="yes">Set Advanced Search Parameters</option>
                            <option value="no" selected="True">Keep Default Advanced Search Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="xtandem_quick_acetyl" help="Protein N-terminal modification detection"
                                label="X!Tandem: Quick Acetyl" type="boolean" truevalue="1" falsevalue="0" checked="true" />
                            <param name="xtandem_quick_pyro" help="Peptide N-terminus cyclization detection"
                                label="X!Tandem: Quick Pyrolidone" type="boolean" truevalue="1" falsevalue="0" checked="true" />
                            <param name="xtandem_stp_bias" help="Interpretation of peptide phosphorylation models"
                                label="X!Tandem: Protein stP Bias" type="boolean" truevalue="1" falsevalue="0" checked="false" />
                            <param name="xtandem_ptm_complexity" type="float" value="6.0" help="maximum number of variable modification alternatives that will be tested for a particular peptide"
                                 label="X!Tandem: PTM complexity" />
                       </when>
                   </conditional>
                    <!-- Output -->
                    <conditional name="xtandem_output">
                        <param name="xtandem_output_selector" type="select" label="X!Tandem: Output Related">
                            <option value="yes">Set Output Parameters</option>
                            <option value="no" selected="True">Keep Default Output Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <conditional name="xtandem_output_results_conditional">
                                <param name="xtandem_output_results_selector" type="select" label="" help="Determines which results are written to the output file at the end of a modelling session">
                                    <option value="all" selected="True">All</option>
                                    <option value="valid" >Valid</option>
                                    <option value="stochastic" >Stochastic</option>
                                </param>
                                <when value="all"/>
                                <when value="valid">
                                    <param name="xtandem_evalue" help="Highest value for recorded peptides"
                                        label="X!Tandem: Maximum Valid Expectation Value" type="float" value="0.01" />
                                </when>
                                <when value="stochastic">
                                    <param name="xtandem_evalue" help="Highest value for recorded peptides"
                                        label="X!Tandem: Maximum Valid Expectation Value" type="float" value="0.01" />
                                </when>
                            </conditional>

                            <param name="xtandem_output_proteins" help="Controls output of protein sequences"
                                label="X!Tandem: Output Proteins" type="boolean" truevalue="1" falsevalue="0" checked="true" />
                            <param name="xtandem_output_sequences" help="Controls output of sequence information"
                                label="X!Tandem: Output Sequences" type="boolean" truevalue="1" falsevalue="0" checked="false" />
                            <param name="xtandem_output_spectra" help="Controls output of spectrum information"
                                label="X!Tandem: Output Spectra" type="boolean" truevalue="1" falsevalue="0" checked="true" />
                            <param name="xtandem_output_histograms" help="Controls output of statistical information about an spectrum-to-sequence assignment"
                                label="X!Tandem: Output Histograms" type="boolean" truevalue="1" falsevalue="0" checked="false" />
                            <!-- TODO: Integration with Skyline not ready yet
                            <param name="xtandem_skyline_path" label="X!Tandem 'spectrum, skyline path'" type="txt" help="Path to a spectrum data file for use by skyline." -->
                        </when>
                    </conditional>

                    <!-- Refine -->
                    <conditional name="xtandem_refine">
                        <param name="xtandem_refine_selector" type="select" label="X!Tandem peptide model refinement">
                            <option value="no">Don't refine</option>
                            <option value="yes" selected="True">Use refinement</option>
                        </param>
                        <when value="no"/>
                        <when value="yes">
                            <param name="xtandem_refine_evalue" help="Highest value for recorded peptides during refinement"
                                label="X!Tandem: Maximum Valid Expectation Value, refinement" type="float" value="0.01" />
                            <param name="xtandem_refine_unc" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="X!Tandem: Unanticipated cleavage, refinement" help="Allow for unanticipated cleavage during refinement"/>
                            <param name="xtandem_refine_semi" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="X!Tandem: semi-enzymatic cleavage, refinement" help="Search for semi-tryptic peptides during refinement"/>
                            <param name="xtandem_refine_pot" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="X!Tandem: Use potential modifications for full refinement" help="Controls the use of refinement modifications in all refinement modules."/>
                            <param name="xtandem_refine_p_mut" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="X!Tandem: Point mutations, refinement" help="Allow for point mutations during refinement"/>
                            <param name="xtandem_refine_snaps" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="X!Tandem: snAPs, refinement" help="Search for known single amino acid polymorphisms during refinement"/>
                            <param name="xtandem_refine_spec_synt" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="X!Tandem: Spectrum synthesis, refinement" help="Use spectrum synthesis scoring"/>
                            <!-- TODO: Refinement modifications when implemented in the command line -->
                        </when>
                    </conditional>
                </when>
            </conditional>


            <!-- MyriMatch ADVANCED PARAMETERS -->
            <conditional name="myrimatch">
                <param name="myrimatch_advanced" type="select" label="MyriMatch Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="myrimatch_min_pep_length"  type="integer" value="6"
                        label="MyriMatch: Minimum Peptide Length" help="Minimum length for a peptide to be considered" />
                    <param name="myrimatch_max_pep_length"  type="integer" value="30"
                        label="MyriMatch: Maximum Peptide Length" help="Maximum length for a peptide to be considered" />
                    <param name="myrimatch_min_prec_mass"  type="float" value="0.0"
                        label="MyriMatch: Minimum Precursor Mass" help="Minimum precursor mass of parent ion to be considered" />
                    <param name="myrimatch_max_prec_mass"  type="float" value="5000.0"
                        label="MyriMatch: Maximum Precursor Mass" help="Maximum precursor mass of parent ion to be considered" />
                    <param name="myrimatch_num_matches"  type="integer" value="10"
                        label="MyriMatch: Maximum Number of Spectrum Matches" help="Set the value for the maximum number of spectrum matches" />
                    <param name="myrimatch_num_ptms"  type="integer" value="2"
                        label="MyriMatch: Max Variable PTMs per Peptide" help="Set the number of PTMS allowed per peptide" />

                    <!-- TODO : TO BE UPDATED WHEN CLI DOES. TO CONFIRM MANUAL OPTION FIRSTLY -->
                    <param name="myrimatch_fragmentation" label="MyriMatch: Fragmentation Method" type="select" help="Choose the fragmentation method used (CID: b,y) or (ETD: c, z*)">
                        <option value="CID" selected="True">CID</option>
                        <option value="HCD" >HCD</option>
                        <option value="ETD" >ETD</option>
                    </param>
                    <param name="myrimatch_termini" label="MyriMatch: Enzymatic Terminals" type="select" help="Select the number of enzymatic terminals">
                        <option value="0">non-tryptic</option>
                        <option value="1">semi-tryptic</option>
                        <option value="2" selected="True" >fully-tryptic</option>
                    </param>
                    <param name="myrimatch_plus_three"  type="boolean" truevalue="1" falsevalue="0" checked="true"
                        label="MyriMatch: Use Smart Plus Three Option" help="Defines what algorithms are used to generate a set of theoretical fragment ions" />
                    <param name="myrimatch_xcorr"  type="boolean" truevalue="1" falsevalue="0" checked="false"
                        label="MyriMatch: Compute Xcorr" help="a Sequest-like cross correlation score can be calculated for the top ranking hits" />
                    <param name="myrimatch_tic_cutoff"  type="float" value="0.98"
                        label="MyriMatch: TIC cutoff percentage" help="Cumulative ion current of picked peaks divided by TIC >= this value for peaks to be retained (0.0 - 1.0)" />
                    <param name="myrimatch_intensity_classes"  type="integer" value="3"
                        label="MyriMatch: Number of Intensity Classes" help="Experimental spectra have their peaks stratified into this number of intensity classed" />
                    <param name="myrimatch_class_multiplier"  type="integer" value="2"
                        label="MyriMatch: Class Size Multiplier" help="Has to do with previous option, this parameter controls the size of each class relative to the class above" />
                    <param name="myrimatch_num_batches"  type="integer" value="50"
                        label="MyriMatch: Number of Batches" help="The number of batches per node to strive for when usinge the MPI-based parallelization features" />
                    <param name="myrimatch_max_peak"  type="integer" value="100"
                        label="MyriMatch: Maximum Peak Count" help="Maximum number of peaks to be used from a spectrum" />
                    <param name="myrimatch_output" type="select" label="MyriMatch: output format option">
                        <option value="mzIdentML" selected="True" >mzIdentML</option>
                        <option value="pepXML">pepXML</option>
                    </param>
                </when>
            </conditional>

            <!-- MS-GF+ ADVANCED PARAMETERS -->
            <conditional name="msgf">
                <param name="msgf_advanced" type="select" label="MSGF Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="msgf_decoy" type="boolean" truevalue="1" falsevalue="0" checked="false"
                        label="MSGF: Search Decoy Database" help="If yes then a decoy database will be generated and searched. Assumed input database contains no decoys"/>
                    <param name="msgf_instrument" label="MSGF: MS/MS Detector" type="select" help="Identifier of the instrument to generate MS/MS spectra (used to determine the scoring model)">
                        <option value="0" >Low-res LCQ/LTQ</option>
                        <option value="1" >Orbitrap/FTICR</option>
                        <option value="2" >TOF</option>
                        <option value="3" selected="True">Q-Exactive</option>
                    </param>
                    <param name="msgf_fragmentation" label="MSGF: Fragmentation method" type="select" help="Fragmentation method identifier (used to determine the scoring model)">
                        <option value="0" >As written in the spectrum or CID if no info</option>
                        <option value="1" >CID</option>
                        <option value="2" >ETD</option>
                        <option value="3" selected="True">HCD</option>
                        <option value="4" >UVPD</option>
                    </param>
                    <param name="msgf_protocol" label="MSGF: Protocol" type="select" help="Protocol identifier. Protocols are used to enable scoring parameters for enriched and/or labeled samples">
                        <option value="0" selected="True">Automatic</option>
                        <option value="1" >Phosphorylation</option>
                        <option value="2" >iTRAQ</option>
                        <option value="3" >iTRAQPhospho</option>
                        <option value="4" >TMT</option>
                        <option value="5" >Standard</option>
                    </param>
                    <param name="msgf_termini" type="select" format="txt"
                        label="MSGF: Enzymatic Terminals" help="Searches will take much longer if selecting a value other than 2">
                        <option value="0">None required</option>
                        <option value="1">At least one</option>
                        <option value="2" selected="true">Both</option>
                    </param>
                    <param name="msgf_min_pep_length" type="integer" value="8"
                        label="MSGF: Minimum Peptide Length" help="Minimum length for a peptide to be considered"/>
                    <param name="msgf_max_pep_length" type="integer" value="30"
                        label="MSGF: Maximum Peptide Length" help="Maximum length for a peptide to be considered"/>
                    <param name="msgf_num_ptms" label="MSGF: Max Variable PTMs per Peptide" type="integer" value="2"/>
                    <param name="msgf_num_matches" label="MSGF: Number of Spectrum Matches" type="integer" value="10" help="Number of peptide matches per spectrum to report" />
                    <param name="msgf_additional" label="MS-GF+ additional Output" type="select" help="Additional features to export">
                        <option value="0" selected="True">output basic scores only</option>
                        <option value="1" >output additional features</option>
                    </param>
                    <conditional name="msgf_tasks">
                        <param name="msgf_tasks_custom" type="select" label="Number of tasks to use on the threads">
                            <option value="yes">Custom</option>
                            <option value="no" selected="True">Default</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="msgf_num_tasks" type="integer" value="4"
                                label="MSGF: Custom number of tasks to use on the threads"
                                help="Manually set the number of tasks to create for the search. More tasks than threads will reduce the memory requirements of the search, but will be slower (how much depends on the inputs). Check the documentation carefully. "/>
                        </when>
                    </conditional>
                </when>
            </conditional>

              <!-- MS-AMANDA ADVANCED PARAMETERS  -->
            <conditional name="ms_amanda">
                <param name="ms_amanda_advanced" type="select" label="MS Amanda Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="ms_amanda_decoy"  type="boolean" truevalue="1" falsevalue="0" checked="false"
                        label="MS Amanda: Generate Decoys" help="generate decoys" />
                    <param name="ms_amanda_instrument" label="MS Amanda: instrument" type="select"
                      help="MS Amanda instrument id option. Available ion types are listed here.">

                      <option value="b, y" selected="True">b, y</option>
                      <option value="b, y, -H2O, -NH3" >b, y, -H2O, -NH3</option>
                      <option value="a, b, y, -H2O, -NH3, Imm" >a, b, y, -H2O, -NH3, Imm</option>
                      <option value="a, b, y, -H2O, -NH3" >a, b, y, -H2O, -NH3</option>
                      <option value="a, b, y" >a, b, y</option>
                      <option value="a, b, y, Imm" >a, b, y, Imm</option>
                      <option value="a, b, y, z, -H2O, -NH3, Imm" >a, b, y, z, -H2O, -NH3, Imm</option>
                      <option value="c, y, z+1, z+2" >c, y, z+1, z+2</option>
                      <option value="b, c, y, z+1, z+2" >b, c, y, z+1, z+2</option>
                      <option value="b, y, INT" >b, y, INT</option>
                      <option value="b, y, INT, Imm" >b, y, INT, Imm</option>
                      <option value="a, b, y, INT" >a, b, y, INT</option>
                      <option value="a, b, y, INT, IMM" >a, b, y, INT, IMM</option>
                      <option value="a, b, y, INT, IMM, -H2O" >a, b, y, INT, IMM, -H2O</option>
                      <option value="a, b, y, INT, IMM, -H2O, -NH3" >a, b, y, INT, IMM, -H2O, -NH3</option>
                      <option value="a, b, y, INT, IMM, -NH3" >a, b, y, INT, IMM, -NH3</option>

                    </param>
                    <param name="ms_amanda_max_rank" type="integer" value="10"
                        label="MS Amanda: Maximum Rank" help="MS Amanda maximum rank" />
                    <param name="ms_amanda_mono" type="boolean" truevalue="1" falsevalue="0" checked="true"
                        label="MS Amanda: Use Monoisotopic Mass Values" help="MS Amanda use monoisotopic mass values" />
                </when>
            </conditional>

            <!-- OMSSA ADVANCED PARAMETERS -->
            <conditional name="omssa">
                <param name="omssa_advanced" type="select" label="OMSSA Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <!-- Spectrum -->
                    <conditional name="omssa_spectrum">
                        <param name="omssa_spectrum_selector" type="select" label="OMSSA: Spectrum Related">
                            <option value="yes" selected="True">Set Spectrum Parameters</option>
                            <option value="no">Keep Default Spectrum Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="omssa_low_intensity" type="float" value="0.0"
                                label="OMSSA: Low Intensity Cutoff" help="Low intensity cutoff as a fraction of max peak" />
                            <param name="omssa_high_intensity" type="float" value="0.2"
                                label="OMSSA: High Intensity Cutoff" help="High intensity cutoff as a fraction of max peak" />
                            <param name="omssa_intensity_incr" type="float" value="0.0005"
                                label="OMSSA: Intensity Increment" help="Intensity increment" />
                            <param name="omssa_min_peaks" type="integer" value="4"
                                label="OMSSA: Minimum Peak Count" help="The minimum number of m/z values a spectrum must have to be searched" />
                            <param name="omssa_remove_prec" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="OMSSA: Remove precursors" help="Eliminate charge reduced precursors in spectra" />
                            <param name="omssa_estimate_charge" type="select"
                                label="OMSSA: Estimate charge" help="estimate precursor charge" >
                                <option value="0" >Believe input file</option>
                                <option value="1" selected="True">Use range</option>
                            </param>
                            <param name="omssa_plus_one" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="OMSSA: Estimate Plus One Charge" help="Allow OMSSA to estimate plus one charge algorithmically"/>
                            <param name="omssa_fraction" type="float" value="0.95"
                                label="OMSSA: Fraction of Peaks to estimate Charge 1" help="fraction of peaks to estimate charge 1" />
                            <param name="omssa_prec_per_spectrum" type="integer" value="1"
                                label="OMSSA: Minimum Number of Precursors per Spectrum" help="Minimum number of precursors per spectrum" />
                            <param name="omssa_scale_prec" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="OMSSA: Scale Precursor Mass" help="scale precursor mass" />
                        </when>
                    </conditional>
                    <!-- Database -->
                    <conditional name="omssa_database">
                        <param name="omssa_database_selector" type="select" label="OMSSA: Database Related">
                            <option value="yes" >Set Database Parameters</option>
                            <option value="no" selected="True">Keep Default Database Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="omssa_memory" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="OMSSA: Map Sequences in Memory" help="Use memory mapped sequence libraries" />
                            <param name="omssa_methionine" type="boolean" truevalue="1" falsevalue="0" checked="true"
                             label="OMSSA: Cleave n-term Methionine" help="Allow for N-terminal methionine cleavage" />
                        </when>
                    </conditional>
                    <!-- Search -->
                    <conditional name="omssa_search">
                        <param name="omssa_search_selector" type="select" label="OMSSA: Search Related">
                            <option value="yes">Set Search Parameters</option>
                            <option value="no" selected="True">Keep Default Search Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <!-- TODO: TO BE IMPLEMENTED IN THE CLI, MINIMUM PRECURSOR CHARGE FOR MULTIPLY CHARGED FRAGMENTS -->
                            <param name="omssa_neutron" type="float" value="1446.94"
                                   label="OMSSA: Neutron Mass" help="Mass after which OMSSA should consider neutron exact mass" />
                            <param name="omssa_single_window_wd" type="integer" value="27"
                                label="OMSSA: Single Charge Window Width" help="Single charge window width in Da (integer)" />
                            <param name="omssa_double_window_wd" type="integer" value="14"
                                label="OMSSA: Double Charge Window Width" help="OMSSA double charge window width in Da (integer)" />
                            <param name="omssa_single_window_pk" type="integer" value="2"
                                label="OMSSA: Single Charge Window Peaks" help="Minimum number of peaks in single charge window (integer)" />
                            <param name="omssa_double_window_pk" type="integer" value="2"
                                label="OMSSA: Double Charge Window Peaks" help="Minimum number of peaks in double charge window (integer)" />
                            <param name="omssa_min_ann_int_pks" type="integer" value="6"
                                label="OMSSA: Minimum Number of Annotated Peaks of Intense Ones" help="Minimum number of annotated peaks among the most intense ones" />
                            <param name="omssa_min_annotated_peaks" type="integer" value="2"
                                label="OMSSA: Minimum number of Annotated Peaks" help="Minimum number of annotated peaks" />
                            <param name="omssa_max_ladders" type="integer" value="128"
                                label="OMSSA: Maximum Number of m/z Ladders" help="The maximum number of mass ladders to generate per database peptide" />
                            <param name="omssa_max_frag_charge" type="integer" value="2"
                                label="OMSSA: Maximum Fragment Charge" help="Maximum fragment charge" />
                            <param name="omssa_charge" type="select"
                                label="OMSSA: Fragment Charge" help="OMSSA fragment charge option" >
                                <option value="0" >Minus</option>
                                <option value="1" selected="True">Plus</option>
                            </param>
                            <param name="omssa_forward" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="OMSSA: Include First Forward Ion (b1) in Search" help="Allow OMSSA to include first forward ion (b1) in search" />
                            <param name="omssa_rewind" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="OMSSA: Search Rewind" help="Allow search rewind (C-terminal) ions" />
                            <param name="omssa_max_frag_series" type="integer" value="100"
                                label="OMSSA: Maximum Fragment per Series" help="Max number of fragments ions ions in each series being searched" />
                            <param name="omssa_corr" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="OMSSA: Use Correlation Correction" help="Allow the use correlation correction score" />
                            <param name="omssa_consecutive_p" type="float" value="0.5"
                                label="OMSSA: Consecutive Ion Probability" help="Probability of consecutive ion (used in correlation correction)" />
                            <param name="omssa_hitlist_charge" type="integer" value="30"
                                label="OMSSA: Number of Hits per Spectrum per Charge" help="number of hits per spectrum per charge" />
                        </when>
                    </conditional>
                    <!-- Iterative Search -->
                    <conditional name="omssa_isearch">
                        <param name="omssa_isearch_selector" type="select" label="OMSSA: Iterative Search Related">
                            <option value="yes" >Set Iterative Search Parameters</option>
                            <option value="no" selected="True">Keep Default Iterative Search Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="omssa_it_sequence_evalue" type="float" value="0.0"
                                label="OMSSA: Sequence e-value Cutoff" help="The maximum e-value allowed to consider a sequence in the iterative search(0.0 means all)" />
                            <param name="omssa_it_spectrum_evalue" type="float" value="0.01"
                                label="OMSSA: Spectrum e-value Cutoff" help="The maximum e-value allowed to consider a spectrum in the iterative search(0.0 means all)" />
                            <param name="omssa_it_replace_evalue" type="float" value="0.0"
                                label="OMSSA: Replace e-value cutoff" help="The maximum e-value allowed to replace a hit in the iterative search (0.0 means all)" />
                        </when>
                    </conditional>

                    <!-- Semi-enzymatic -->
                    <conditional name="omssa_senzymatic">
                        <param name="omssa_senzymatic_selector" type="select" label="OMSSA: Semi-enzymatic Related">
                            <option value="yes" >Set Semi-enzymatic Parameters</option>
                            <option value="no" selected="True">Keep Default Semi-enzymatic Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="omssa_min_pep_length" type="integer" value="8"
                                label="OMSSA: Minimum Peptide Length" help="Minimum length of peptides for no-enzyme and semi-tryptic searches" />
                            <param name="omssa_max_pep_length" type="integer" value="30"
                                label="OMSSA: Maximum Peptide Length" help="Maximum length of peptides for no-enzyme and semi-tryptic searches (0: none)" />
                        </when>
                    </conditional>

                    <!-- Output -->
                    <conditional name="omssa_output_conditional">
                        <param name="omssa_output_conditional_selector" type="select" label="OMSSA: Output Related">
                            <option value="yes">Set Output Parameters</option>
                            <option value="no" selected="True">Keep Default Output Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="omssa_max_evalue" type="float" value="100"
                                label="OMSSA: Maximal evalue Considered" help="The maximum e-value considered" />
                            <param name="omssa_hitlist_length" type="integer" value="10"
                                label="OMSSA: Hitlist Length" help="OMSSA hitlist length, 0 means all" />
                            <param name="omssa_format" label="OMSSA output format" type="select" >
                                <option value="0" selected="True">OMX</option>
                                <option value="1" >CSV</option>
                                <option value="2" >pepXML</option>
                            </param>
                        </when>
                    </conditional>

                </when>
            </conditional>


            <!-- Comet ADVANCED PARAMETERS -->
            <conditional name="comet">
                <param name="comet_advanced" type="select" label="Comet Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <!-- Spectrum Related parameters -->
                    <conditional name="comet_spectrum">
                        <param name="comet_spectrum_selector" type="select" label="Comet: Spectrum Related">
                            <option value="yes"  selected="True">Set Spectrum Parameters</option>
                            <option value="no">Keep Default Spectrum Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="comet_min_peaks"  type="integer" value="10"
                                label="Comet: Minimum Number of Peaks per Spectrum" help="The minimum number of peaks per spectrum" />
                            <param name="comet_min_peak_int"  type="float" value="0.0"
                                label="Comet: Minimum Peaks Intensity" help="The minimum intensity for input peaks to be considered" />
                            <conditional name="comet_prec">
                                <param name="comet_remove_prec" label="Comet: Remove Precursor peaks" type="select" help="Select for precursor m/z signal removal">
                                    <option value="0" selected="True" >no</option>
                                    <option value="1">yes</option>
                                    <option value="2">yes + charge reduced</option>
                                    <option value="3">yes + phospate neutral</option>
                                </param>
                                <when value="0" />
                                <when value="1">
                                    <param name="comet_remove_prec_tol"  type="float" value="1.5"
                                        label="Comet: Remove Precursor Tolerance" />
                                </when>
                                <when value="2">
                                    <param name="comet_remove_prec_tol"  type="float" value="1.5"
                                        label="Comet: Remove Precursor Tolerance" />
                                </when>
                                <when value="3">
                                    <param name="comet_remove_prec_tol"  type="float" value="1.5"
                                        label="Comet: Remove Precursor Tolerance" />
                                </when>
                            </conditional>
                            <param name="comet_clear_mz_range_lower"  type="float" value="0.0"
                                label="Comet: Minimum Peaks Intensity" help="Intended for iTRAQ/TMT type data where one might want to remove the reporter ion signals, lower m/z range" />
                            <param name="comet_clear_mz_range_upper"  type="float" value="0.0"
                                label="Comet: Maximum Peaks Intensity" help="Intended for iTRAQ/TMT type data where one might want to remove the reporter ion signals, upper m/z range" />
                        </when>
                    </conditional>
                      <!-- Search Related parameters -->
                    <conditional name="comet_search">
                        <param name="comet_search_selector" type="select" label="Comet: Search Related">
                            <option value="yes">Set Search Parameters</option>
                            <option value="no" selected="True">Keep Default Search Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="comet_enzyme_type" label="Comet: Enzyme Type" type="select" help="Specifies the number of enzyme termini a peptide must have">
                                <option value="1">semi-specific</option>
                                <option value="2" selected="True">full-enzyme</option>
                                <option value="8">unspecific N-term</option>
                                <option value="9">unspecific C-term</option>
                            </param>
                            <param name="comet_isotope_correction" label="Comet: Isotope Correction" type="select" help="Controls whether the peptide_mass_tolerance takes into account possible isotope errors in the precursor mass measurement">
                                <option value="0">off</option>
                                <option value="1">0,+1</option>
                                <option value="2">0,+1,+2</option>
                                <option value="3" selected="True">0,+1,+2,+3</option>
                                <option value="4">-8,-4,0,+4,+8</option>
                            </param>
                            <param name="comet_min_prec_mass"  type="float" value="600.0"
                                label="Comet: Minimum Precursor Mass" help="The minimum precursor mass considered" />
                            <param name="comet_max_prec_mass"  type="float" value="5000.0"
                                label="Comet: Maximum Precursor Mass" help="The maximum precursor mass considered" />
                            <param name="comet_max_frag_charge"  type="integer" value="3"
                                label="Comet: Maximum Fragment Charge" help="Sets the maximum fragment charge (fill value between 1 and 5)" />
                            <param name="comet_remove_meth"  type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="Comet: Remove Methionine" help="Specifies whether the N-terminal methionine is cleaved prior to matching" />
                            <param name="comet_batch_size"  type="integer" value="0"
                                label="Comet: Batch Size" help="0 means load and search all spectra at once, otherwise spectra are loaded and searched in batches of the number specified" />
                            <param name="comet_num_ptms"  type="integer" value="10"
                                label="Comet: Maximum Number of PTMs" help="The maximum number of ptms per peptide" />
                            <param name="comet_req_ptms" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="Comet: Require Variable PTMs" help="Require at least one variable PTM per peptide" />
                        </when>
                    </conditional>
                    <!-- Fragment Ions Related parameters -->
                    <conditional name="comet_fragment_ions">
                        <param name="comet_fragment_ions_selector" type="select" label="Comet: Fragment Ions Related">
                            <option value="yes">Set Fragment Ions Parameters</option>
                            <option value="no" selected="True">Keep Default Fragment Ions Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="comet_theoretical_fragment_ions" type="select"
                                label="Comet: Correlation Score type" help="Specifies how theoretical fragment ion peaks are represented (on the sum in the bin alone or using flanking bins too)">
                                <option value="0" selected="True">Summed intensities + flanking</option>
                                <option value="1">Summed intensities</option>
                            </param>
                            <param name="comet_frag_bin_offset"  type="float" value="0"
                                label="Comet: Fragment Bin Offset" help="Controls how each fragment bin is defined in terms of where each bin starts" />
                        </when>
                    </conditional>
                    <!-- Output Related parameters -->
                    <conditional name="comet_output">
                        <param name="comet_output_selector" type="select" label="Comet: Output Related">
                            <option value="yes">Set Output Parameters</option>
                            <option value="no" selected="True">Keep Default Output Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="comet_num_matches"  type="integer" value="10"
                                label="Comet: Maximum Number of Matches" help="The maximum number of peptide matches per spectrum" />
                            <param name="comet_output_type" type="select"
                                label="Comet: Output type" help="Output type: PepXML, SQT, TXT or Percolator">
                                <option value="PepXML" selected="True">PepXML</option>
                                <option value="SQT">SQT</option>
                                <option value="TXT">TXT</option>
                                <option value="Percolator">Percolator</option>
                            </param>
                        </when>
                    </conditional>
                </when>
            </conditional>

            <!-- TIDE ADVANCED PARAMETERS -->
            <conditional name="tide">
                <param name="tide_advanced" type="select" label="TIDE Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <!-- Index parameters -->
                    <conditional name="tide_index">
                        <param name="tide_index_selector" type="select" label="Tide: Index Related">
                            <option value="yes" selected="True">Set Index Parameters</option>
                            <option value="no" >Keep Default Index Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="tide_min_pep_length" type="integer" value="6"
                                label="TIDE: Minimum Peptide Length" help="Set the minimum length of peptide to be considered"/>
                            <param name="tide_max_pep_length" type="integer" value="30"
                                label="TIDE: Maximum Peptide Length" help="Set the maximum length of peptide to be considered"/>
                            <param name="tide_min_prec_mass" type="float" value="200.0"
                                label="TIDE: Minimum Precursor Mass" help="Set the minimum precursor mass to be considered"/>
                            <param name="tide_max_prec_mass" type="float" value="7200.0"
                                label="TIDE: Maximum Precursor Mass" help="Set the maximum precursor mass to be considered"/>
                            <param name="tide_monoisotopic" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="TIDE: Monoisotopic" help="If true, the precursor mass is monoisotopic"/>
                            <param name="tide_clip_n_term" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Clip Nterm Methionine" help="If true, the Nterm Methionine will be clipped"/>
                            <param name="tide_num_ptms" type="integer" value="" optional="true"
                                label="TIDE: Maximum Number of PTMs" help="Set the maximum number of PTMs on peptide to be considered"/>
                            <param name="tide_num_ptms_per_type" type="integer" value="2"
                                label="TIDE: Maximum Number of PTMs of each Type" help="Set the maximum number of PTMs of each type to be considered"/>
                            <param name="tide_digestion_type" label="TIDE: Enzyme/Digestion Type" type="select" help="Either both ends (full-digest) or at least one end (partial-digest) of a peptide must conform to enzyme specificity rules">
                                <option value="full-digest" selected="True">full-digest</option>
                                <option value="partial-digest" >partial-digest</option>
                            </param>
                            <param name="tide_print_peptides" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Print Peptides" help="If true, the peptides will be printed in the output"/>
                            <param name="tide_decoy_format" label="TIDE: Decoy Format" type="select" help="Select the format for generating the decoy sequences">
                                <option value="none" selected="True">none</option>
                                <option value="shuffle" >shuffle</option>
                                <option value="peptide-revers" >peptide-reverse</option>
                                <option value="protein-reverse" >protein-reverse</option>
                            </param>
                            <param name="tide_keep_terminals" label="TIDE: Keep Terminals" type="select" help="Select to keep the terminal amino acids when creating decoys">
                                <option value="N" >N</option>
                                <option value="C" >C</option>
                                <option value="NC" selected="True">NC</option>
                                <option value="non" >none</option>
                            </param>
                            <param name="tide_decoy_seed" type="integer" value="1"
                                label="TIDE: Decoy Seed" help="Set the decoy seed"/>
                            <param name="tide_remove_temp" type="boolean" truevalue="1" falsevalue="0" checked="true"
                                label="TIDE: Remove Temp Folders" help="If true, the temp folders are removed when the search is done."/>
                        </when>
                    </conditional>

                    <!-- Search parameters -->
                    <conditional name="tide_search">
                        <param name="tide_search_selector" type="select" label="Tide: Search Related">
                            <option value="yes">Set Search Parameters</option>
                            <option value="no" selected="True">Keep Default Search Parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="tide_compute_p" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Compute Exact P-value" help="If true, the exact p-values are calculated"/>
                            <param name="tide_compute_sp" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Compute SP" help="If true, the SP-score is calculated"/>
                            <param name="tide_min_spectrum_mz" type="float" value="0.0"
                                label="TIDE: Minimum Spectrum m/z" help="Set the minimum spectrum m/z value for a spectrum to be considered"/>
                            <param name="tide_max_spectrum_mz" type="float" value="" optional="true"
                                label="TIDE: Maximum Spectrum m/z" help="Set the maximum spectrum m/z value for a spectrum to be considered"/>
                            <param name="tide_min_spectrum_peaks" type="integer" value="20"
                                label="TIDE: Minimum Spectrum Peaks" help="Set the minimum amount of peaks in a spectrum for it to be considered"/>
                            <param name="tide_spectrum_charges" label="TIDE: Spectrum Charges" type="select" help="Select what precursor charges should be taken into account for matching">
                                <option value="1" >1</option>
                                <option value="2" >2</option>
                                <option value="3" >3</option>
                                <option value="all" selected="True">all</option>
                            </param>
                            <param name="tide_remove_prec" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Remove Precursor Peak" help="If true, the peak that corresponds to the precursor mass is excluded"/>
                            <param name="tide_remove_prec_tol" type="float" value="1.5"
                                label="TIDE: Remove Precursor Tolerance" help="Choose the threshold for precursor mass searching (for precursor peak removal)"/>
                            <param name="tide_use_flanking" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Use Flanking" help="Includes two flanking peaks on either side of each b- and y-ion to compute the XCorr"/>
                            <param name="tide_use_neutral_losses" type="boolean" truevalue="1" falsevalue="0" checked="false"
                                label="TIDE: Neutral Losses" help="Includes fragment peaks with neutral losses to perform the matching"/>
                            <param name="tide_mz_bin_width" type="float" value="0.02"
                                label="TIDE: mz Bin Width" help="Choose bin size to analyze the fragmentation spectrum"/>
                            <param name="tide_mz_bin_offset" type="float" value="0.0"
                                label="TIDE: mz Bin Offset" help="Choose bin offset to analyze the fragmentation spectrum"/>
                            <param name="tide_max_psms" type="integer" value="10"
                                label="TIDE: Maximum Number of PSMs" help="Set the maximum number of PSMs to be considered"/>
                            <param name="tide_export" label="TIDE: Output Format" type="select" multiple="true"
                              display="checkboxes" help="Choose the output format">
                                <option value="tide_export_text" selected="True">Text</option>
                                <option value="tide_export_sqt" >SQT</option>
                                <option value="tide_export_pepxml" >pepxml</option>
                                <option value="tide_export_mzid" >MzIdentML</option>
                                <option value="tide_export_pin" >Percolator input file</option>
                            </param>
                        </when>
                    </conditional>

                    <!-- other options -->
                    <param name="tide_output_folder" type="text" value="crux-output"
                        label="TIDE: Output Folder" help="Tide output folder (relative to the Tide working folder). Not to be changed if the .par file will be used by SearchGUI in Galaxy"/>
                    <param name="tide_verbosity" label="TIDE: Progress Display Verbosity" type="select" help="Select the display verbosity level to report the search progress">
                        <option value="0" >0</option>
                        <option value="10" >10</option>
                        <option value="20" >20</option>
                        <option value="30" selected="True">30</option>
                        <option value="40" >40</option>
                        <option value="50" >50</option>
                        <option value="60" >60</option>
                    </param>
                    <param name="tide_progress_indicator" type="integer" value="1000"
                        label="TIDE: Progress Indicator" help="Choose the progress indicator frequency  (in number of fragmentation spectra processed)"/>
                    <param name="tide_concat" type="boolean" truevalue="1" falsevalue="0" checked="false"
                        label="TIDE: Concat Target and Decoy" help="If true, the target results are concatenated with the decoy results"/>
                    <param name="tide_store_spectra" type="text" value=""
                        label="TIDE: Store spectra" help="Tide file name in with to store the binary spectra. Not to be changed if the .par file will be used by SearchGUI in Galaxy"/>
                </when>
            </conditional>

            <!-- Andromeda ADVANCED PARAMETERS -->
            <!-- Windows only
            <conditional name="andromeda">
                <param name="andromeda_advanced" type="select" label="Andromeda Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="andromeda_max_pep_mass" type="float" value="4600.0" label="Andromeda maximum peptide mass, default is: 4600.0" />
                    <param name="andromeda_max_comb" type="integer" value="250" label="Andromeda maximum combinations, default is: 250" />
                    <param name="andromeda_top_peaks" type="integer" value="8" label="Andromeda number of top peaks, default is: 8" />
                    <param name="andromeda_top_peaks_window" type="integer" value="100" label="Andromeda top peaks window width, default is: 100" />
                    <param name="andromeda_incl_water" type="boolean" truevalue="1" falsevalue="0" checked="true" label="Andromeda account for water losses, default is: true" />
                    <param name="andromeda_incl_ammonia" type="boolean" truevalue="1" falsevalue="0" checked="true" label="Andromeda account for ammonina losses, default is: true" />
                    <param name="andromeda_neutral_losses" type="boolean" truevalue="1" falsevalue="0" checked="true" label="Andromeda neutral losses are sequence dependent, default is: true" />
                    <param name="andromeda_fragment_all" type="boolean" truevalue="1" falsevalue="0" checked="false" label="Andromeda fragment all option, default is: false" />
                    <param name="andromeda_emp_correction" type="boolean" truevalue="1" falsevalue="0" checked="true" label="Andromeda emperical correction, default is: true" />
                    <param name="andromeda_higher_charge" type="boolean" truevalue="1" falsevalue="0" checked="true" label="Andromeda higher charge option, default is: true" />
                    <param name="andromeda_equal_il" type="boolean" truevalue="1" falsevalue="0" checked="false" label="Andromeda whether I and L should be considered indistinguishable, default is: false" />
                    <param name="andromeda_frag_method" type="select" value="" label="Andromeda fragmentation method, (HCD, CID or EDT), default is: CID." >
                       <option value="CID" selected="true">CID</option>
                       <option value="HCD">HCD</option>
                       <option value="EDT">EDT</option>
                    </param>
                    <param name="andromeda_max_mods" type="integer" value="5" label="Andromeda maximum number of modifications, default is: 5" />
                    <param name="andromeda_min_pep_length" type="integer" value="8" label="Andromeda minimum peptide length when using no enzyme, default is: 8" />
                    <param name="andromeda_max_pep_length" type="integer" value="25" label="Andromeda maximum peptide length when using no enzyme, default is: 25" />
                    <param name="andromeda_max_psms" type="integer" value="10" label="Andromeda maximum number of spectrum matches spectrum, default is: 10" />
                    <param name="andromeda_decoy_mode" type="boolean" truevalue="decoy" falsevalue="none" checked="false" label="Andromeda decoy mode" />
                </when>
            </conditional>
            -->

            <!-- DIRECTAG ADVANDED PARAMETERS-->
            <conditional name="directtag">
                <param name="directtag_advanced" type="select" label="DirectTag Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="directag_tag_length" type="integer" value="4" label="DirecTag tag length"/>
                    <param name="directag_max_var_mods" type="integer" value="2" label="DirecTag maximum variable modifications per sequence"/>
                    <param name="directag_charge_states" type="integer" value="3" label="DirecTag number of charge states considered"/>
                    <param name="directag_duplicate_spectra" type="boolean" truevalue="1" falsevalue="0" checked="true" label="DirecTag duplicate spectra per charge"/>
                    <param name="directag_isotope_tolerance" type="float" value="0.25" label="DirecTag isotope mz tolerance"/>
                    <param name="directag_deisotoping" type="select" label="DirecTag deisotoping mode">
                        <option value="0" selected="true">no deisotoping</option>
                        <option value="1">precursor only</option>
                        <option value="2">precursor and candidate</option>
                    </param>
                    <param name="directag_intensity_classes" type="integer" value="3" label="DirecTag number of intensity classses."/>
                    <param name="directag_output_suffix" type="text" value="" label="DirecTag output suffix"/>
                    <param name="directag_max_peak_count" type="integer" value="100" label="DirecTag max peak count"/>
                    <param name="directag_max_tag_count" type="integer" value="10" label="DirecTag maximum tag count"/>
                    <param name="directag_tic_cutoff" type="integer" value="100" label="DirecTag TIC cutoff in percent">
                        <validator type="in_range" min="0" max="100" />
                    </param>
                    <param name="directag_complement_tolerance" type="float" value="0.1" label="DirecTag complement mz tolerance"/>
                    <param name="directag_adjustment_step" type="float" value="0.1" label="DirecTag precursor adjustment step"/>
                    <param name="directag_min_adjustment" type="float" value="-0.5" label="DirecTag minimum precursor adjustment"/>
                    <param name="directag_max_adjustment" type="float" value="1.5" label="DirecTag maximum precursor adjustment"/>
                    <param name="directag_intensity_weight" type="float" value="1.0" label="DirecTag intensity score weight"/>
                    <param name="directag_fidelity_weight" type="float" value="1.0" label="DirecTag fidelity score weight"/>
                    <param name="directag_complement_weight" type="float" value="1.0" label="DirecTag complement_score_weight"/>
                    <param name="directag_adjust_precursor" type="boolean" truevalue="1" falsevalue="0" checked="false" label="DirecTag adjust precursor"/>
                    <param name="directag_ms_charge_state" type="boolean" truevalue="1" falsevalue="0" checked="true" label="DirecTag use charge state from M spectrum"/>
                </when>
            </conditional>


            <!-- METAMORPHEUS ADVANDED PARAMETERS-->
            <conditional name="metamorpheus">
                <param name="metamorpheus_advanced" type="select" label="MetaMorpheus Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <conditional name="metamorpheus_search">
                        <param name="metamorpheus_search_selector" type="select" label="MetaMorpheus: Search related options">
                            <option value="yes" selected="True">Set Search parameters</option>
                            <option value="no">Keep Default Search parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_search_type" type="select" label="MetaMorpheus search type">
                                <option value="Classic" selected="true">Classic</option>
                                <option value="Modern">Modern</option>
                                <option value="NonSpecific">NonSpecific</option>
                            </param>
                            <param name="meta_morpheus_num_partitions" type="integer" value="1" label="MetaMorpheus number of partitions when indexing"/>
                            <param name="meta_morpheus_dissociation_type" type="select" label="MetaMorpheus dissociation type">
                                <option value="HCD" selected="true">HCD</option>
                                <option value="CID">CID</option>
                                <option value="ECD">ECD</option>
                                <option value="ETD">ETD</option>
                            </param>
                            <param name="meta_morpheus_max_mods_for_peptide" type="integer" value="2" label="MetaMorpheus maximum modifications per peptide"/>
                            <param name="meta_morpheus_meth" type="select" label="MetaMorpheus initiator methionine behavior">
                                <option value="Undefined" >Undefined</option>
                                <option value="Retain">Retain</option>
                                <option value="Cleave">Cleave</option>
                                <option value="Variable" selected="true">Variable</option>
                            </param>
                            <param name="meta_morpheus_score_cutoff" type="float" value="5.0" label="MetaMorpheus score cutoff"/>
                            <param name="meta_morpheus_use_delta_score" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus use delta score"/>
                            <param name="meta_morpheus_mass_diff_acceptor_type" type="select" label="MetaMorpheus mass difference acceptor type">
                                <option value="Exact">Exact</option>
                                <option value="OneMM" selected="true">OneMM</option>
                                <option value="TwoMM">TwoMM</option>
                                <option value="ThreeMM" >ThreeMM</option>
                                <option value="PlusOrMinusThreeMM">PlusOrMinusThreeMM</option>
                                <option value="ModOpen">ModOpen</option>
                                <option value="Open">Open</option>
                            </param>
                            <param name="meta_morpheus_min_pep_length" type="integer" value="8"
                                label="MetaMorpheus minimum peptide length" help="Minimum length for a peptide to be considered"/>
                            <param name="meta_morpheus_max_pep_length" type="integer" value="30"
                                label="MetaMorpheus maximum peptide length" help="Maximum length for a peptide to be considered"/>
                        </when>
                    </conditional>

                    <conditional name="metamorpheus_output">
                        <param name="metamorpheus_output_selector" type="select" label="MetaMorpheus: Output related options">
                            <option value="yes" >Set Output parameters</option>
                            <option value="no" selected="True">Keep Default Output parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_write_mzid" type="boolean" truevalue="1" falsevalue="0" checked="true" label="MetaMorpheus write mzid"/>
                            <param name="meta_morpheus_write_pepxml" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus write pepxml"/>
                        </when>
                    </conditional>

                    <conditional name="metamorpheus_deisotoping">
                        <param name="metamorpheus_deisotoping_selector" type="select" label="MetaMorpheus: Deisotoing related options">
                            <option value="yes" >Set Deisotoping parameters</option>
                            <option value="no" selected="True">Keep Default Deisotoping parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_use_provided_prec" type="boolean" truevalue="1" falsevalue="0" checked="true" label="MetaMorpheus use provided precursor info"/>
                            <param name="meta_morpheus_do_prec_deconv" type="boolean" truevalue="1" falsevalue="0" checked="true" label="MetaMorpheus do precursor deconvolution"/>
                            <param name="meta_morpheus_deconv_int_ratio" type="float" value="3.0" label="MetaMorpheus deconvolution intensity ratio"/>
                            <param name="meta_morpheus_deconv_mass_tol" type="float" value="4.0" label="MetaMorpheus score cutoff"/>
                            <param name="meta_morpheus_deconv_mass_tol_type" type="select" label="MetaMorpheus deoconvolution mass tolerance type">
                                <option value="PPM" selected="true">PPM</option>
                                <option value="Absolute">Absolute</option>
                            </param>
                        </when>
                    </conditional>


                    <conditional name="metamorpheus_proteingrouping">
                        <param name="metamorpheus_proteingrouping_selector" type="select" label="MetaMorpheus: Protein grouping related options">
                            <option value="yes" >Set Protein grouping parameters</option>
                            <option value="no" selected="True">Keep Default Protein grouping parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_mod_peptides_are_different" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus modified peptides are different"/>
                            <param name="meta_morpheus_no_one_hit_wonders" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus exclude one hit wonders"/>
                        </when>
                    </conditional>



                    <conditional name="metamorpheus_peaktrimming">
                        <param name="metamorpheus_peaktrimming_selector" type="select" label="MetaMorpheus: Peak trimming related options">
                            <option value="yes" >Set Peak trimming parameters</option>
                            <option value="no" selected="True">Keep Default Peak trimming parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                          <param name="meta_morpheus_trim_ms1" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus trim MS1 peaks"/>
                          <param name="meta_morpheus_trim_msms" type="boolean" truevalue="1" falsevalue="0" checked="true" label="MetaMorpheus trim MSMS peaks"/>
                          <param name="meta_morpheus_num_peaks_per_window" type="integer" value="200" label="MetaMorpheus number of peaks per window" />
                          <param name="meta_morpheus_min_allowed_int_ratio_to_base_peak" type="float" value="0.01" label="MetaMorpheus minimum allowed intensity ratio to base peak"/>
                          <param name="meta_morpheus_window_with_thompson" type="integer" optional="true" label="MetaMorpheus window width in Thompson" />
                          <param name="meta_morpheus_num_windows" type="integer" optional="true" label="MetaMorpheus number of windows" />
                          <param name="meta_morpheus_norm_across_all_windows" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus normalize peaks across all windows"/>
                        </when>
                    </conditional>

                    <conditional name="metamorpheus_silico">
                        <param name="metamorpheus_silico_selector" type="select" label="MetaMorpheus: Silico digestion related options">
                            <option value="yes" >Set Silico digestion parameters</option>
                            <option value="no" selected="True">Keep Default Silico digestion parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_frag_term" type="select" label="MetaMorpheus fragmentation terminus">
                                <option value="Both" selected="true">Both</option>
                                <option value="N">N</option>
                                <option value="C">C</option>
                            </param>
                            <param name="meta_morpheus_max_frag_size" type="float" value="30000.0" label="MetaMorpheus maximum fragmentation size"/>
                            <param name="meta_morpheus_search_target" type="boolean" truevalue="1" falsevalue="0" checked="true" label="MetaMorpheus search target sequences"/>
                            <param name="meta_morpheus_decoy_type" type="select" label="MetaMorpheus decoy type">
                                <option value="None" selected="true">None</option>
                                <option value="Reverse">Reverse</option>
                                <option value="Slide">Slide</option>
                            </param>
                            <param name="meta_morpheus_max_mod_isoforms" type="integer" value="1024" label="MetaMorpheus maximum modified isoforms" />
                            <param name="meta_morpheus_min_variant_depth" type="integer" value="1" label="MetaMorpheus minimum variant depth" />
                            <param name="meta_morpheus_max_hetrozygous_var" type="integer" value="4" label="MetaMorpheus maximum hetrozygous variants" />
                        </when>
                    </conditional>

                    <conditional name="metamorpheus_gptm">
                        <param name="metamorpheus_gptm_selector" type="select" label="MetaMorpheus: G-PTM search related options">
                            <option value="yes" >Set G-PTM search parameters</option>
                            <option value="no" selected="True">Keep Default G-PTM search parameters</option>
                        </param>
                        <when value="no" />
                        <when value="yes">
                            <param name="meta_morpheus_gptm" type="boolean" truevalue="1" falsevalue="0" checked="false" label="MetaMorpheus run G-PTM"/>
                            <param name="meta_morpheus_gptm_categories" type="select"  display="checkboxes" multiple="True"
                              label="MetaMorpheus G-PTM categories to include in the G-PTM search">
                                <option value="common_fixed_variable" >Common Fixed and Variable</option>
                                <option value="common_biological" selected="true">Common Biological</option>
                                <option value="common_artifact" selected="true">Common Artifact</option>
                                <option value="metal" selected="true">Metal</option>
                                <option value="less_common">Less Common</option>
                                <option value="labeling">Labeling</option>
                                <option value="subs_1n">Substitution (1 Nucleotide)</option>
                                <option value="subs_2n">Substitution (2+ Nucleotides)</option>
                                <option value="other">Other</option>
                            </param>
                        </when>
                    </conditional>


                </when>
            </conditional>


            <!-- NOVOR ADVANDED PARAMETERS-->
            <conditional name="novor">
                <param name="novor_advanced" type="select" label="Novor Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="novor_fragmentation" type="select" label="Novor fragmentation method">
                        <option value="HCD" selected="True">HCD</option>
                        <option value="CID">CID</option>
                    </param>
                    <param name="novor_mass_analyzer" label="Novor: mass analyzer" type="select" help="Identifier of the instrument to generate MS/MS spectra">
                        <option value="Trap" >Trap</option>
                        <option value="TOF" >TOF</option>
                        <option value="FT" selected="True">FT</option>
                    </param>
                </when>
            </conditional>

            <!-- PEPNOVO+ ADVANDED PARAMETERS-->
            <conditional name="pepnovo">
                <param name="pepnovo_advanced" type="select" label="PepNovo+ Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="pepnovo_hitlist_length" type="integer" value="10" label="PepNovo+ number of de novo solutions [0-2000], default is '10'.">
                      <validator type="in_range" min="0" max="2000" />
                    </param>
                    <param name="pepnovo_estimate_charge" type="boolean" truevalue="1" falsevalue="0" checked="true" label="PepNovo+ estimate precursor charge option."/>
                    <param name="pepnovo_correct_prec_mass" type="boolean" truevalue="1" falsevalue="0" checked="true" label="PepNovo+ correct precursor mass option."/>
                    <param name="pepnovo_discard_spectra" type="boolean" truevalue="1" falsevalue="0" checked="true" label="PepNovo+ discard low quality spectra option."/>
                    <param name="pepnovo_generate_blast" type="boolean" truevalue="1" falsevalue="0" checked="false" label="PepNovo+ generate a BLAST query."/>
                </when>
            </conditional>

            <!-- PNOVO+ ADVANDED PARAMETERS-->
            <conditional name="pnovo">
                <param name="pnovo_advanced" type="select" label="pNovo+ Options">
                    <option value="yes">Advanced</option>
                    <option value="no" selected="True">Default</option>
                </param>
                <when value="no" />
                <when value="yes">
                    <param name="pnovo_num_peptides" type="integer" value="10" label="pNovo+ number of peptides per spectrum, default is '10'."/>
                    <param name="pnovo_lower_prec" type="integer" value="300" label="pNovo+ minimum precursor mass, default is '300'."/>
                    <param name="pnovo_upper_prec" type="integer" value="5000" label="pNovo+ maximum precursor mass, default is '5000'."/>
                    <param name="pnovo_activation" type="select" label="pNovo+ activation type (HCD, CID or EDT)">
                        <option value="HCD" selected="True">HCD</option>
                        <option value="CID" >CID</option>
                        <option value="EDT">EDT</option>
                    </param>
                </when>
            </conditional>
        </section>










        <!-- ADVANCED PARAMETERS -->

        <section name="advanced_options" expanded="false" title="Show/Hide advanced options">

            <!-- SPECTRUM ANNOTATION -->

            <section name="spectrum_annotation_options" expanded="false" title="Spectrum Annotation Options">
                <param name="annotation_level" label="Percent of the possible annotations relative to the most intensive peak" help="The intensity percentile to consider for annotation, e.g. 0.75 means that the 25% most intense peaks will be annotated, default is 0.75." value="0.75" type="float">
                    <validator type="in_range" min="0" max="1" />
                </param>
                <param name="annotation_mz_tolerance" label="Fragment ion annotation accuracy" help=" The m/z tolerance to annotate peaks, default is equal to the search settings MS2 tolerance." value="0.5" type="float" />
                <param name="annotation_high_resolution" label="High resolution" help="The most accurate peak will be selected within the m/z tolerance if chosen" truevalue="1" falsevalue="0" checked="true" type="boolean"/>
            </section>

            <!-- SEQUENCE MATCHING -->

            <section name="sequence_matching_options" expanded="false" title="Sequence Matching Options">
                <param name="sequence_matching_type" label="The peptide to protein sequence matching type" type="select">
                    <option value="0">Character Sequence</option>
                    <option value="1">Amino Acids</option>
                    <option value="2" selected="true">Indistinguishable Amino Acids</option>
                </param>
                <param name="sequence_matching_x" label="The maximal share of Xs in a sequence" help="0.25 means 25% of Xs" value="0.25" type="float">
                    <validator type="in_range" min="0" max="1" />
                </param>
                <param name="sequence_matching_enzymatic_tags" label="Tags should only be mapped to enzymatic peptides" type="boolean" truevalue="1" falsevalue="0" checked="false"/>
                <param name="sequence_matching_max_ptms_per_tag" label="The maximum number of PTMs per peptide when mapping tags" type="integer" value="3">
                    <validator type="in_range" min="0" max="2147483647" />
                </param>
                <param name="sequence_matching_min_amino_acid_score" label="The minimum amino acid score when mapping tags" type="integer" value="30">
                    <validator type="in_range" min="0" max="2147483647" />
                </param>
                <param name="sequence_matching_min_tag_length" label="The minimum tag length when mapping tags" type="integer" value="3">
                    <validator type="in_range" min="0" max="2147483647" />
                </param>

            </section>


            <!-- IMPORT FILTERS -->

            <section name="import_filters_options" expanded="false" title="Import filters">
                    <param name="min_peptide_length" type="integer" label="Minimum Peptide Length" value="8" />
                    <param name="max_peptide_length" type="integer" label="Maximum Peptide Length" value="30" />
                    <param name="max_precursor_error" type="float" label="Maximum Precursor Error" help="The higher precursor mass error allowed in order to filter out outliers" value="10" />
                    <param name="max_precursor_error_type" label="Maximum Precursor Error Type" type="select" >
                        <option value="1">ppm</option>
                        <option value="0">Daltons</option>
                    </param>
                    <param name="missed_cleavages_min" type="integer" label="Minimal number of missed cleavages to consider when importing identification files" help="Default is no filter" value="" optional="true"/>
                    <param name="missed_cleavages_max" type="integer" label="Maximal number of missed cleavages to consider when importing identification files" help="Default is no filter" value="" optional="true"/>
                    <param name="exclude_unknown_ptms" label="Exclude Unknown PTMs" help="If true, peptides presenting unrecognized PTMs will be excluded" type="boolean" truevalue="1" falsevalue="0" checked="true" />
            </section>


            <!-- PTM LOCALIZATION -->

            <section name="ptm_localization_options" expanded="false" title="PTM Localizacion">
                <conditional name="ptm_score">
                    <param name="ptm_score_selector" type="select" label="The PTM probabilistic score to use for PTM localization">
                        <option value="1" selected="True">PhosphoRS</option>
                        <option value="2">None</option>
                    </param>
                    <when value="1">
                        <param name="score_neutral_losses" label="Include Neutral Losses in A Score" type="boolean" truevalue="1" falsevalue="0" />
                        <param name="ptm_threshold" label="The threshold to use for the PTM scores" value="95.0" type="float"
                            help="Automatic mode will be used if not set" />
                    </when>
                    <when value="2" />
                </conditional>
                <param name="ptm_sequence_matching_type" type="select" label="The modification to peptide sequence matching type." >
                     <option value="0">Character Sequence</option>
                     <option value="1" selected="true">Amino Acids</option>
                     <option value="2">Indistinguishable Amino Acids</option>
                </param>
                <param name="ptm_alignment" label="Align peptide ambiguously localized PTMs on confident sites" type="boolean" truevalue="1" falsevalue="0" checked="true"/>
            </section>


            <!-- GENE ANNOTATION -->

            <section name="gene_annotation_options" expanded="false" title="Gene Annotation">
                <param name="use_gene_mapping" type="boolean" truevalue="-useGeneMapping 1" falsevalue="-useGeneMapping 0" checked="false"
                    label="gene mappings will be used and saved along with the project (UniProt databases only)"
                    help="This should only be enabled for UniProt databaases" />
                <param name="update_gene_mapping" type="boolean" truevalue="-updateGeneMapping 1" falsevalue="-updateGeneMapping 0" checked="false"
                    label="Update gene mappings automatically from Ensembl (UniProt databases only)"
                help="This should only be enabled for UniProt databaases" />
            </section>


            <!-- PROTEIN INFERENCE -->

            <section name="protein_inference_options" expanded="false" title="Protein Inference">
                <conditional name="simplify_protein_groups_conditional">
                    <param name="simplify_protein_groups_selector" type="select" label="Simplify protein groups">
                        <option value="yes" selected="True">Yes</option>
                        <option value="no">No</option>
                    </param>
                    <when value="no" />
                    <when value="yes">
                        <param name="simplify_protein_groups_evidence" type="boolean" truevalue="1" falsevalue="0" checked="true"
                            label="Based on Uniprot evidence level"/>
                        <param name="simplify_protein_groups_confidence" type="boolean" truevalue="1" falsevalue="0" checked="true"
                            label="Based on the peptide confidence"/>
                        <param name="simplify_protein_groups_confidence_threshold" value="0.05" type="float"
                            label="Confidence below which a peptide is ignored"/>
                        <param name="simplify_protein_groups_enzymaticity" type="boolean" truevalue="1" falsevalue="0" checked="true"
                            label="Based on Enzymaticity"/>
                        <param name="simplify_protein_groups_variant" type="boolean" truevalue="1" falsevalue="0" checked="true"
                            label="Based on Variant Mapping"/>
                    </when>
                </conditional>
                <param name="simplify_protein_pi_modifications" type="boolean" truevalue="1" falsevalue="0" checked="true"
                    label="Account for modifications when mapping peptides to proteins"/>
            </section>

            <!-- VALIDATION LEVELS -->

            <section name="validation_levels_options" expanded="false" title="Validation Levels">
                <param name="protein_fdr" label="FDR at the protein level" help="In percent (default 1% FDR: '1')" value="1" type="float">
                    <validator type="in_range" min="0" max="100" />
                </param>
                <param name="peptide_fdr" label="FDR at the peptide level" help="In percent (default 1% FDR: '1')" value="1" type="float">
                    <validator type="in_range" min="0" max="100" />
                </param>
                <param name="psm_fdr" label="FDR at the PSM level" help="In percent (default 1% FDR: '1')" value="1" type="float">
                    <validator type="in_range" min="0" max="100" />
                </param>
            </section>


            <!-- FRACTION ANALYSIS -->

            <section name="fraction_analysis_options" expanded="false" title="Fraction Analysis">
                <param name="protein_fraction_mw_confidence" value="95.0" type="float"
                  label="Minimum confidence required for a protein in the fraction MW plot (in percentage)"
                    help="default 95%: '95.0'">
                    <validator type="in_range" min="0" max="100" />
                </param>
            </section>


            <!-- DATABASE PROCESSING OPTIONS -->

            <section name="database_processing_options" expanded="false" title="Database Processing Options">
                <conditional name="decoy_conditional">
                    <param name="create_decoy_selector" type="select"
                      label="Create a concatenated target/decoy database before running PeptideShaker"
                      help="Selecting this option will help PeptideShaker calculate FDR values">
                        <option value="yes" selected="True">Yes</option>
                        <option value="no" >No</option>
                    </param>
                    <when value="no" />
                    <when value="yes">
                        <param name="decoy_tag" type="text" value="_REVERSED" label="The decoy flag">
                        </param>
                        <param name="decoy_type" type="select" label="Location of the decoy flag: prefix or suffix">
                            <option value="0">Prefix</option>
                            <option value="1" selected="True">Suffix</option>
                        </param>
                    </when>
                </conditional>
                <param name="decoy_file_tag" type="text" value="_concatenated_target_decoy" label="Target decoy suffix.">
                </param>
            </section>

        </section>

    </inputs>
    <outputs>
        <data name="Identification_Parameters_File" format="json" from_work_dir="IdentificationParametersOutput.par" label="${tool.name}: PAR file" />
    </outputs>
    <tests>

        <!-- Test that default parameters generates a standard par file -->
        <test>
            <param name="xtandem_advanced" value="yes"/>
            <param name="xtandem_refine_selector" value="no"/>
            <output name="Identification_Parameters_File" file="Identification_Parameters_default.par" ftype="json" compare="sim_size" delta="1000" />
        </test>
        <!-- Test specific parameters with modifications -->
        <test>
            <param name="precursor_ion_tol" value="100"/>
            <param name="fixed_modifications" value="Carbamidomethylation of C"/>
            <param name="variable_modifications" value="Oxidation of M"/>
            <param name="min_charge" value="1"/>
            <param name="max_charge" value="3"/>
            <param name="xtandem_advanced" value="yes"/>
            <param name="xtandem_refine_selector" value="yes"/>
            <output name="Identification_Parameters_File" file="Identification_Parameters_specific.par" ftype="json" compare="sim_size" delta="1000" />
        </test>

    </tests>
    <help>
**What it does**

Creates a parameters file (.par) which can be used independently by SearchGUI or PeptideShaker apps.

A FASTA file with decoy sequences generated by FastaCLI is recommended if SearchGUI and PeptideShaker are going to use the output of this tool.

    </help>
    <expand macro="citations" />
</tool>