metabolicnetwork.h

Go to the documentation of this file.

#include <vector>
#include <string>
#include <map>
#include <iostream>
#include <fstream>   // file I/O
#include <sstream>
#include <stdlib.h>
#include <iomanip>
#include <algorithm>
#include <time.h>
#include "options.h"
#include "bitefm.h"

using namespace std;

#ifndef METABOLIC_NETWORK_H
#define METABOLIC_NETWORK_H


class MetabolicNetwork {

        protected:
                vector< vector<double> > core_efms;     
                vector< vector<double> > efm_yields;    
                vector<string> reacs_names;                     
                map<string,int> target_names;                   
                map<string,int> substrate_names;                
                map<string,int> init_knocks_names;              
                map<string,int> transport_names;                
                map<string,double> yields, max_yields;
                Options options;                                        
                //string efm_fname; //, reac_fname,target_fname,yield_fname, substrate_fname, init_knocks_fname, core_yield_fname;
                long num_modes;

                int num_reacs, num_metabs; 
                int compressed_mode;
                //indices of efficient and inefficient modes (by yields, max_yields)  in efms matrix
                vector<long> eff_efm_indices; 
                vector<long> ineff_efm_indices; 
                vector<long> knock_cand_reacs;

                vector<double> core_min_yields;         
                vector<long> core_efm_indices;
                BitEfm bit_efm;
        public:
                MetabolicNetwork();
                MetabolicNetwork(MetabolicNetwork &metab_network);
                MetabolicNetwork(Options options);

                BitEfm& get_bit_efm() { return this->bit_efm;}
                int get_num_reacs();
                unsigned long get_num_modes();
                vector<string>& get_reacs_names() { return this->reacs_names;}
                map<string,int>& get_substrate_names() {return this->substrate_names;}
                map<string,int>& get_target_names() {return this->target_names;}
                map<string,int>& get_transport_names() {return this->transport_names;}
                map<string,int>& get_init_knocks_names() {return this->init_knocks_names;}

                map<string,double>& get_yields() {return this->yields;}
                map<string,double>& get_max_yields() {return this->max_yields;}

                //vector< vector<double> >& get_efms() { return this->efms;}
                vector< vector<double> >& get_core_efms() { return this->core_efms;}
                vector< vector<double> >& get_efm_yields() { return this->efm_yields; }

                vector<long>& get_eff_efm_indices() { return this->eff_efm_indices;}    
                vector<long>& get_ineff_efm_indices() { return this->ineff_efm_indices;}        
                vector<long>& get_core_efm_indices() {return this->core_efm_indices;}
                vector<long>& get_knock_cand_reacs() {return this->knock_cand_reacs;}
                Options& get_options() {return this->options; }

                int init_efm_yields();
                int init_max_yields();
                int init_yields();

                int load_efm_full(string efm_bit_fname, t_UnsignedInt  num_ems, vector< vector<double> > &stoich);
                double get_efm_elem(unsigned long index, int reac);
                int remove_zero_substrate_modes();
                int extract_production_eff_efms();
                int extract_growth_eff_and_ineff_modes();
                int is_efm_elem_zero(unsigned long index, int reac, int &is_zero);
                int is_core_efms_collapsed(map<int,string> knock_reacs,int &cnt_not_collapsed);

};


#endif