void PMCSQS_Scorer::trainSqsModels(const Config* config, const SpectraAggregator& positiveSpectra, const char* pathNegativeSpectraList, int specificCharge, vector< vector<float> >* inputWeights) { // TODO add weight file that can be read from outside to set the weights... ? vector< vector< vector<ME_Regression_Sample> > > samples; // first dim: neg, +1, +2, +3 // second dim: sizeIndex maximalChargeWithModels_ = (inputWeights ? inputWeights->size()-1 : 3); set_frag_pair_sum_offset(MASS_PROTON); // b+y - PM+19 set_bin_increment(0.1); set_sqs_mass_thresholds(); if (pmcMassThresholds_.size() == 0) { pmcMassThresholds_=config->get_size_thresholds(); } vector<vector<float> > classWeights; if (inputWeights) { classWeights = *inputWeights; } else setClassWeightsAccordingToData(positiveSpectra, classWeights); const int numSizes = sqsMassThresholds_.size(); cout << "number of sizes for SQS models " << numSizes+1 << endl; samples.resize(maximalChargeWithModels_+1); SpectraAggregator negativeSpectra; negativeSpectra.initializeFromTextFile(pathNegativeSpectraList, config); const int maxHeadersPerModel = 8000; // read all samples size_t charge; for (charge=0; charge<=maximalChargeWithModels_; charge++) { if (charge>0 && specificCharge>0 && charge != specificCharge) continue; samples[charge].resize(numSizes+1); size_t sizeIndex; for (sizeIndex=0; sizeIndex<=numSizes; sizeIndex++) { const mass_t minMass = (sizeIndex == 0 ? 0 : sqsMassThresholds_[sizeIndex-1]); const mass_t maxMass = (sizeIndex == numSizes ? POS_INF : sqsMassThresholds_[sizeIndex]); const SpectraAggregator& sa = (charge == 0 ? negativeSpectra : positiveSpectra); SpectraList sl(sa); if (charge == 0) { sl.selectHeaders(minMass, maxMass); } else sl.selectHeaders(minMass, maxMass, charge, charge); cout << "Found " << sl.getNumHeaders() << " for charge " << charge << " ranges:" << minMass << " - " << maxMass << endl; sl.randomlyReduceListToSize(maxHeadersPerModel); const int label = (charge == 0 ? 1 : 0); samples[charge][sizeIndex].resize(sl.getNumHeaders()); int i; for (i=0; i<sl.getNumHeaders(); i++) { const SingleSpectrumHeader* header = sl.getSpectrumHeader(i); PeakList pl; pl.readPeaksToLocalAllocation(sa,header); pl.initializePeakList(config, true); initializeForCurrentSpectrum(config, pl); calculateCurrentSpectrumPmcValues(pl, bin_increment); fillSqsMeSample(pl, samples[charge][sizeIndex][i]); samples[charge][sizeIndex][i].label = label; } } } // cout sample composition cout << "Sample composition:" << endl; for (charge=0; charge<=maximalChargeWithModels_; charge++) { cout << charge; size_t i; for (i=0; i<samples[charge].size(); i++) cout << "\t" << samples[charge][i].size(); cout << endl; } // create SQS models sqs_models.resize(maximalChargeWithModels_+1); for (charge =0; charge<=maximalChargeWithModels_; charge++) { sqs_models[charge].resize(maximalChargeWithModels_+1); int j; for (j=0; j<sqs_models[charge].size(); j++) sqs_models[charge][j].resize(numSizes+1,NULL); } for (charge=1; charge<=maximalChargeWithModels_; charge++) { int sizeIndex; for (sizeIndex=0; sizeIndex<=numSizes; sizeIndex++) { cout << endl << "CHARGE " << charge << " SIZE " << sizeIndex << endl; ME_Regression_DataSet ds; ds.num_classes=2; ds.num_features=SQS_NUM_FIELDS; ds.add_samples(samples[0][sizeIndex]); ds.add_samples(samples[charge][sizeIndex]); ds.tally_samples(); if (ds.class_weights[0]<0.0001 || ds.class_weights[1]<0.0001) { cout << "Warning: insufficient number of samples, not trianing model for this charge " << charge << " size " << sizeIndex << endl; continue; } const double pos_weight = 0.2 + classWeights[charge][sizeIndex]*0.3; ds.randomly_remove_samples_with_activated_feature(1,SQS_IND_MAX_TAG_LENGTH_ABOVE_4,0.5); ds.calibrate_class_weights(pos_weight); // charge vs bad spectra ds.print_feature_summary(cout,SQS_var_names); sqs_models[charge][0][sizeIndex]=new ME_Regression_Model; sqs_models[charge][0][sizeIndex]->train_cg(ds,250); sqs_models[charge][0][sizeIndex]->print_ds_probs(ds); } } //////////////////////////////////////////// // train model vs. model if charge1>charge2 if (1) { int charge1,charge2; for (charge1=2; charge1<=maximalChargeWithModels_; charge1++) { for (charge2=1; charge2<charge1; charge2++) { int sizeIndex; for (sizeIndex=0; sizeIndex<=numSizes; sizeIndex++) { ME_Regression_DataSet ds; ds.num_classes=2; ds.num_features=SQS_NUM_FIELDS; ds.add_samples(samples[charge1][sizeIndex]); int i; for (i=0; i<samples[charge2][sizeIndex].size(); i++) { samples[charge2][sizeIndex][i].label=1; ds.add_sample(samples[charge2][sizeIndex][i]); samples[charge2][sizeIndex][i].label=0; } float relative_weight = classWeights[charge1][sizeIndex]/ (classWeights[charge1][sizeIndex]+classWeights[charge2][sizeIndex]); ds.tally_samples(); if (ds.class_weights[0]<0.0001 || ds.class_weights[1]<0.0001) { cout << "Warning: insufficient number of samples, not trianing model for charge " << charge1 << " vs charge " << charge2<< " (size " << sizeIndex << ")" << endl; continue; } ds.calibrate_class_weights(relative_weight); sqs_models[charge1][charge2][sizeIndex] = new ME_Regression_Model; cout << endl << "CHARGE " << charge1 << " vs " << charge2 << " size " << sizeIndex << endl; cout << "Relative weights: " << charge1 << "/(" << charge1 << "+" << charge2 << "): " << relative_weight << endl; ds.print_feature_summary(cout,SQS_var_names); sqs_models[charge1][charge2][sizeIndex]->train_cg(ds,300); sqs_models[charge1][charge2][sizeIndex]->print_ds_probs(ds); } } } } init_sqs_correct_factors(maximalChargeWithModels_, sqsMassThresholds_.size()); //////////////////////////////////////////// // final report on datasets cout << endl; int sizeIndex; for (sizeIndex=0; sizeIndex<=numSizes; sizeIndex++) { cout << endl << "SIZE: " << sizeIndex << endl; cout << "--------" << endl; float p_thresh = 0.05; int d; for (d=0; d<=maximalChargeWithModels_; d++) { vector<int> counts; vector<int> max_counts; counts.resize(maximalChargeWithModels_+1,0); max_counts.resize(maximalChargeWithModels_+1,0); int i; for (i=0; i<samples[d][sizeIndex].size(); i++) { bool above_thresh=false; float max_prob=0; int max_class=0; int c; for (c=1; c<=maximalChargeWithModels_; c++) { if (! sqs_models[c][0][sizeIndex]) continue; float prob = sqs_models[c][0][sizeIndex]->p_y_given_x(0,samples[d][sizeIndex][i]); if (prob>p_thresh) { counts[c]++; above_thresh=true; if (prob>max_prob) { max_prob=prob; max_class=c; } } } max_counts[max_class]++; if (! above_thresh) counts[0]++; } cout << d << "\t"; for (i=0; i<=maximalChargeWithModels_; i++) cout << fixed << setprecision(4) << max_counts[i]/(float)samples[d][sizeIndex].size() << "\t"; cout << endl; } } ind_initialized_sqs = true; string path; path = config->get_resource_dir() + "/" + config->get_model_name() + "_SQS.txt"; write_sqs_models(path.c_str()); }
int main(int argc, char **argv) { AllScoreModels model; int i; char ann_file[256]; char out_file[256]; char input_file[256]; char inspect_results_file[256]; char list_file[256]; char model_file[256]; char initial_model[256]; char model_dir[256]; char PTM_string[256]; char mgf_out_dir[256]; char neg_spec_list[256]; char tag_string[64]; char tag_suffix[64]; bool got_input_file=false,got_model_file=false, got_list_file=false; bool got_model_dir=false, got_initial_model=false, got_PTM_string = false, got_neg_spec_list=false; bool prm_only=false; bool prm_norm=false; bool pmcsqs_only = false; bool sqs_only = false; bool got_filter_spectra = false; bool pmcsqs_and_prm = false; bool train_flag = false; bool correct_pm = false; bool use_spectrum_charge = false; bool use_spectrum_mz = false; bool perform_filter = true; bool output_aa_probs = false; bool output_cumulative_probs = false; bool make_inspect_tags = false; bool make_training_fa = false; bool test_tags = false; bool got_make_ann_mgf = false; bool got_make_training_mgf = false; bool got_rescore_inspect = false; bool got_recalibrate_inspect = false; bool got_make_peak_examples = false; int start_train_idx=0; int end_train_idx = POS_INF; int specific_charge=-1; int specific_size=-1; int specific_region=-1; int specific_idx = -1; int file_start_idx =0; int tag_length = 0; int num_solutions = 20; int digest_type = TRYPSIN_DIGEST; mass_t train_tolerance; float min_pmcsqs_prob = -1.0; mass_t fragment_tolerance = -1.0; mass_t pm_tolerance = -1.0; float sqs_filter_thresh = 0.0; float min_filter_prob = 0.0; int num_test_cases=-1; int num_training_spectra=-1; seedRandom(112233); strcpy(tag_suffix,"tags"); // read command line arguments i=1; while (i<argc) { if (! strcmp(argv[i],"-make_ann_mgf")) { if (++i == argc) print_help("Missing file ann file!"); strcpy(ann_file,argv[i]); if (++i == argc) print_help("Missing file out file!"); strcpy(out_file,argv[i]); got_make_ann_mgf=true; } else if (! strcmp(argv[i],"-make_training_mgf")) { if (++i == argc) print_help("Missing file out file!"); strcpy(out_file,argv[i]); if (++i == argc) print_help("Missing num training spectra!"); num_training_spectra = atoi(argv[i]); if (num_training_spectra<=0) print_help("Error: -make_training_mgf [out_file] [num spectra>0]\n"); got_make_training_mgf=true; } else if (!strcmp(argv[i],"-file")) { if (++i == argc) print_help("Missing file name!"); strcpy(input_file,argv[i]); got_input_file=true; } else if (!strcmp(argv[i],"-list")) { if (++i == argc) print_help("Missing list name!"); strcpy(list_file,argv[i]); got_list_file=true; } else if (!strcmp(argv[i],"-file_start_idx")) { if (++i == argc) print_help("Missing file start idx!"); file_start_idx = atoi(argv[i]); } else if (!strcmp(argv[i],"-model")) { if (++i == argc) print_help("Missing model name!"); strcpy(model_file,argv[i]); got_model_file=true; } else if (! strcmp(argv[i],"-model_dir")) { if (++i == argc) print_help("Missing model dir name!"); strcpy(model_dir,argv[i]); got_model_dir=true; } else if (! strcmp(argv[i],"-fragment_tolerance")) { if (++i == argc) print_help("Missing model dir name!"); fragment_tolerance = atof(argv[i]); if (fragment_tolerance<0 || fragment_tolerance>0.75) print_help("Error: -fragment_toelerance should be 0-0.75\n"); } else if (! strcmp(argv[i],"-pm_tolerance")) { if (++i == argc) print_help("Missing model dir name!"); pm_tolerance = atof(argv[i]); if (pm_tolerance<0 || pm_tolerance>5.0) print_help("Error: -pm_toelerance should be 0-5.0\n"); } else if (!strcmp(argv[i],"-num_solutions")) { if (++i == argc) print_help("Missing number of solutions!"); num_solutions = atoi(argv[i]); if (num_solutions<=0 || num_solutions> 2000) print_help("Error: -num_solutions should be 1-2000\n"); } else if (!strcmp(argv[i],"-tag_length")) { if (++i == argc) print_help("Missing minimum length parameter!"); tag_length = atoi(argv[i]); if (tag_length<3 || tag_length>6) print_help("Error: -tag_length value must be 3-6\n"); } else if (!strcmp(argv[i],"-digest")) { if (++i == argc) print_help("Missing digest type parameter : NON_SPECIFIC, TRYPSIN\n"); if (! strcmp(argv[i],"NON_SPECIFIC")) { digest_type = NON_SPECIFIC_DIGEST; } else if (! strcmp(argv[i],"TRYPSIN")) { digest_type = TRYPSIN_DIGEST; } else { printf("Error: bad digest type: %s\n",argv[i]); print_help("Supported digest types: NON_SPECIFIC, TRYPSIN."); } } else if (! strcmp(argv[i],"-use_spectrum_charge")) { use_spectrum_charge = true; } else if (! strcmp(argv[i],"-use_spectrum_mz")) { use_spectrum_mz = true; } else if (! strcmp(argv[i],"-no_quality_filter")) { perform_filter = false; } else if (! strcmp(argv[i],"-correct_pm")) { correct_pm = true; } else if (! strcmp(argv[i],"-prm")) { prm_only = true; } else if (! strcmp(argv[i],"-prm_norm")) { prm_norm = true; prm_only = true; } else if (! strcmp(argv[i],"-output_aa_probs")) { output_aa_probs=true; } else if (! strcmp(argv[i],"-output_cumulative_probs")) { output_cumulative_probs=true; } else if (! strcmp(argv[i],"-pmcsqs_only")) { pmcsqs_only = true; } else if (! strcmp(argv[i],"-sqs_only")) { sqs_only = true; } else if (! strcmp(argv[i],"-min_filter_prob")) { if (++i == argc) print_help("Missing minimum probability parmater after -min_filter_prob !\n"); min_filter_prob = -1.0; min_filter_prob = atof(argv[i]); if (min_filter_prob<0.0 || min_filter_prob>=1.0 || argv[i][0] != '0') { print_help("The flag -min_filter_prob should be followed by a minimal probability value [0-1.0]\n"); exit(1); } } else if ( ! strcmp(argv[i],"-filter_spectra")) { got_filter_spectra = true; if (++i == argc) print_help("Missing minimum probability parmater after -filter_spectra !\n"); sqs_filter_thresh=atof(argv[i]); if (sqs_filter_thresh <0 || sqs_filter_thresh>1.0) print_help("Error: the sqs threshold should be in the range 0-1 (recommended below 0.1)\n"); if (++i == argc) print_help("Missing output directory for MGF files (second argument after -filter_spectra)!\n"); strcpy(mgf_out_dir,argv[i]); } else if (! strcmp(argv[i],"-specific_idx")) { if (++i == argc) print_help("Missing idx!"); specific_idx=atoi(argv[i]); } else if (! strcmp(argv[i],"-train_model")) { train_flag = true; if (++i == argc) print_help("Missing training tolerance!"); train_tolerance = atof(argv[i]); if (train_tolerance<0.001 || train_tolerance>1.0) print_help("Error: training tolerance should be in the range 0.001 - 1.0\n"); } else if (! strcmp(argv[i],"-start_train_idx")) { if (++i == argc) print_help("Missing start_train_idx!"); start_train_idx = atoi(argv[i]); } else if (! strcmp(argv[i],"-end_train_idx")) { if (++i == argc) print_help("end_train_idx!"); end_train_idx = atoi(argv[i]); } else if (! strcmp(argv[i],"-specific_reigon_model")) { if (++i == argc) print_help("specific_reigon_model!"); specific_charge = atoi(argv[i++]); specific_size = atoi(argv[i++]); specific_region = atoi(argv[i]); } else if (! strcmp(argv[i],"-specific_charge")) { if (++i == argc) print_help("specific_charge!"); specific_charge = atoi(argv[i]); } else if (! strcmp(argv[i],"-specific_size")) { if (++i == argc) print_help("specific_size!"); specific_size = atoi(argv[i]); } else if (! strcmp(argv[i],"-initial_model")) { got_initial_model = true; if (++i == argc) print_help("Missing initial model name!"); strcpy(initial_model,argv[i]); } else if (! strcmp(argv[i],"-neg_spec_list")) { got_neg_spec_list = true; if (++i == argc) print_help("Missing neg spec list!"); strcpy(neg_spec_list,argv[i]); } else if (! strcmp(argv[i],"-PTMs")) { got_PTM_string = true; if (++i == argc) print_help("Missing PTM list!"); strcpy(PTM_string,argv[i]); } else if (! strcmp(argv[i],"-inspect_tags")) { make_inspect_tags=true; if (++i == argc) print_help("inspect_tags!"); strcpy(tag_string,argv[i]); } else if (! strcmp(argv[i],"-rescore_inspect")) { got_rescore_inspect = true; if (++i == argc) print_help("Missing results file!"); strcpy(inspect_results_file,argv[i]); if (++i == argc) print_help("Missing new results file!"); strcpy(out_file,argv[i]); } else if (! strcmp(argv[i],"-recalibrate_inspect")) { got_recalibrate_inspect = true; if (++i == argc) print_help("Missing results file!"); strcpy(inspect_results_file,argv[i]); if (++i == argc) print_help("Missing new results file!"); strcpy(out_file,argv[i]); } else if ( ! strcmp(argv[i],"-make_peak_examples")) { got_make_peak_examples=true; } else if (! strcmp(argv[i],"-make_training_fa")) { make_training_fa=true; } else if (! strcmp(argv[i],"-test_tags")) { test_tags=true; if (++i == argc) print_help("test_tags!"); strcpy(tag_string,argv[i]); } else if (! strcmp(argv[i],"-num_test_cases")) { if (++i == argc) print_help("num_test_cases!"); num_test_cases = atoi(argv[i]); } else if (! strcmp(argv[i],"-tag_suffix")) { if (++i == argc) print_help("tag suffix!"); strcpy(tag_suffix,argv[i]); } else { printf("**********************************************************\n"); printf("\nError: Unkown command line option: %s\n\n",argv[i]); print_help(""); exit(0); } i++; } if (! got_model_file) print_help("Error: Missing model name!"); if (!got_input_file && ! got_list_file) print_help("Error: missing input file (either -file or -list must be used)."); Config *config = model.get_config(); if (got_model_dir) { config->set_resource_dir(string(model_dir)); } ////////////////////////////////////////////////////////////////// // Model Training if (train_flag) { if (got_initial_model) { model.read_model(initial_model); if (got_PTM_string) config->apply_selected_PTMs(PTM_string); model.read_rank_models(initial_model,true); model.read_cum_seq_prob_models(initial_model,true); } else { config->init_with_defaults(); config->set_tolerance(train_tolerance); config->set_digest_type(digest_type); if (got_PTM_string) config->apply_selected_PTMs(PTM_string); } model.set_model_name(string(model_file)); SpectraAggregator sa; if (! got_list_file) { if (got_input_file) { // fm.init_from_mgf(config,input_file); sa.initializeFromSpectraFilePath(input_file, config); } else { printf("Must supply a list of annotated spectra for training!\n"); exit(0); } } else { // fm.init_from_list_file(config,list_file); sa.initializeFromTextFile(list_file, config); } model.trainModelsInStages(model_file, sa, train_tolerance, start_train_idx, end_train_idx, specific_charge, specific_size, specific_region, (got_neg_spec_list ? neg_spec_list : NULL)); model.write_model(); exit(0); } /////////////////////////////////////////////////////////////////// // Model initializing (running some sort of de novo, need a model) // const time_t start_time = time(NULL); cout << "PepNovo V3. Build " << build_name << endl; cout << "Copyright 2008, The Regents of the University of California. All Rights Reserved." << endl; cout << "Created by Ari Frank ([email protected])" << endl << endl; cout << "Initializing models (this might take a few seconds)... " << flush; // TODO: incorporate PTM line into the model reading and also the other model stuff below model.read_model(model_file,true); if (got_PTM_string) config->apply_selected_PTMs(PTM_string); model.getPeptideCompositionAssigner().init_aa_translations(); model.read_rank_models(model_file,true); model.read_cum_seq_prob_models(model_file,true); cout << "Done." << endl; config = model.get_config(); config->set_digest_type(digest_type); if (fragment_tolerance>0) config->set_tolerance(fragment_tolerance); if (pm_tolerance>0) config->setPrecursorMassTolerance(pm_tolerance); if (correct_pm) config->set_need_to_estimate_pm(1); if (use_spectrum_mz) config->set_use_spectrum_mz(1); if (use_spectrum_charge) config->set_use_spectrum_charge(1); if (! perform_filter) config->set_filter_flag(0); if (config->get_pm_tolerance()<0.1) config->set_need_to_estimate_pm(0); cout << setprecision(4) << fixed; cout << "Fragment tolerance : " << config->getTolerance() << endl; cout << "PM tolernace : " << config->get_pm_tolerance() << endl; cout << "PTMs considered : " ; if (got_PTM_string) { cout << PTM_string << endl; } else { cout << "None" << endl; } /////////////////////////////////////////////////////////////////// // Training fa if (make_training_fa) { make_denovo_training_fa(model,input_file); exit(0); } /////////////////////////////////////////////////////////////////// // Inspect tags if (make_inspect_tags) { create_tag_file_for_inspect(model,input_file,tag_string,tag_suffix); exit(0); } if (test_tags) { benchmark_tags(model,list_file,tag_string,num_test_cases); exit(0); } //////////////////////////////////////////////////////////////////// // Rescore InsPecT if (got_rescore_inspect) { PeptideRankScorer *db_score = (PeptideRankScorer *)model.get_rank_model_ptr(0); db_score->rescore_inspect_results(input_file,inspect_results_file,out_file); exit(0); } if (got_recalibrate_inspect) { cout << "Recalibrating delta scores in " << input_file << endl; PeptideRankScorer *db_score = (PeptideRankScorer *)model.get_rank_model_ptr(0); db_score->recalibrate_inspect_delta_scores(input_file,inspect_results_file,out_file); exit(0); } if (got_make_peak_examples) { cout << "Making peak examples " << input_file << endl; PeptideRankScorer *db_score = (PeptideRankScorer *)model.get_rank_model_ptr(0); //db_score->make_peak_table_examples(input_file); exit(0); } /////////////////////////////////////////////////////////////////// // Make input file list vector<string> list_vector; if (got_list_file) { readListOfPaths(list_file, list_vector); } else list_vector.push_back(input_file); int correct_benchmark =0; int total_benchmark =0; int counter=0; if (got_make_training_mgf) { // make_training_mgf(config,list_file,num_training_spectra,out_file); exit(0); } if (sqs_only) { PMCSQS_Scorer *pmcsqs = (PMCSQS_Scorer *)model.get_pmcsqs_ptr(); if (! pmcsqs || ! pmcsqs->getIndInitializedSqs()) { cout << "Error: no spectrum quality score (SQS) for this model!" << endl; exit(1); } } else if (got_filter_spectra || pmcsqs_only) { PMCSQS_Scorer *pmcsqs = (PMCSQS_Scorer *)model.get_pmcsqs_ptr(); if (! pmcsqs || ! pmcsqs->getIndInitializedPmc() || ! pmcsqs->getIndInitializedSqs()) { cout << "Error: no parent mass correction (PMC) and/or quality score (SQS) for this model!" << endl; exit(1); } } /////////////////////////////////////////////////////////////////// // FILTER SPECTRA if (got_filter_spectra) { int num_written =0; int num_read = 0; PMCSQS_Scorer *pmcsqs = (PMCSQS_Scorer *)model.get_pmcsqs_ptr(); // pmcsqs->output_filtered_spectra_to_mgfs(config, list_vector, mgf_out_dir, sqs_filter_thresh, num_written, num_read); time_t curr_time = time(NULL); double elapsed_time = (curr_time - start_time); cout << "Processed " << list_vector.size() << " (" << num_read << " spectra)." << endl; cout << "Wrote " << num_written << " spectra to mgfs in " << mgf_out_dir << endl; cout << "Elapsed time " << fixed << elapsed_time << " seconds." << endl; return 0; } ////////////////////////////////////////////////////////////////// // PRM if (prm_only) { perform_prm_on_list_of_files(model, list_vector, min_filter_prob, file_start_idx, prm_norm); // prm_benchmark(model, list_vector, min_pmcsqs_prob, file_start_idx); // FileManager fm; // fm.init_from_list(config,list_vector); // model.learn_prm_normalizer_values(fm); // model.write_prm_normalizer_values(); return 0; } if (fabs(config->get_aa2mass()[Cys]-103.0)<1) { cout << endl <<"*** Warning: searching with unmodified cystine, usually the PTM C+57 should be included ***" << endl << endl; } cout << endl; ////////////////////////////////////////////////////////////////// // PMCSQS if (pmcsqs_only) { // perform_pmcsqs_on_list_of_files(model, list_vector, file_start_idx); return 0; } ////////////////////////////////////////////////////////////////// // SQS if (sqs_only) { // perform_sqs_on_list_of_files(model, list_vector, file_start_idx); return 0; } ////////////////////////////////////////////////////////////////// // DENOVO AND TAGS if (tag_length<=0) { // perform_denovo_on_list_of_files(model, list_vector, file_start_idx, num_solutions, 7, 16, // false, min_filter_prob, output_aa_probs, output_cumulative_probs, cout); new_perform_denovo_on_list_of_files(model, list_vector, file_start_idx, num_solutions, 7, 16, false, min_filter_prob, output_aa_probs, output_cumulative_probs, cout); } else { perform_tags_on_list_of_files(model,list_vector,file_start_idx,num_solutions,tag_length, false, min_filter_prob, output_aa_probs, output_cumulative_probs, cout); } #ifdef WIN32 system("pause"); #endif return 0; }