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;
}
/***************************************************************************************
This function touches up inspect search results by rescoring the sequences returned by
inspect. The function produces a new inspect results file with the scores (and delta scores)
replaced.
****************************************************************************************/
void PeptideRankScorer::recalibrate_inspect_delta_scores(char *spectra_file,
char *inspect_res,
char *new_res_file) const
{
AllScoreModels* allScoreModels = static_cast<AllScoreModels*>(this->allScoreModelsPtr_);
Config *config = allScoreModels->get_config();
ifstream org_res(inspect_res);
if (! org_res.is_open() || ! org_res.good())
{
cout << "Error: couldn't open original inspect results file for reading:" << inspect_res << endl;
exit(1);
}
ofstream new_res(new_res_file);
if (! new_res.is_open() || ! new_res.good())
{
cout << "Error: couldn't open new inspect results file for writing:" << new_res << endl;
exit(1);
}
char line_buff[1024];
org_res.getline(line_buff,1024);
bool read_line = true;
vector<string> field_names;
if (line_buff[0] != '#')
{
read_line = false;
}
else
{
string header = string(line_buff);
split_string(header,field_names);
int i;
for (i=0; i<field_names.size(); i++)
cout << i << "\t" << field_names[i] << endl;
}
vector<ScanCandidateSet> cand_sets;
vector<int> scan_mapping;
cand_sets.clear();
scan_mapping.resize(100000,-1);
while (! org_res.eof())
{
vector<string> fields;
if (read_line)
{
org_res.getline(line_buff,1024);
if (org_res.gcount() < 5)
continue;
}
else
{
read_line = true;
}
split_string(line_buff,fields);
InspectResultsLine res;
res.parse_from_fields(config,fields);
if (cand_sets.size()==0 || ! cand_sets[cand_sets.size()-1].add_new_line(res))
{
ScanCandidateSet new_set;
new_set.add_new_line(res);
if (new_set.scan>=scan_mapping.size())
scan_mapping.resize(2*scan_mapping.size(),-1);
scan_mapping[new_set.scan]=cand_sets.size();
cand_sets.push_back(new_set);
}
}
org_res.close();
cout << "Read results for " << cand_sets.size() << " scans..." << endl;
FileManager fm;
FileSet fs;
fm.init_from_file(config,spectra_file);
fs.select_all_files(fm);
const vector<SingleSpectrumFile *>& all_ssfs = fs.get_ssf_pointers();
cout << "Read " << all_ssfs.size() << " spectra headers..." << endl;
BasicSpecReader bsr;
QCPeak *peaks = new QCPeak[5000];
vector<bool> spectrum_indicators;
spectrum_indicators.resize(cand_sets.size(),false);
int num_found =0;
int i;
for (i=0; i<all_ssfs.size(); i++)
{
SingleSpectrumFile *ssf = all_ssfs[i];
const int scan_number = ssf->get_scan();
if (scan_mapping[scan_number]<0)
continue;
const int num_peaks = bsr.read_basic_spec(config,fm,ssf,peaks);
spectrum_indicators[scan_mapping[scan_number]]=true;
num_found++;
ScanCandidateSet& cand_set = cand_sets[scan_mapping[scan_number]];
cand_set.recalbirate_scores(config);
cand_set.output_to_stream(new_res,10);
}
if (num_found<cand_sets.size())
{
cout << "Warning: found only " << num_found << "/" << cand_sets.size() << " of the scans scored by InsPecT!" << endl;
}
else
{
cout << "All scored scans found in spectrum file." << endl;
}
delete [] peaks;
}
void PrmNodeScoreModel::learnPrmNormalizerValue(void* allScoreModelsVoidPointer, const SpectraAggregator& sa)
{
AllScoreModels* allScoreModels = static_cast<AllScoreModels*>(allScoreModelsVoidPointer);
const float step = 0.5;
const float min_delta = -1.0;
const float max_delta = 7.0;
const float target_mid_ratio = 0.96;
const float target_side_ratio = 0.94;
config_->set_use_spectrum_charge(1);
regional_prm_normalizers.resize(RegionalPrmNodeScoreModels_.size());
int c;
for (c=0; c<RegionalPrmNodeScoreModels_.size(); c++)
{
regional_prm_normalizers[c].resize(RegionalPrmNodeScoreModels_[c].size());
int s;
for (s=0; s<RegionalPrmNodeScoreModels_[c].size(); s++)
regional_prm_normalizers[c][s].resize(RegionalPrmNodeScoreModels_[c][s].size(),0);
}
const vector< vector<mass_t> >& mass_threshes = config_->get_size_thresholds();
for (c=1; c<regional_prm_normalizers.size(); c++)
{
int s;
for (s=0; s<regional_prm_normalizers[c].size(); s++)
{
const mass_t min_mass = (s == 0 ? 0 : mass_threshes[c][s-1]);
const mass_t max_mass = mass_threshes[c][s];
const int num_regions = regional_prm_normalizers[c][s].size();
cout << "Finding normalizers for charge " << c << " size " << s << " (masses " << min_mass << " - " <<
max_mass << ")" << endl;
SpectraList sl(sa);
sl.selectHeaders(min_mass/c,max_mass/c,c,c);
sl.randomlyReduceListToSize(2000);
if (sl.getNumHeaders()<50)
{
cout << "Insufficient number of spectra... skipping" << endl;
continue;
}
vector< vector< NodeType > > all_prms;
int sc;
for (sc=0; sc<sl.getNumHeaders(); sc++)
{
const SingleSpectrumHeader* header = sl.getSpectrumHeader(sc);
PrmGraph prm;
Spectrum s;
if (! s.readSpectrum(sa, header))
continue;
vector<mass_t> pms_with_19;
vector<int> charges;
// output m/z and prob values for the different charge states
allScoreModels->selectPrecursorMassesAndCharges(config_, s, pms_with_19, charges);
if (pms_with_19.size()<=0)
continue;
s.setCharge(charges[0]);
prm.create_graph_from_spectrum(allScoreModels, &s,pms_with_19[0]);
vector<NodeType> spec_prms;
vector<mass_t> exp_masses;
const mass_t true_mass_with_19 = s.get_true_mass_with_19();
s.getPeptide().calc_expected_breakage_masses(config_,exp_masses);
int i;
for (i=1; i<prm.get_num_nodes()-1; i++)
{
const Node& node = prm.get_node(i);
if (node.score == 0)
continue;
NodeType nt;
nt.type = 0;
int j;
for (j=0; j<exp_masses.size(); j++)
if (fabs(exp_masses[j]-node.mass)<config_->getTolerance())
{
nt.type=1;
break;
}
if (nt.type<=0)
{
int j;
for (j=0; j<exp_masses.size(); j++)
if (fabs(true_mass_with_19 - exp_masses[j] -node.mass-MASS_PROTON)<config_->getTolerance())
{
nt.type=2;
break;
}
}
nt.org_score = node.score;
nt.mod_score = node.score;
nt.region = node.breakage.region_idx;
spec_prms.push_back(nt);
}
all_prms.push_back(spec_prms);
}
vector< vector< double > > per_pre, per_suf, per_covered;
vector<float> deltas;
per_pre.resize(num_regions);
per_suf.resize(num_regions);
per_covered.resize(num_regions);
float delta;
for (delta = min_delta; delta<=max_delta; delta+=step )
{
// perform mods
int a;
for (a=0; a<all_prms.size(); a++)
{
int b;
for (b=0; b<all_prms[a].size(); b++)
{
NodeType& nt = all_prms[a][b];
if (nt.org_score< -delta)
{
nt.mod_score = NEG_INF;
continue;
}
nt.mod_score = nt.org_score + delta;
}
}
// compute stats (if score is negative treat as 0)
vector<double> num_pre,num_suf;
vector<double> num_pre_wpos, num_suf_wpos;
vector<double> score_pre, score_suf, total_score;
num_pre.resize(num_regions,0);
num_suf.resize(num_regions,0);
num_pre_wpos.resize(num_regions,0);
num_suf_wpos.resize(num_regions,0);
score_pre.resize(num_regions,0);
score_suf.resize(num_regions,0);
total_score.resize(num_regions,0);
for (a=0; a<all_prms.size(); a++)
{
int b;
for (b=0; b<all_prms[a].size(); b++)
{
const int type = all_prms[a][b].type;
const float score = all_prms[a][b].mod_score;
const int region = all_prms[a][b].region;
if (type == 1)
{
num_pre[region]++;
if (score>0)
{
num_pre_wpos[region]++;
score_pre[region]+= score;
}
}
if (type == 2)
{
num_suf[region]++;
if (score>0)
{
num_suf_wpos[region]++;
score_suf[region]+=score;
}
}
if (score>0)
total_score[region]+=score;
}
}
deltas.push_back(delta);
int r;
for (r=0; r<num_regions; r++)
{
per_pre[r].push_back(num_pre_wpos[r]/num_pre[r]);
per_suf[r].push_back(num_suf_wpos[r]/num_suf[r]);
per_covered[r].push_back((score_pre[r]+score_suf[r])/total_score[r]);
}
}
// report
int r;
for (r=0; r<num_regions; r++)
{
cout << endl << "Region " << r << endl;
int d;
for (d=0; d<deltas.size(); d++)
cout << "\t" << deltas[d];
cout << endl << "% Pre";
for (d=0; d<per_pre[r].size(); d++)
cout << "\t" << per_pre[r][d];
cout << endl << "% Suf";
for (d=0; d<per_suf[r].size(); d++)
cout << "\t" << per_suf[r][d];
cout << endl << "% Cov";
for (d=0; d<per_covered[r].size(); d++)
cout << "\t" << per_covered[r][d];
cout << endl;
// select
float target_val = target_mid_ratio;
if (r==0 || r == num_regions-1)
target_val = target_side_ratio;
float best_val=POS_INF;
float best_delta=0;
for (d=0; d<deltas.size(); d++)
if (fabs(per_pre[r][d]-target_val)<best_val)
{
best_val = fabs(per_pre[r][d]-target_val);
best_delta = deltas[d];
}
cout << "Chose delta = " << best_delta << endl << endl;
regional_prm_normalizers[c][s][r]=best_delta;
}
}
}
indNormzlizersInitialized_ = true;
write_prm_normalizer_values();
}
/***************************************************************************************
This function touches up inspect search results by rescoring the sequences returned by
inspect. The function produces a new inspect results file with the scores (and delta scores)
replaced.
****************************************************************************************/
void PeptideRankScorer::rescore_inspect_results(char *spectra_file,
char *inspect_res,
char *new_res_file) const
{
AllScoreModels* allScoreModels = static_cast<AllScoreModels*>(this->allScoreModelsPtr_);
Config *config = allScoreModels->get_config();
ifstream org_res(inspect_res);
if (! org_res.is_open() || ! org_res.good())
{
cout << "Error: couldn't open original inspect results file for reading:" << inspect_res << endl;
exit(1);
}
ofstream new_res(new_res_file);
if (! new_res.is_open() || ! new_res.good())
{
cout << "Error: couldn't open new inspect results file for writing:" << new_res << endl;
exit(1);
}
char line_buff[1024];
org_res.getline(line_buff,1024);
bool read_line = true;
vector<string> field_names;
if (line_buff[0] != '#')
{
read_line = false;
}
else
{
string header = string(line_buff);
split_string(header,field_names);
// int i;
// for (i=0; i<field_names.size(); i++)
// cout << i << "\t" << field_names[i] << endl;
cout << "Header:" << endl << line_buff << endl;
}
vector<ScanCandidateSet> cand_sets;
vector<int> scan_mapping;
cand_sets.clear();
scan_mapping.resize(100000,-1);
while (! org_res.eof())
{
vector<string> fields;
if (read_line)
{
org_res.getline(line_buff,1024);
if (org_res.gcount() < 5)
continue;
}
else
{
read_line = true;
}
split_string(line_buff,fields);
InspectResultsLine res;
res.parse_from_fields(config,fields);
if (cand_sets.size()==0 || ! cand_sets[cand_sets.size()-1].add_new_line(res))
{
ScanCandidateSet new_set;
new_set.add_new_line(res);
if (new_set.scan>=scan_mapping.size())
scan_mapping.resize(2*scan_mapping.size(),-1);
scan_mapping[new_set.scan]=cand_sets.size();
cand_sets.push_back(new_set);
}
}
org_res.close();
cout << "Read results for " << cand_sets.size() << " scans..." << endl;
SpectraAggregator sa;
sa.initializeFromSpectraFilePath(spectra_file, config);
SpectraList sl(sa);
sl.selectAllAggregatorHeaders();
cout << "Read " << sl.getNumHeaders() << " spectra headers." << endl;
if (sl.getNumHeaders() == 0)
{
cout << "Error: read not spectra headers from " << spectra_file << endl;
return;
}
vector<bool> spectrum_indicators;
spectrum_indicators.resize(cand_sets.size(),false);
int num_found =0;
int sc;
for (sc=0; sc<sl.getNumHeaders(); sc++)
{
const SingleSpectrumHeader* header = sl.getSpectrumHeader(sc);
int scan_number = (header->getScanNumber() >=0 ? header->getScanNumber() : header->getIndexInFile());
if (header->getFileType() == IFT_MGF)
scan_number = header->getIndexInFile();
assert(scan_number>=0);
if (scan_mapping[scan_number]<0)
continue;
AnnotatedSpectrum as;
if (! as.readSpectrum(sa, header))
{
continue;
}
spectrum_indicators[scan_mapping[scan_number]]=true;
num_found++;
ScanCandidateSet& cand_set = cand_sets[scan_mapping[scan_number]];
vector<PeptideSolution> peptide_sols;
peptide_sols.resize(cand_set.results.size());
int j;
for (j=0; j<cand_set.results.size(); j++)
{
InspectResultsLine& inspect_res = cand_set.results[j];
PeptideSolution& sol = peptide_sols[j];
sol.pep = inspect_res.pep;
sol.pm_with_19 = sol.pep.get_mass_with_19();
sol.charge = inspect_res.Charge;
sol.reaches_n_terminal = true;
sol.reaches_c_terminal = true;
}
vector<score_pair> scores;
// score_complete_sequences(peptide_sols,ssf,peaks,num_peaks,scores);
scoreCompleteSequences(peptide_sols, as, scores);
for (j=0; j<scores.size(); j++)
cand_set.results[j].Score = scores[j].score;
cand_set.recalbirate_scores(config);
vector<string> pep_strings;
pep_strings.resize(scores.size());
int max_len =0;
for (j=0; j<cand_set.results.size(); j++)
{
pep_strings[j]=cand_set.results[j].pep.as_string(config);
if (pep_strings[j].length()>max_len)
max_len = pep_strings[j].length();
}
if (1)
{
cand_set.output_to_stream(new_res,10);
}
else
{
for (j=0; j<cand_set.results.size(); j++)
{
cout << cand_set.scan << " " << cand_set.results[j].Charge << "\t";
cout << cand_set.results[j].Protein.substr(0,3) << " " << pep_strings[j];
if (pep_strings[j].length()<max_len)
{
int k;
for (k=pep_strings[j].length(); k<max_len; k++)
cout << " ";
}
cout << "\t" << cand_set.results[j].MQScore << "\t" << cand_set.results[j].Score << "\t" <<
cand_set.results[j].DeltaScore << "\t" << cand_set.results[j].DeltaScoreOther << endl;
}
cout << endl;
}
}
if (num_found<cand_sets.size())
{
cout << "Warning: found only " << num_found << "/" << cand_sets.size() << " of the scans scored by InsPecT!" << endl;
}
else
{
cout << "All scored scans found in spectrum file." << endl;
}
}
void PrmNodeScoreModel::trainNodeScoreModels(void* allScoreModelsVoidPointer,
const char *name,
const SpectraAggregator& sa,
int specificCharge,
int specificSize,
int specificRegion)
{
AllScoreModels* allScoreModels = static_cast<AllScoreModels*>(allScoreModelsVoidPointer);
config_ = allScoreModels->get_config();
// resize regional breakage score models according to regional fragment sets
const vector< vector< vector< RegionalFragments > > >& all_rfs = config_->get_regional_fragment_sets();
int c;
RegionalPrmNodeScoreModels_.resize(all_rfs.size());
for (c=0; c<all_rfs.size(); c++)
{
RegionalPrmNodeScoreModels_[c].resize(all_rfs[c].size());
int s;
for (s=0; s<all_rfs[c].size(); s++)
{
RegionalPrmNodeScoreModels_[c][s].resize(all_rfs[c][s].size());
int r;
for (r=0; r<RegionalPrmNodeScoreModels_[c][s].size(); r++)
if (! RegionalPrmNodeScoreModels_[c][s][r].get_was_initialized())
RegionalPrmNodeScoreModels_[c][s][r].init(config_,c,s,r);
}
}
// train models
for (c=1; c<RegionalPrmNodeScoreModels_.size(); c++)
{
if (RegionalPrmNodeScoreModels_.size() == 0 || (specificCharge>0 && specificCharge != c))
continue;
if (sa.getNumSpectraWithCharge(c)<200)
{
cout << "WARNING: insufficient number of spectra to train breakage model for charge " << c << endl;
cout << " only " << sa.getNumSpectraWithCharge(c) << " spectra were found so this charge is being skipped!" << endl << endl;
continue;
}
int s;
for (s=0; s<RegionalPrmNodeScoreModels_[c].size(); s++)
{
if (specificSize>=0 && s != specificSize)
continue;
int r;
for (r=0; r<RegionalPrmNodeScoreModels_[c][s].size(); r++)
{
if (specificRegion>=0 && r != specificRegion)
continue;
RegionalPrmNodeScoreModels_[c][s][r].trainRegionalScoreModel(allScoreModelsVoidPointer, name, sa);
}
}
}
// train PRM normalizer values
// cout << endl << "Training PRM normalizer vlaues..." << endl;
// TODO fix this issue, it needs to use the AllScoreModels class
// learn_prm_normalizer_values(fm);
ind_was_initialized=true;
}
