Reconstruction#

MATLAB functions in RAVEN/src/reconstruction of the RAVEN toolbox.

Functions#

Function

Summary

buildGlobalGPR

Join the genes of all KEGG organisms to reference reactions by KO id.

buildGlobalKEGGModel

Download and assemble the global KEGG model.

getBlast

Bidirectional BLAST between an organism and template organisms.

getDiamond

Bidirectional BLAST with DIAMOND against template organisms.

getKEGGModelForOrganism

Reconstruct a model from KEGG protein homology.

getModelFromHomology

Construct a new model from existing models and homology.

getModelFromKEGG

Load the global KEGG model.

getPhylDist

Load the pre-built KEGG phylogenetic distance matrix.

guessComposition

Guess the composition of metabolites without one.

hitsFromSuppOrth

Read SuppOrth consensus orthologs into a blastStructure.

keggDataVersion

The toolbox-assets release tag for KEGG artefacts.

makeFakeBlastStructure

Make a fake blastStructure from an ortholog list.

readKEGGTable

Read a gzipped KEGG relational table into a table of cellstr columns.

runSuppOrth

Run SuppOrth on an organism and template proteomes.

Reference#

buildGlobalGPR#

function [genes,rxnGeneMat]=buildGlobalGPR(rxns,koReaction,organismGeneKO)

Join the genes of all KEGG organisms to reference reactions by KO id.

Joins every KEGG organism's genes onto the reference reactions through their shared KO (KEGG Orthology) ids. The function builds two sparse incidence matrices (gene to KO and KO to reaction) that share one KO axis, and multiplies them. The join is not expanded row by row, because organismGeneKO can contain millions of rows (every gene of every KEGG organism).

Parameters

rxns : cell array

the reference model's reaction ids (model.rxns), in model order.

koReaction : table

the ko_reaction table (columns 'ko', 'reaction') from readKEGGTable.

organismGeneKO : table

the organism_gene_ko table (columns 'organism', 'gene', 'ko') from readKEGGTable.

Returns

genes : cell array

sorted unique 'organism:gene' identifiers.

rxnGeneMat : sparse double

numel(rxns) by numel(genes); rxnGeneMat(i,j)=1 when gene j shares at least one KO with reaction i.

buildGlobalKEGGModel#

function [model,KOModel,isSpontaneous,isUndefinedStoich,isIncomplete,isGeneral]=buildGlobalKEGGModel(ravenPath)

Download and assemble the global KEGG model.

Fetches the toolbox-assets _core.tar.gz bundle (the gene-free reference model plus the ko_reaction, organism_gene_ko and rxn_flags relational tables), then joins every organism's genes onto the reference reactions through their shared KO ids. The KEGG version is read from keggDataVersion.

Parameters

ravenPath : char

the RAVEN root directory, as returned by findRAVENroot.

Returns

model : struct

the full global KEGG model (all reactions and metabolites, genes and rxnGeneMat spanning every KEGG organism). getKEGGModelForOrganism narrows it to one organism.

KOModel : struct

a minimal model struct whose rxns are the KO ids linked to at least one reaction (getKEGGModelForOrganism's HMM-search path uses this as a KO id lookup table; nothing else of KOModel is read).

isSpontaneous, isUndefinedStoich, isIncomplete, isGeneral : cell arrays

reaction ids carrying the corresponding rxn_flags quality flag.

getBlast#

function [blastStructure,blastReport]=getBlast(organismID,fastaFile,...
    modelIDs,refFastaFiles,varargin)

Bidirectional BLAST between an organism and template organisms.

Parameters

organismID : char

the id of the organism of interest. This should also match with the id supplied to getModelFromHomology.

fastaFile : char

a FASTA file with the protein sequences for the organism of interest.

modelIDs : cell

a cell array of model ids. These must match the "model.id" fields in the "models" structure if the output is to be used with getModelFromHomology.

refFastaFiles : cell

a cell array with the paths to the corresponding FASTA files.

Name-Value Arguments

developMode : logical

true if blastReport is filled, as used in the unit test for BLAST+ (default false).

hideVerbose : logical

true if no status messages should be printed (default false).

Returns

blastStructure : struct

structure array with one element per search direction and template organism (2 times the number of modelIDs), containing the bidirectional homology measurements (fromId, toId, fromGenes, toGenes, evalue, identity, aligLen, bitscore and ppos) for use by getModelFromHomology.

blastReport : struct

structure containing MD5 hashes for FASTA database files and unparsed BLAST output data. The fields are empty if developMode is false.

Notes

This function calls BLAST+ to perform a bidirectional homology test between the organism of interest and a set of other organisms using standard settings. The only filtering this function applies is the removal of hits with an E-value higher than 10e-5.

Examples

[blastStructure,blastReport] = getBlast(organismID,fastaFile,...
   modelIDs,refFastaFiles,developMode,hideVerbose);

See also

getModelFromHomology, getDiamond, runSuppOrth

getDiamond#

function [blastStructure,diamondReport]=getDiamond(organismID,fastaFile,...
    modelIDs,refFastaFiles,varargin)

Bidirectional BLAST with DIAMOND against template organisms.

Parameters

organismID : char

the id of the organism of interest. This should also match with the id supplied to getModelFromHomology.

fastaFile : char

a FASTA file with the protein sequences for the organism of interest.

modelIDs : cell

a cell array of model ids. These must match the "model.id" fields in the "models" structure if the output is to be used with getModelFromHomology.

refFastaFiles : cell

a cell array with the paths to the corresponding FASTA files.

Name-Value Arguments

developMode : logical

true if diamondReport is filled, as used in the unit test for DIAMOND (default false).

hideVerbose : logical

true if no status messages should be printed (default false).

Returns

blastStructure : struct

structure array with one element per search direction and template organism (2 times the number of modelIDs), containing the bidirectional homology measurements (fromId, toId, fromGenes, toGenes, evalue, identity, aligLen, bitscore and ppos) for use by getModelFromHomology.

diamondReport : struct

structure containing MD5 hashes for FASTA database files and unparsed DIAMOND output data. The fields are empty if developMode is false.

Notes

This function calls DIAMOND to perform a bidirectional homology search between the organism of interest and a set of other organisms using the "--more-sensitive" setting from DIAMOND. getBlast() gives the most sensitive results; getDiamond() is >15x faster. The blastStructure is in the same format as that obtained from getBlast().

Examples

[blastStructure,diamondReport] = getDiamond(organismID,fastaFile,...
   modelIDs,refFastaFiles,developMode,hideVerbose);

See also

getModelFromHomology, getBlast, runSuppOrth

getKEGGModelForOrganism#

function model=getKEGGModelForOrganism(organismID,varargin)

Reconstruct a model from KEGG protein homology.

Reconstructs a genome-scale metabolic model based on protein homology to the orthologies in KEGG. If the target species is not available in KEGG, the function stops with an error; give a closely related species as organismID. Without a fastaFile, the protein homology search is skipped (see the fastaFile parameter).

Parameters

organismID : char

three or four letter abbreviation of the organism (as used in KEGG). If the organism is not available, a closely related species can be given. The abbreviation determines the genes that are kept when fastaFile is empty. "eukaryotes" or "prokaryotes" gives a model for the whole domain. Only applicable if fastaFile is empty, that is when no homology search is performed.

Name-Value Arguments

fastaFile : char

a FASTA file that contains the protein sequences of the organism for which to reconstruct a model. If no FASTA file is supplied then a model is reconstructed based only on the organism abbreviation. In this case, cutOff, minScoreRatioKO, minScoreRatioG and dataDir are not used (default []).

dataDir : char

directory of the HMM library, named kegg118_prokaryotes or kegg118_eukaryotes. The name gives the KEGG version and whether the HMMs were trained on pro- or eukaryotic sequences, and matches the published HMM library it is paired with. The prebuilt concatenated KO HMM library (dataDir.hmm) is downloaded from the corresponding toolbox-assets release if it is not already present. Required when fastaFile is supplied (default []).

outDir : char

directory that is created if it does not exist when fastaFile is supplied. The function writes no result files to it (default is the temporary directory, where all *.out files are deleted before the reconstruction).

keepSpontaneous : logical

include reactions labelled as "spontaneous" (default true).

keepUndefinedStoich : logical

include reactions in the form n A <=> n+1 A. These are treated as two separate metabolites (default true).

keepIncomplete : logical

include reactions which have been labelled as "incomplete", "erroneous" or "unclear" (default true).

keepGeneral : logical

include reactions which have been labelled as "general reaction". These are reactions of the form "an aldehyde <=> an alcohol". Not all such reactions have this label, so the function cannot remove all of them (default false).

cutOff : double

maximum full-sequence E-value from HMMER for assigning a gene to a KO (default 10^-30).

minScoreRatioKO : double

a gene is removed from a KO if log(score)/log(best score in KO) is below this value, where score is the E-value of the gene. This removes genes from KOs with many genes where some have a lower E-value (default 0.3, lower is less strict).

minScoreRatioG : double

a gene is only assigned to KOs for which log(score)/log(best score) is at least this value, where best score is the lowest E-value of that gene over its KOs after the minScoreRatioKO step. This removes the assignment of a gene to KOs with a much higher E-value than its best KO (default 0.9, lower is less strict).

maxPhylDist : double

only used when fastaFile is empty and organismID is "eukaryotes" or "prokaryotes". -1 keeps genes from organisms in the same domain (Prokaryota, Eukaryota) as H. sapiens ("hsa") or E. coli ("eco"), respectively. Any other value, including Inf, does not restrict the domain, and the value is not compared with the distances calculated in getPhylDist (default Inf).

globalModel : struct

structure containing both model and KOModel structures as generated by getModelFromKEGG. When empty, the global model is loaded with getModelFromKEGG. Providing globalModel avoids reloading it when getKEGGModelForOrganism is run several times, for example for different strains. Example: [globalModel.model,globalModel.KOModel] = getModelFromKEGG (default []).

Returns

model : struct

the reconstructed model.

Notes

The reconstruction works in one of two modes:

  1. From KEGG annotations (no fastaFile supplied). The reactions associated with organismID in the local KEGG database are kept; maxPhylDist applies to organismID "eukaryotes" and "prokaryotes".

  2. From protein homology (fastaFile supplied). The query proteome is searched, in a single hmmsearch, against a prebuilt KEGG-version- and domain-specific concatenated KO HMM library (for example kegg118_eukaryotes), downloaded from the corresponding toolbox-assets release if not already present in dataDir. Hits are filtered by cutOff, minScoreRatioKO and minScoreRatioG into a KO-gene matrix, from which the model is built (spontaneous reactions without genes are kept if keepSpontaneous is true).

The global KEGG model (reaction-KO relationships) is either supplied via globalModel or loaded with getModelFromKEGG.

Examples

model=getKEGGModelForOrganism(organismID,fastaFile,dataDir,...
   outDir,keepSpontaneous,keepUndefinedStoich,keepIncomplete,...
   keepGeneral,cutOff,minScoreRatioKO,minScoreRatioG,maxPhylDist);

getModelFromHomology#

function [draftModel, hitGenes]=getModelFromHomology(models,blastStructure,...
    getModelFor,varargin)

Construct a new model from existing models and homology.

Constructs a new model from a set of existing models and gene homology information.

Parameters

models : cell

a cell array of model structures to build the model from. These models must be sorted by importance in decreasing order.

blastStructure : struct

a blastStructure as produced by getBlast, getDiamond, hitsFromSuppOrth, runSuppOrth or makeFakeBlastStructure.

getModelFor : char

a three-four letter abbreviation of the organism to build a model for. Must have BLASTP hits in both directions to the organisms in "models".

Name-Value Arguments

preferredOrder : cell

the order in which reactions are added from the models, as a cell array of model IDs. If not supplied, reactions are included from all models, otherwise one gene results in reactions from one model only (default {}).

strictness : double

integer that specifies which reactions are included (default 1):

  • 1 : map new genes to old for all pairs which have BLASTP results that pass the filters (maxE, minLen, minIde) in both directions.

  • 2 : map new genes to old for all pairs which have BLASTP results that pass the filters in one direction, selected by mapNewGenesToOld.

  • 3 : apply the filters (maxE, minLen, minIde), retain only the best hit (highest bitscore, ties included) among the hits that passed them for each query gene in each direction separately, then map new genes to old for all pairs which have BLASTP results in both directions.

onlyGenesInModels : logical

consider BLASTP results only for genes that exist in the models. This tends to import a larger fraction from the existing models but may give less reliable results. Changes the result only if strictness=3 (default false).

maxE : double

only look at genes with E-values < this value (default 10^-30). In a benchmark against KEGG and OMA orthology, with the minIde filter in place, values between 10^-4 and 10^-50 gave the same result.

minLen : double

only look at genes with alignment length >= this value (default 100). Measured against KEGG and OMA orthology across four organisms: any value at or below 150 performs the same, while higher values discard real orthologs without reducing the number of wrong ones.

minIde : double

only look at genes with identity >= this value (default 40 (%)). This filter determines the result. In the calibration, with a wrongly transferred reaction counted as worse than a missing one, 40 lies in the 35 to 45 range that the KEGG and OMA references favour.

mapNewGenesToOld : logical

determines how to match genes when strictness is 2: true maps the new genes to the old, false maps the old genes to the new (default true).

complexPolicy : char

what happens to an "and"-linked subunit without an ortholog (case insensitive): "flag" keeps the reaction with the subunit renamed OLD_MODELID_geneName, for review; "keep" drops that subunit; "drop" drops the whole reaction (default "flag").

keepGeneFree : logical

also transfer the template reactions that have no grRule (spontaneous, transport, exchange, artificial). By default they are dropped, because no gene supports them in the new organism. When the template is a curated reference whose gene-free reactions belong in every derived model, true transfers them. With several templates, a gene-free reaction comes in once per template (default false).

preserveNotes : logical

keep rxnNotes and rxnConfidenceScores of each transferred reaction from the template. By default the notes say the reaction was included by getModelFromHomology and the confidence score is 2. The rxnReferences of the template reactions are always kept (default false).

Returns

draftModel : struct

a model structure for the new organism.

hitGenes : struct

structure with the fields oldGenes (the template genes that were mapped) and newGenes (the corresponding genes of the new organism).

Examples

draftModel = getModelFromHomology(models, blastStructure, getModelFor);

Notes

The models in the "models" structure should name the metabolites in the same manner, have their reversible reactions in the same direction (run sortModel), and use the same compartment names. To avoid keeping unnecessary old genes, the models should not have "or"-relations in their grRules (use expandModel).

The gene ids of the new organism in blastStructure become its gene ids in the draft model, so they cannot contain whitespace, parentheses, "|" or "&". FASTA headers from UniProt, such as "sp|P33284|HXK_KLULA", should be reduced to the accession first.

The resulting draft model contains only reactions associated with orthologous genes, plus the gene-free ones with keepGeneFree. With complexPolicy "flag", the old (original) genes involved in "and" relations in grRules without any orthologs are included in the draft model as OLD_MODELID_geneName. A gene that several template genes map to appears once in a grRule. The draft does not keep the version, date or descriptive annotation of the templates.

"to" and "from" are relative to the new organism: "to" is a BLAST search from a template organism to the new organism, "from" is a search from the new organism to a template organism.

The hits can also come from SuppOrth consensus orthologs (hitsFromSuppOrth, runSuppOrth). Their e-value, identity and alignment length are placeholders that pass the filters, so minSupport and the other filters of hitsFromSuppOrth decide which pairs are used.

See also

getBlast, getDiamond, hitsFromSuppOrth, runSuppOrth, makeFakeBlastStructure

getModelFromKEGG#

function [model,KOModel]=getModelFromKEGG(varargin)

Load the global KEGG model.

Loads the global KEGG reaction and gene model from keggModel.mat. When keggModel.mat is not present, the underlying artefacts (the gene-free reference model plus the KO, reaction and organism-gene relational tables, published as a toolbox-assets release) are downloaded and assembled, and the result is saved to keggModel.mat for later calls. The first build takes longer because the organism-gene table covers every KEGG organism, and needs a few hundred MB of disk.

Name-Value Arguments

keepSpontaneous : logical

include reactions labelled as "spontaneous" (default true).

keepUndefinedStoich : logical

include reactions in the form n A <=> n+1 A (default true).

keepIncomplete : logical

include reactions labelled as "incomplete", "erroneous" or "unclear" (default true).

keepGeneral : logical

include reactions labelled as "general reaction" (default false).

Returns

model : struct

a model structure with the reactions that the keep* options retain (by default all except those labelled as "general reaction") and the metabolites used in them.

KOModel : struct

a model structure representing KEGG Orthology ids and their associated genes. KO ids are stored as reactions.

Notes

The model output can be used as a template for fillGaps after the genes and rxnGeneMat fields are removed: model = rmfield(model, 'genes') and model = rmfield(model, 'rxnGeneMat').

See also

getKEGGModelForOrganism, getPhylDist, fillGaps

getPhylDist#

function phylDistStruct=getPhylDist(varargin)

Load the pre-built KEGG phylogenetic distance matrix.

Loads the pre-built phylogenetic distance matrix from keggPhylDist.mat. The matrix ships with RAVEN and is derived from the KEGG taxonomy, which is a toolbox-assets release asset.

Name-Value Arguments

onlyInKingdom : logical

if true, returns a distance matrix with Inf for cross-domain pairs (Prokaryota vs Eukaryota) (default false).

Returns

phylDistStruct : struct

structure with fields:

  • ids : cell array of KEGG organism abbreviations.

  • distMat : pairwise distance matrix (number of tree-nodes apart).

Notes

Distance is based on the number of nodes two organisms are apart in the KEGG taxonomy tree.

guessComposition#

function [model, guessedFor, couldNotGuess]=guessComposition(model, varargin)

Guess the composition of metabolites without one.

Derives the elemental composition of metabolites without a formula from the reactions they participate in, and writes it to the metFormulas field.

Parameters

model : struct

a model structure.

Name-Value Arguments

printResults : logical

true if the predicted compositions are printed (default true).

Returns

model : struct

a model structure with the predicted formulas added to metFormulas, for all metabolites that share the metabolite name.

guessedFor : cell

metabolite names for which a composition could be guessed.

couldNotGuess : cell

metabolite names, among those without a formula in the input model, for which no composition could be assigned.

Examples

[model, guessedFor, couldNotGuess] = guessComposition(model, printResults);

Notes

A metabolite's composition can only be resolved from a reaction in which every other participating metabolite already has a known composition; the function repeats this until no further metabolites can be resolved. It requires that the existing compositions and reactions are correct. If a metabolite would need different compositions in different reactions, or a reaction gives both positive and negative atom counts, the function issues a warning and assigns no composition to that metabolite, so the warnings can also be used to check a model for such inconsistencies. Completion without warnings does not show that the pre-existing compositions are correct.

hitsFromSuppOrth#

function [blastStructure,suppOrthInfo]=hitsFromSuppOrth(source,organismID,varargin)

Read SuppOrth consensus orthologs into a blastStructure.

SuppOrth (https://github.com/fma91/SuppOrth) runs several ortholog predictors (OrthoFinder, SonicParanoid2, Broccoli, and optionally an imported OMA run) on a set of proteomes and writes suppOrth.tsv: one row per cross-species protein pair, with the number of predictors that support it. This function turns that table into a blastStructure for getModelFromHomology.

Parameters

source : char or table

path to suppOrth.tsv, or a MATLAB table with its columns. Protein ids are read as text, so ids such as "NA" or "0123" are kept.

organismID : char

SuppOrth species label of the organism to build a model for: the FASTA file name without extension, or the --labels value. It becomes fromId and toId unless speciesToModel maps it to another id.

Name-Value Arguments

speciesToModel : cell or containers.Map

SuppOrth species label to model id, as an N-by-2 cell array or a containers.Map. A label mapped to '' is left out. When given, every label in the table must be included. When empty, labels are used as model ids (default []).

minSupport : double

minimum number of predictors that found the pair (Lv_support). SuppOrth has already filtered the table with its own --supportLv and --identity_filter; this filter is applied in addition (default 1).

requireTools : cell

predictors that must all have found the pair, by column name ('orthofinder', 'sonicparanoid', 'broccoli', 'oma') (default {}).

minIdentity : double

minimum SuppOrth identity. A pair without an alignment hit fails this filter (default [], no filter).

maxEvalue : double

maximum SuppOrth e-value. A pair without an alignment hit fails this filter (default [], no filter).

proteinToGene : cell, containers.Map or char

protein id to model gene id, as an N-by-2 cell array, a containers.Map, a JSON file with one object of strings, or a two-column tab-separated file (lines starting with # are skipped). Proteins missing from the map keep their id, and their number is reported in a warning. A gene pair takes the highest support over its protein pairs, the union of their predictors, the highest identity and bitscore, and the lowest e-value; these values can come from different protein pairs (default [], no mapping).

Returns

blastStructure : struct

one element per search direction between organismID and each other species, as from getBlast or getDiamond. Every pair is written in both directions, so strictness 1 and 2 of getModelFromHomology give the same result. evalue, identity, aligLen and ppos are placeholders (0, 100, 1000, 100) that pass the filters of getModelFromHomology; bitscore is SuppOrth's value (0 when it has none), which strictness 3 ranks by.

suppOrthInfo : table

one row per gene pair, with modelId, newGene, templateGene, support, supportedBy, identity, evalue and bitscore (SuppOrth's values).

Notes

Only pairs between organismID and another species are kept. Species that are not templates in getModelFromHomology have to be left out with speciesToModel, because getModelFromHomology requires every id in the blastStructure to be the new organism or a template.

Examples

blastStructure = hitsFromSuppOrth('out/suppOrth.tsv','klac',...
   'minSupport',2,'proteinToGene','klac_genes.tsv');

See also

runSuppOrth, getModelFromHomology, getDiamond

keggDataVersion#

function version=keggDataVersion()

The toolbox-assets release tag for KEGG artefacts.

Reads the first line of src/reconstruction/kegg/KEGG_VERSION.md. The file is the single place where the version is recorded, so that every function that downloads a KEGG artefact (getModelFromKEGG, getKEGGModelForOrganism) uses the same release.

Returns

version : char

the toolbox-assets release tag, for example 'kegg118'.

makeFakeBlastStructure#

function blastStructure=makeFakeBlastStructure(orthologList,sourceModelID,getModelFor)

Make a fake blastStructure from an ortholog list.

The structure has the format that getBlast generates. It feeds a predefined list of orthologs to getModelFromHomology. The orthologList is a cell array with at least 10 rows and two columns: the first column contains the genes from the source organism and the second column the genes from the target organism.

Parameters

orthologList : cell

cell array of orthologous genes, where the first column contains the genes from the source organism, while the second column contains the genes from the target organism.

sourceModelID : char

ID of the model that will be used as template, that contains the genes in the first column of orthologList.

getModelFor : char

the name of the organism to build a model for, identical to the getModelFor parameter in the getModelFromHomology function.

Returns

blastStructure : struct

a fake blastStructure with one element per direction. For every pair, evalue is 0, identity is 100, aligLen is 1000, bitscore is 100 and ppos is 100. All orthologous pairs pass the filters of getModelFromHomology.

Examples

blastStructure = makeFakeBlastStructure(orthologList,sourceModelID,getModelFor);

See also

getModelFromHomology, getBlast, hitsFromSuppOrth

readKEGGTable#

function tbl=readKEGGTable(gzFile)

Read a gzipped KEGG relational table into a table of cellstr columns.

Every column is a cellstr (RAVEN's cell-array-of-char convention), whatever the default text-import type of the caller.

Parameters

gzFile : char

path to the gzipped TSV file, for example '.../kegg118_ko_reaction.tsv.gz'.

Returns

tbl : table

the table, with every column as a cellstr.

runSuppOrth#

function [blastStructure,suppOrthInfo]=runSuppOrth(organismID,fastaFile,modelIDs,refFastaFiles,outDir,varargin)

Run SuppOrth on an organism and template proteomes.

Runs the suppOrth command (https://github.com/fma91/SuppOrth) and reads its consensus orthologs with hitsFromSuppOrth.

Parameters

organismID : char

the id of the organism of interest, as in getModelFromHomology.

fastaFile : char

a FASTA file (optionally gzipped) with the proteins of the organism.

modelIDs : cell

the template model ids, as "model.id" in getModelFromHomology.

refFastaFiles : cell

the proteome of each template, in the order of modelIDs, with FASTA ids equal to the gene ids of that model (or mapped to them with proteinToGene).

outDir : char

folder for SuppOrth's output.

Name-Value Arguments

tools : char

comma-separated predictors, or 'all' for orthofinder, sonicparanoid and broccoli (default 'all').

supportLv : double

SuppOrth's --supportLv: a pair is kept if at least this many predictors found it, or if its identity is above identityFilter (default 3, or the number of tools when fewer are selected).

identityFilter : double

SuppOrth's --identity_filter (default 80).

alignment : char

SuppOrth's --alignment (default 'diamond').

threads : double

number of threads (default: the cores assigned to MATLAB).

extraArgs : cell

further arguments for "suppOrth run", for example {'--resume'} or {'--oma','path/to/Output'} (default {}).

suppOrth : char

the suppOrth command. If empty, the RAVEN_SUPPORTH environment variable is used, and then suppOrth on the PATH (default '').

The name-value arguments of hitsFromSuppOrth (minSupport, requireTools, :

minIdentity, maxEvalue, proteinToGene, speciesToModel) are passed on. :

Returns

blastStructure : struct

as from hitsFromSuppOrth, for getModelFromHomology.

suppOrthInfo : table

SuppOrth's values per gene pair, as from hitsFromSuppOrth.

Notes

SuppOrth requires protein ids to be unique over all proteomes. When two FASTA files share an id (for example two templates of the same species), every id is given a "

SuppOrth's predictors run on Linux and macOS only. On Windows, run SuppOrth under WSL or on a Linux host, and read suppOrth.tsv with hitsFromSuppOrth.

Examples

blastStructure = runSuppOrth('klac','klac.fasta',{'yeastGEM'},...
   {'yeast.fasta'},'supporth_out','proteinToGene','klac_genes.tsv');
draftModel = getModelFromHomology(yeastGEM,blastStructure,'klac');

See also

hitsFromSuppOrth, getModelFromHomology, getDiamond