advancedscoremodel_fill.cpp

MS-Clustering is designed to rapidly cluster large MS/MS datasets. The program merges similar spectr

						else if (min_dis<150)
						{
							f_vals.push_back(fval(SI_SE_IND_C_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SI_SE_IND_C_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));
				
						if (c_diff<exact_peak_tolerance)
						{
							f_vals.push_back(fval(SI_SE_IND_C_FRAG_DIFF_01,1.0));
						}
						else if (c_diff<frag_tolerance)
						{
							f_vals.push_back(fval(SI_SE_IND_C_FRAG_DIFF_05,1.0));
						}
						else
							f_vals.push_back(fval(SI_SE_IND_C_FRAG_DIFF_LARGE,1.0));

						const float diff_inten = peak.log_intensity - c_peak.log_intensity;
						f_vals.push_back(fval(SI_SE_IND_C_N_TERM_DIFF_INTEN,diff_inten));
						f_vals.push_back(fval(SI_SE_IND_C_N_TERM_DIFF_INTEN+c_aa,diff_inten));
					}
					else
					{
						f_vals.push_back(fval(SI_SE_IND_HAS_NO_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SI_SE_IND_C_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SI_SE_IND_C_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SI_SE_IND_C_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
				else // multiple edge
				{
					f_vals.push_back(fval(SI_IND_C_ME,1.0));
					if (c_pos>=0)
					{
						const Peak& c_peak = spec->get_peak(info->c_break->fragments[c_pos].peak_idx);
						const mass_t c_diff = fabs(fabs((peak.mass - c_peak.mass)* model_frag_charge) - info->exp_c_edge_mass);

						f_vals.push_back(fval(SI_ME_IND_HAS_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_50_WINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));
				
						if (c_diff<exact_peak_tolerance)
						{
							f_vals.push_back(fval(SI_ME_IND_C_FRAG_DIFF_01,1.0));
						}
						else if (c_diff<frag_tolerance)
						{
							f_vals.push_back(fval(SI_ME_IND_C_FRAG_DIFF_05,1.0));
						}
						else
							f_vals.push_back(fval(SI_ME_IND_C_FRAG_DIFF_LARGE,1.0));
					}
					else
					{
						f_vals.push_back(fval(SI_ME_IND_HAS_NO_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SI_ME_IND_C_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
			}
		}
	}
	else  // fill features for no intensity
	{
		if (! do_n_features)
			f_vals.push_back(fval(SNI_IND_N_IS_GAP,1.0));
		
		if (! do_c_features)
			f_vals.push_back(fval(SNI_IND_C_IS_GAP,1.0));

		// aa category feature
		if (do_n_features)
		{
			int k;
			for (k=0; k<threshes.size(); k++)
				if (info->n_side_cat>threshes[k])
					break;
			if (info->connects_to_N_term)
			{
				f_vals.push_back(fval(SNI_N_TERM_CAT20+k,1.0));
			}
			else
				f_vals.push_back(fval(SNI_N_EDGE_CAT20+k,1.0));

			for (k=0; k<threshes.size(); k++)
				if (info->c_side_cat>threshes[k])
					break;
		}

		if (do_c_features)
		{
			int k;
			for (k=0; k<threshes.size(); k++)
				if (info->c_side_cat>threshes[k])
					break;

			if (info->connects_to_C_term)
			{
				f_vals.push_back(fval(SNI_C_TERM_CAT20+k,1.0));
			}
			else
				f_vals.push_back(fval(SNI_C_EDGE_CAT20+k,1.0));

			for (k=0; k<threshes.size(); k++)
				if (info->span_cat>threshes[k])
					break;
		
			if (do_n_features)
			{
				f_vals.push_back(fval(SNI_SPAN_CAT20+k,1.0));

				if (info->n_double_span_cat>NEG_INF)
				{
					int k;
					for (k=0; k<threshes.size(); k++)
						if (info->n_double_span_cat>threshes[k])
							break;
					f_vals.push_back(fval(SNI_ND_SPAN_CAT20+k,1.0));
				}

				if (info->c_double_span_cat>NEG_INF)
				{
					int k;
					for (k=0; k<threshes.size(); k++)
						if (info->c_double_span_cat>threshes[k])
							break;
					f_vals.push_back(fval(SNI_CD_SPAN_CAT20+k,1.0));
				}
			}
		}

		if (do_n_features)
		{
			if (info->connects_to_N_term)
				f_vals.push_back(fval(SNI_IND_CONNECTS_TO_N_TERM,1.0));

			if (info->preferred_digest_aa_N_term)
				f_vals.push_back(fval(SNI_IND_PREFERRED_DIGEST_AA_N_TERM,1.0));
		}

		if (do_c_features)
		{
			if (info->connects_to_C_term)
				f_vals.push_back(fval(SNI_IND_CONNECTS_TO_C_TERM,1.0));

			if (info->preferred_digest_aa_C_term)
				f_vals.push_back(fval(SNI_IND_PREFERRED_DIGEST_AA_C_TERM,1.0));
		}


		if (! info->connects_to_N_term && ! info->connects_to_C_term)
			f_vals.push_back(fval(SNI_IND_NOT_CONNECTED_TO_TERMS,1.0));

		if (info->missed_cleavage)
			f_vals.push_back(fval(SNI_IND_MISSED_CLEAVAGE,1.0));
	

		if (do_n_features)
		{
			if (! info->n_break || ! info->n_break->is_frag_type_visible(model_frag_idx))
			{
				f_vals.push_back(fval(SNI_IND_N_NOT_VIZ,1.0));
			}
			else
			{
				f_vals.push_back(fval(SNI_IND_N_N_TERM,1.0));
				f_vals.push_back(fval(SNI_IND_N_N_TERM+n_aa,1.0));
			
				const int n_pos=info->n_break->get_position_of_frag_idx(model_frag_idx);
				if (n_pos>=0)
				{
					f_vals.push_back(fval(SNI_IND_N_INTEN,1.0));
				}
				else
					f_vals.push_back(fval(SNI_IND_N_NO_INTEN,1.0));

				const mass_t dis_min = exp_n_peak_mass - spec->get_min_peak_mass();
				const mass_t dis_max = spec->get_max_peak_mass() - exp_n_peak_mass;
				const mass_t min_dis = (dis_min<dis_max ? dis_min : dis_max);

				if (info->n_edge_is_single)
				{
					f_vals.push_back(fval(SNI_IND_N_SE,1.0));
					if (n_pos>=0)
					{
						const Peak& n_peak = spec->get_peak(info->n_break->fragments[n_pos].peak_idx);

						f_vals.push_back(fval(SNI_SE_IND_HAS_N_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_50_WINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));

						f_vals.push_back(fval(SNI_SE_IND_N_N_TERM_DIFF_INTEN,n_peak.log_intensity));
						f_vals.push_back(fval(SNI_SE_IND_N_N_TERM_DIFF_INTEN+n_aa,n_peak.log_intensity));
					}
					else
					{
					
						f_vals.push_back(fval(SNI_SE_IND_HAS_NO_N_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_SE_IND_N_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
				else // multiple edge
				{
					f_vals.push_back(fval(SNI_IND_N_ME,1.0));
					if (n_pos>=0)
					{
						f_vals.push_back(fval(SNI_ME_IND_HAS_N_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_50_WINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));
					}
					else
					{
						f_vals.push_back(fval(SNI_ME_IND_HAS_NO_N_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_ME_IND_N_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
			}
		}


		if (do_c_features)
		{
			if (! info->c_break || ! info->c_break->is_frag_type_visible(model_frag_idx))
			{
				f_vals.push_back(fval(SNI_IND_C_NOT_VIZ,1.0));
			}
			else
			{
				f_vals.push_back(fval(SNI_IND_C_N_TERM,1.0));
				f_vals.push_back(fval(SNI_IND_C_N_TERM+c_aa,1.0));
			
				const int c_pos=info->c_break->get_position_of_frag_idx(model_frag_idx);
				if (c_pos>=0)
				{
					f_vals.push_back(fval(SNI_IND_C_INTEN,1.0));
				}
				else
					f_vals.push_back(fval(SNI_IND_C_NO_INTEN,1.0));

				const mass_t dis_min = exp_c_peak_mass - spec->get_min_peak_mass();
				const mass_t dis_max = spec->get_max_peak_mass() - exp_c_peak_mass;
				const mass_t min_dis = (dis_min<dis_max ? dis_min : dis_max);

				if (info->c_edge_is_single)
				{
					f_vals.push_back(fval(SNI_IND_C_SE,1.0));
					if (c_pos>=0)
					{
						const Peak& c_peak = spec->get_peak(info->c_break->fragments[c_pos].peak_idx);
					
						f_vals.push_back(fval(SNI_SE_IND_HAS_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_50_WINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));

						f_vals.push_back(fval(SNI_SE_IND_C_N_TERM_DIFF_INTEN,c_peak.log_intensity));
						f_vals.push_back(fval(SNI_SE_IND_C_N_TERM_DIFF_INTEN+c_aa,c_peak.log_intensity));
					}
					else
					{
					
						f_vals.push_back(fval(SNI_SE_IND_HAS_NO_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_SE_IND_C_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
				else // multiple edge
				{
					f_vals.push_back(fval(SNI_IND_C_ME,1.0));
					if (c_pos>=0)
					{
						f_vals.push_back(fval(SNI_ME_IND_HAS_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_50_WINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_150_WINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_250_WINTEN,1.0));
					}
					else
					{
						f_vals.push_back(fval(SNI_ME_IND_HAS_NO_C_FRAG_INTEN,1.0));
						if (min_dis<50)
						{
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_50_NOINTEN,1.0));
						} 
						else if (min_dis<150)
						{
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_150_NOINTEN,1.0));
						} 
						else if (min_dis<250)
							f_vals.push_back(fval(SNI_ME_IND_C_DIS_FROM_MINMAX_LESS_250_NOINTEN,1.0));
					}
				}
			}
		}
	}
}



void RegularFragModel::fill_constant_vals(
							Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage, 
							vector<fval>& f_vals) const
{
	const int num_parents = parent_idxs.size();
	FragStats frag_stats;
	vector<FragStats> parent_frag_stasts;

	parent_frag_stasts.resize(num_parents);
	frag_stats.fill_from_breakage(breakage,spec,model_frag_idx);
	int i;
	for (i=0; i<num_parents; i++)
		parent_frag_stasts[i].fill_from_breakage(breakage,spec,parent_idxs[i]);
	
	f_vals.clear();

	if (frag_stats.has_intensity) // fill features for visible fragment
	{
		f_vals.push_back(fval(RI_CONST,1.0));

		const float log_inten = frag_stats.log_intensity;
		f_vals.push_back(fval(RI_LOG_LOCAL_RANK,frag_stats.log_local_rank));
		f_vals.push_back(fval(RI_LOG_GLOBAL_RANK,frag_stats.log_global_rank));
		if (frag_stats.iso_level != 0)
			f_vals.push_back(fval(RI_ISO_LEVEL,frag_stats.iso_level));

		if (log_inten<1.0)
		{
			f_vals.push_back(fval(RI_IND_LOG_INTEN_LESS1,1.0));
			f_vals.push_back(fval(RI_LOG_INTEN_LESS1,log_inten));
		} 
		else if (log_inten<2.0)
		{