readBooleanRegModel

PURPOSE ^

readBooleanRegModel Read Boolean regulatory network model

SYNOPSIS ^

function regModel = readBooleanRegModel(metModel,fileName)

DESCRIPTION ^

readBooleanRegModel Read Boolean regulatory network model

 regModel = readBooleanRegModel(metModel,fileName)

INPUT
 metModel

OPTIONAL INPUT
 fileName
 
OUTPUT
 regModel      model containing the following fields:

 regModel.mets   Metabolite rules
            name     Metabolite/pool name (internal to the reg network model)
            rule     Metabolite 'activation' rule
            type     Metabolite type (extra/intracellular/pool)
            excInd   Exchange flux indices corresponding to extracellular
                     metabolites
            icmRules Intracellular metabolite 'activation' rules (based on
                     a flux vector - fluxVector)
            pool     Pool components
 regModel.regs    Regulator rules
            name     Regulator name
            rule     Regulator rule
            comp     Regulator rule components (i.e. metabolites or other
                     regulators that affect the state of this regulator)
            ruleParsed Rule in parsed format (based on metabolite state -
                      metState, regulator state - regState)
 regModel.tars    Target rules
            name     Target name
            rule     Target rule
            comp     Target rule components (i.e. metabolites or other
                     regulators that affect the state of this regulator)
            ruleParsed Rule in parsed format (based on metabolite state -
                     metState, regulator state - regState)

 Markus Herrgard 12/5/07

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SOURCE CODE ^

0001 function regModel = readBooleanRegModel(metModel,fileName)
0002 %readBooleanRegModel Read Boolean regulatory network model
0003 %
0004 % regModel = readBooleanRegModel(metModel,fileName)
0005 %
0006 %INPUT
0007 % metModel
0008 %
0009 %OPTIONAL INPUT
0010 % fileName
0011 %
0012 %OUTPUT
0013 % regModel      model containing the following fields:
0014 %
0015 % regModel.mets   Metabolite rules
0016 %            name     Metabolite/pool name (internal to the reg network model)
0017 %            rule     Metabolite 'activation' rule
0018 %            type     Metabolite type (extra/intracellular/pool)
0019 %            excInd   Exchange flux indices corresponding to extracellular
0020 %                     metabolites
0021 %            icmRules Intracellular metabolite 'activation' rules (based on
0022 %                     a flux vector - fluxVector)
0023 %            pool     Pool components
0024 % regModel.regs    Regulator rules
0025 %            name     Regulator name
0026 %            rule     Regulator rule
0027 %            comp     Regulator rule components (i.e. metabolites or other
0028 %                     regulators that affect the state of this regulator)
0029 %            ruleParsed Rule in parsed format (based on metabolite state -
0030 %                      metState, regulator state - regState)
0031 % regModel.tars    Target rules
0032 %            name     Target name
0033 %            rule     Target rule
0034 %            comp     Target rule components (i.e. metabolites or other
0035 %                     regulators that affect the state of this regulator)
0036 %            ruleParsed Rule in parsed format (based on metabolite state -
0037 %                     metState, regulator state - regState)
0038 %
0039 % Markus Herrgard 12/5/07
0040 
0041 if (nargin < 2)
0042     fileName = 'iMHruletest.xls';
0043 end
0044 
0045 %% Read xls file
0046 [tmp,textData] = xlsread(fileName);
0047 nameList = textData(2:end,1);
0048 ruleList = textData(2:end,2);
0049 ruleType = textData(2:end,3);
0050 
0051 %% Assign metabolite, regulator, and target rules
0052 regModel = [];
0053 
0054 metCnt = 0;
0055 regCnt = 0;
0056 tarCnt = 0;
0057 nameList = strrep(nameList,'[','_');
0058 nameList = strrep(nameList,']','');
0059 nameList = deblank(nameList);
0060 ruleList = strrep(ruleList,'[','_');
0061 ruleList = strrep(ruleList,']','');
0062 ruleList = deblank(ruleList);
0063 for i = 1:length(ruleList)
0064     ruleList{i} = strrep(ruleList{i},'if ','');
0065     switch ruleType{i}
0066         case {'xcm','icm','xcp','icp'}
0067             metCnt = metCnt + 1;
0068             regModel.mets.name{metCnt} = nameList{i};
0069             regModel.mets.rule{metCnt} = ruleList{i};
0070             if (strcmp(ruleType{i},'xcp') | strcmp(ruleType{i},'icp'))
0071                 regModel.mets.rule{metCnt} = splitString(ruleList{i},'+');
0072             end
0073             regModel.mets.type{metCnt} = ruleType{i};
0074         case {'reg','regc'}
0075             regCnt = regCnt + 1;
0076             regModel.regs.name{regCnt} = nameList{i};
0077             regModel.regs.rule{regCnt} = ruleList{i};
0078             [elements,newRule] = parseBoolean(ruleList{i});
0079             regModel.regs.comp{regCnt} = elements;
0080             regModel.regs.ruleParsed{regCnt} = newRule;
0081         case 'tar'
0082             tarCnt = tarCnt + 1;
0083             regModel.tars.name{tarCnt} = nameList{i};
0084             regModel.tars.rule{tarCnt} = ruleList{i};
0085             [elements,newRule] = parseBoolean(ruleList{i});
0086             regModel.tars.comp{tarCnt} = elements;
0087             regModel.tars.ruleParsed{tarCnt} = newRule;
0088     end
0089 end
0090 
0091 %% Parse metabolite rules
0092 
0093 regModel.mets.name = columnVector(regModel.mets.name);
0094 regModel.mets.rule = columnVector(regModel.mets.rule);
0095 regModel.mets.type = columnVector(regModel.mets.type);
0096 
0097 % Extracellular
0098 selEcMets = find(strcmp(regModel.mets.type,'xcm'));
0099 xcMets = strrep(regModel.mets.rule(selEcMets),'-','_');
0100 regModel.mets.excInd = findRxnIDs(metModel,xcMets);
0101 
0102 notInModel = xcMets(regModel.mets.excInd == 0);
0103 for i = 1:length(notInModel)
0104     if (~strcmp(notInModel{i},'NA'))
0105         fprintf([regModel.mets.name{selEcMets(i)} ': exchange rxn for ' notInModel{i} ' not in metabolic model\n']);
0106     end
0107 end
0108 
0109 % Intracellular
0110 selIcMets = find(strcmp(regModel.mets.type,'icm'));
0111 
0112 for i = 1:length(selIcMets)
0113     [elements,newRule] = parseBoolean(regModel.mets.rule{selIcMets(i)});
0114     rxnInd = findRxnIDs(metModel,elements);
0115     for j = 1:length(rxnInd)
0116         if (rxnInd(j) > 0)
0117             newRule = strrep(newRule,['x(' num2str(j) ')'],['fluxVector(' num2str(rxnInd(j)) '_TMP_)']);
0118         else
0119             if (~strcmp(elements{j},'=0'))
0120                 fprintf([regModel.mets.name{selIcMets(i)} ': rxn ' elements{j} ' not found in the metabolic model']);
0121             end
0122         end
0123     end
0124     regModel.mets.icmRules{i} = strrep(newRule,'_TMP_','');
0125 end
0126 regModel.mets.icmRules = columnVector(regModel.mets.icmRules);
0127 
0128 % Pools
0129 
0130 selPoolMets = find(strcmp(regModel.mets.type,'xcp') | strcmp(regModel.mets.type,'icp'));
0131 
0132 for i = 1:length(selPoolMets)
0133     poolMets = regModel.mets.rule{selPoolMets(i)};
0134     [isInModel,metInd] = ismember(poolMets,regModel.mets.name);
0135     notInModel = poolMets(~isInModel);
0136     for j = 1:length(notInModel)
0137         fprintf([regModel.mets.name{selPoolMets(i)} ': metabolite ' notInModel{j} ' not in regulatory network model\n']);
0138     end
0139     regModel.mets.pool{i} = metInd(isInModel == 1);
0140 end
0141 regModel.mets.pool = columnVector(regModel.mets.pool);
0142 
0143 %% Parse regulator rules
0144 
0145 regModel.regs.name = columnVector(regModel.regs.name);
0146 regModel.regs.rule = columnVector(regModel.regs.rule);
0147 regModel.regs.comp = columnVector(regModel.regs.comp);
0148 regModel.regs.ruleParsed = columnVector(regModel.regs.ruleParsed);
0149 
0150 for i = 1:length(regModel.regs.name)
0151     elements = regModel.regs.comp{i};
0152     [isMet,metInd] = ismember(elements,regModel.mets.name);
0153     [isReg,regInd] = ismember(elements,regModel.regs.name);
0154     newRule = regModel.regs.ruleParsed{i};
0155     for j = 1:length(elements)
0156         if (metInd(j) > 0)
0157             newRule = strrep(newRule,['x(' num2str(j) ')'],['metState(' num2str(metInd(j)) '_TMP_)']);
0158         elseif (regInd(j) > 0)
0159             newRule = strrep(newRule,['x(' num2str(j) ')'],['regState(' num2str(regInd(j)) '_TMP_)']);
0160         else
0161             if (~strcmp(elements{j},'NA'))
0162                 fprintf([regModel.regs.name{i} ': metabolite or regulator ' elements{j} ' not found in the model\n']);
0163             end
0164             newRule = '';
0165         end
0166     end
0167     regModel.regs.ruleParsed{i} = strrep(newRule,'_TMP_','');
0168 end
0169 
0170 %% Parse target rules
0171 
0172 regModel.tars.name = columnVector(regModel.tars.name);
0173 regModel.tars.rule = columnVector(regModel.tars.rule);
0174 regModel.tars.comp = columnVector(regModel.tars.comp);
0175 regModel.tars.ruleParsed = columnVector(regModel.tars.ruleParsed);
0176 
0177 for i = 1:length(regModel.tars.name)
0178     elements = regModel.tars.comp{i};
0179     [isMet,metInd] = ismember(elements,regModel.mets.name);
0180     [isReg,regInd] = ismember(elements,regModel.regs.name);
0181     newRule = regModel.tars.ruleParsed{i};
0182     for j = 1:length(elements)
0183         if (metInd(j) > 0)
0184             newRule = strrep(newRule,['x(' num2str(j) ')'],['metState(' num2str(metInd(j)) '_TMP_)']);
0185         elseif (regInd(j) > 0)
0186             newRule = strrep(newRule,['x(' num2str(j) ')'],['regState(' num2str(regInd(j)) '_TMP_)']);
0187         else
0188             if (~strcmp(elements{j},'NA'))
0189                 fprintf([regModel.tars.name{i} ': metabolite or regulator ' elements{j} ' not found in the model\n']);
0190             end
0191             newRule = '';
0192         end
0193     end
0194     regModel.tars.ruleParsed{i} = strrep(newRule,'_TMP_','');
0195 end

Generated on Thu 21-Jun-2012 15:39:23 by m2html © 2003