advancedscoremodel.h

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

	bool read_model(istream& is, bool silent_ind);

	bool write_model (ostream& os) const;


	void fill_combo_vectors(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage,
							const vector<BreakageInfo>& infos,
							vector< ME_Regression_Sample > & samples) const;

	void fill_single_frag_vector(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage,
							BreakageInfo& info,
							vector< fval >& f_vals) const;

private:
	int mirror1_idx,  mirror2_idx;
	int parent1_idx,  parent2_idx;

	int mirror1_charge, mirror2_charge, parent1_charge, parent2_charge;

	
	void fill_constant_vals(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage, 
							vector<fval>& f_vals) const;

	void fill_aa_variable_vals( Spectrum *spec, 
							   mass_t pm_with_19,  
							   const Breakage *breakage,
							   const BreakageInfo* info,
							   vector<fval>& f_vals) const;
};


/************************************************************************
Model for fragments not designated "strong" in the regional fragments.
*************************************************************************/
class RegularFragModel : public FragModel {
	friend class RegionalScoreModel;
public:
	RegularFragModel() : num_parents(0), parent_idx_with_same_charge_ori(-1) {}
	
	bool read_model(istream& is, bool silent_ind);
	bool write_model (ostream& os) const;


	void fill_combo_vectors(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage,
							const vector<BreakageInfo>& infos,
							vector< ME_Regression_Sample > & samples) const;

	void fill_single_frag_vector(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage,
							BreakageInfo& info,
							vector< fval >& f_vals) const;


private:
	int num_parents;
	int parent_idx_with_same_charge_ori;

	vector<int> parent_idxs;

	void fill_constant_vals(Spectrum *spec, 
							mass_t pm_with_19,  
							const Breakage *breakage, 
							vector<fval>& f_vals) const;

	void fill_aa_variable_vals( Spectrum *spec, 
							   mass_t pm_with_19,  
							   const Breakage *breakage,
							   const BreakageInfo* info,
							   vector<fval>& f_vals) const;
};


/*****************************************************************************
Scoring model for a specific region (charge / size_idx / region_idx).
Contains a FragModel for each fragment used for scoring in that region.
******************************************************************************/
class RegionalScoreModel
{
	friend class AdvancedScoreModel;
public:
	RegionalScoreModel() : charge(NEG_INF), size_idx(NEG_INF), region_idx(NEG_INF),
								   num_strong_frags(0), num_regular_frags(0), config(NULL),
								   was_initialized(false), has_all_breakage_models(false),
								   rand_prob(0), log_random(0), log_one_minus_random(0), 
								   missing_breakage_score(0) {};

	void init(Config* _c, int _charge, int _size_idx, int _region_idx);

	bool read_regional_score_model(const char *name, bool silent_ind);

	bool write_regional_score_model(const char *name) const;

	bool train_regional_score_model(Model *model, const char *name, const FileManager& fm);

	void calc_constant_element(Node& node,
							   Spectrum *spec, 
							   mass_t pm_with_19,  
							   const Breakage *breakage) const;

	score_t score_a_single_breakage_combo(
							   PrmGraph *prm,
							   Node& node, 
							   const Breakage *breakage,
							   BreakageInfo& info,
							   bool verbose=false) const;

	string make_model_file_name(const char *name) const;

	// Scores a breakage using a Dancik-like scoring model (independent frag probs vs. random)
	float basic_score_breakage(Breakage *breakage) const;

	const FragModel *get_frag_model(int frag_idx) const
	{
		int i;
		for (i=0; i<strong_models.size(); i++)
			if (strong_models[i].model_frag_idx == frag_idx)
				return &strong_models[i];

		for (i=0; i<regular_models.size(); i++)
			if (regular_models[i].model_frag_idx == frag_idx)
				return &regular_models[i];
		return NULL;
	}

	score_t get_frag_prob(int frag_type_idx) const
	{
		int i;
		for (i=0; i<frag_type_idxs.size(); i++)
			if (frag_type_idxs[i]==frag_type_idx)
				return frag_probs[i];
		return NEG_INF;
	}

private:
	int charge, size_idx, region_idx;
	int num_strong_frags;
	int num_regular_frags;
	Config *config;

	bool was_initialized;
	bool has_all_breakage_models;

	vector<StrongFragModel>  strong_models;
	vector<RegularFragModel> regular_models;

	// weights on how much to emphasize the FragModel vs. the Dancik prob 
	vector<float> strong_inten_weights,  strong_no_inten_weights;
	vector<float> regular_inten_weights, regular_no_inten_weights;

	// holds the (1-weight) * frag prob to be weight*model prob for the acutal probability
	vector<float> strong_inten_danc_part,  strong_no_inten_danc_part;
	vector<float> regular_inten_danc_part, regular_no_inten_danc_part;

	// basic score probs
	vector<int>     frag_type_idxs;
	vector<score_t> frag_probs;
	score_t		    rand_prob;
	score_t log_random; 
	score_t log_one_minus_random; 

	vector<score_t> frag_inten_scores;
	vector<score_t> frag_no_inten_scores;
	score_t			missing_breakage_score;

	void create_training_set(Model *model,
							 const FragModel& frag_model,
							 const FileManager& fm,
							 ME_Regression_DataSet& inten_ds,
							 ME_Regression_DataSet& no_inten_ds) const;

};




/*****************************************************************************
General scorin model.
Holds models of all regions.
This is the class used to interface with other classes (PrmGraph, etc.)
******************************************************************************/
class AdvancedScoreModel : public Model {
public:

	void train_score_model(const char *name, const FileManager& fm, 
						   int charge=-1, int size_idx=-1, int region_idx=-1);
	
	void score_all_node_combos(PrmGraph *prm) const;

	void initial_combos_score(PrmGraph *prm) const;

	void score_peptide_node_combos(PrmGraph *prm, const Peptide& peptide ) const;

	// performs scoring on demand (if the combo was not previously scored, calculates
	// values, otherwise returns hashed value
	score_t get_node_combo_score(PrmGraph *prm, int node_idx, 
								 int in_edge_idx, int in_var_idx, 
								 int out_edge_idx, int out_var_idx) const;
	// required Model functions
	void init_score_model() { return; }

	void init_model_for_scoring_spectrum(Spectrum *spec) { return; }

	//  simple score (Dancik style)
	void score_breakage(Spectrum *spec, Breakage *breakage, bool verbose=false) const;
	
	score_t get_missing_breakage_score(int charge, int size_idx, int region_idx) const
	{
		return this->regional_breakage_score_models[charge][size_idx][region_idx].missing_breakage_score;
	}

	void score_graph_edges(PrmGraph& prm) const;

	int get_max_score_model_charge() const;

	void *get_rank_model_ptr(int type) { return rank_models[type]; }

	void *get_rank_tag_model_ptr(int length) { return rank_tag_models[length]; }

	void read_rank_models(const char *name, bool silent_ind = false);

protected:

	vector< vector< vector< RegionalScoreModel > > > regional_breakage_score_models;

	void *rank_models[3];

	void *rank_tag_models[10];

	void read_score_model(const char *name, bool silent_ind = false);
	
	void write_score_model(const char *name) const;


};






#endif