Reconstruction#

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

Functions#

Function

Summary

buildGlobalGPR

Join every KEGG organism's genes onto the reference

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 with

runSuppOrth

Run SuppOrth on an organism and template proteomes.

Reference#

buildGlobalGPR#

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

Join every KEGG organism's genes onto the reference

reactions through their shared KO (KEGG Orthology) ids.

Builds two sparse gene-KO / KO-reaction incidence matrices sharing one KO axis, and multiplies them, rather than expanding the join row by row --- organismGeneKO can carry millions of rows (every gene of every KEGG organism), so a per-row loop is not viable.

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) x 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 / 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, not hardcoded here.

Parameters

ravenPath : char

the RAVEN root directory, as returned by findRAVENroot.

Returns

model : struct

the full global KEGG model (all reactions/metabolites, genes and rxnGeneMat spanning every KEGG organism). Callers narrow this down to one organism (see getKEGGModelForOrganism).

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 should be generated that is used in the unit testing function for BLAST+ (default false).

hideVerbose : logical

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

Returns

blastStructure : struct

structure containing the bidirectional homology measurements that can be used by getModelFromHomology.

blastReport : struct

structure containing MD5 hashes for FASTA database files and non-parsed BLAST output data. Will be blank 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 does 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 blastReport should be generated that is used in the unit testing function for DIAMOND (default false).

hideVerbose : logical

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

Returns

blastStructure : struct

structure containing the bidirectional homology measurements which are used by getModelFromHomology.

diamondReport : struct

structure containing MD5 hashes for FASTA database files and non-parsed BLAST output data. Will be blank 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. For the most sensitive results, the use of getBlast() is adviced, however, getDiamond() is a fast alternative (>15x faster). The blastStructure generated is in the same format as those 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 user must select a closely related species. It is also possible to circumvent protein homology search (see fastaFile parameter for more details).

Parameters

organismID : char

three or four letter abbreviation of the organism (as used in KEGG). If not available, use a closely related species. This is used for determing the phylogenetic distance. Use "eukaryotes" or "prokaryotes" to get a model for the whole domain. Only applicable if fastaFile is empty, i.e. no homology search should be 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. This option ignores all settings except for keepSpontaneous, keepUndefinedStoich, keepIncomplete and keepGeneral.

dataDir : char

directory for which to retrieve the input data, styled as kegg118_prokaryotes or kegg118_eukaryotes, indicating the KEGG version and whether the HMMs were trained on pro- or eukaryotic sequences. The directory name matches the published HMM library it is paired with. The prebuilt concatenated KO HMM library (dataDir.hmm) is downloaded here from the corresponding toolbox-assets release if not already present. This parameter should ALWAYS be provided.

outDir : char

directory to save the results from the quering of the hidden Markov models. The output is specific for the input sequences and the settings used. It is stored in this manner so that the function can continue if interrupted or if it should run in parallel. Be careful not to leave output files from different organisms or runs with different settings in the same folder. They will not be overwritten (default is a temporary dir where all *.out files are deleted before and after doing the reconstruction).

keepSpontaneous : logical

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

keepUndefinedStoich : logical

include reactions in the form n A <=> n+1 A. These will be dealt with 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 on the form "an aldehyde <=> an alcohol", and are therefore unsuited for modelling purposes. Note that not all reactions have this type of annotation, and the script will therefore not be able to remove all such reactions (default false).

cutOff : double

significance score from HMMer needed to assign genes to a KO (default 10^-30).

minScoreRatioKO : double

ignore genes in a KO if their score is <log(score)/log(best score in KO). This is to "prune" KOs which have many genes and where some are clearly a better fit (default 0.3, lower is less strict).

minScoreRatioG : double

a gene is only assigned to KOs for which the score is

=log(score)/log(best score) for that gene. This is to prevent that a gene which clearly belongs to one KO is assigned also to KOs with much lower scores (default 0.9, lower is less strict).

maxPhylDist : double

-1 to only use sequences from the same domain (Prokaryota, Eukaryota); any other (positive) value to only use sequences for organisms where the phylogenetic distance is at the most this large (as calculated in getPhylDist). Only used when reconstructing from KEGG annotations (no fastaFile) (default Inf, which means that all sequences will be used).

globalModel : struct

structure containing both model and KOModel structures as generated by getModelFromKEGG. These will otherwise be loaded by via getModelFromKEGG. Providing globalKEGGmodel can speed up model generation if getKEGGModelForOrganism is run multiple times for different strains. Example: [globalModel.model,globalModel.KOModel] = getModelFromKEGG (default empty, global model is loaded by getModelFromKEGG).

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 controls which organism annotations are considered.

  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 (e.g. kegg118_eukaryotes), downloaded from the corresponding RAVEN release if not already present in dataDir. Hits are filtered by cutOff and the minScoreRatioKO / minScoreRatioG ratios 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, built from a local KEGG FTP dump in dataDir\keggdb (which requires a KEGG FTP license), or loaded from the internal RAVEN version.

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 should be added from the models. If not supplied, reactions will be included from all models, otherwise one gene will only result in reactions from one model (default {}).

strictness : double

integer that specifies which reactions should be included (default 1):

  • 1 : map new genes to old for all pairs which have acceptable BLASTP results in both directions.

  • 2 : map new genes to old for all pairs which have acceptable BLASTP results in the correspondent direction (mapping can be done in the opposite direction, see mapNewGenesToOld below).

  • 3 : check all BLASTP results and retain only the best hit (by bitscore) for each gene pair in each direction separately, then map new genes to old for all pairs which have acceptable 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. Has effect only if strictness=3 (default false).

maxE : double

only look at genes with E-values <= this value (default 10^-30).

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 (%)). The filter that decides the outcome, and 40 is the measured optimum once a wrongly transferred reaction is treated as worse than a missing one. maxE, by contrast, changes nothing between 10^-4 and 10^-50.

mapNewGenesToOld : logical

determines how to match genes if not looking at only 1-1 orthologs. Either map the new genes to the old or old genes to new. The default is to map the new genes (default true).

complexPolicy : char

what happens to an "and"-linked subunit without an ortholog: "flag" keeps the reaction with the subunit renamed OLD_MODELID_geneName, for a curator to review; "keep" drops just 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 nothing supports them in the new organism. Set it when the template is a curated reference whose gene-free reactions belong in every derived model. With several templates, a gene-free reaction comes in once per template (default false).

preserveNotes : logical

keep each transferred reaction's rxnNotes, rxnReferences and rxnConfidenceScores from the template. By default the notes say the reaction was included by getModelFromHomology and the confidence score is 2 (default false).

Returns

draftModel : struct

a model structure for the new organism.

hitGenes : struct

collect the old and new genes.

Examples

draftModel = getModelFromHomology(models, blastStructure, getModelFor);

Notes

The models in the "models" structure should have named 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 unneccesary 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 still 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" means relative to the new 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/gene model from keggModel.mat. On first use --- when no keggModel.mat is present yet --- the underlying artefacts (the gene-free reference model plus the KO/reaction/organism- gene relational tables, published as a toolbox-assets release) are downloaded and assembled instead, and the result is cached to keggModel.mat so later calls load instantly. The first build can take a while (the organism-gene table covers every KEGG organism) and needs a few hundred MB of disk.

Name-Value Arguments

keepSpontaneous : logical

include reactions labeled 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 all reactions 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. In that case, remove the genes and rxnGeneMat fields before parsing: model = rmfield(model, 'genes'), etc.

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; it 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.

Attempts to guess the composition of metabolites without information about elemental composition.

Parameters

model : struct

a model structure.

Name-Value Arguments

printResults : logical

true if the output should be printed (default true).

Returns

model : struct

a model structure with information about elemental composition added.

guessedFor : double

indexes for the metabolites for which a composition could be guessed.

couldNotGuess : double

indexes for the metabolites 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, and throws an error if a metabolite would need inconsistent compositions in different reactions -- so it can also be used to check a model for such errors. Note that successful completion does not guarantee correctness if the pre-existing compositions were themselves wrong.

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/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 reconstruction/kegg/KEGG_VERSION.md --- the single place this version is recorded --- so every function that downloads a KEGG artefact (getModelFromKEGG, getKEGGModelForOrganism) stays in sync when toolbox-assets publishes a new KEGG release. The version is the file's first line.

Returns

version : char

the toolbox-assets release tag, e.g. 'kegg118'.

makeFakeBlastStructure#

function blastStructure=makeFakeBlastStructure(orthologList,sourceModelID,getModelFor)

Make a fake blastStructure from an ortholog list.

This is a structure that would normally be generated by getBlast. It allows to feed a predefined list of orthologs to getModelFromHomology while retaining the further use of that function. For this function to work, it is crucial that the orthologList is a cell array where the first column contains the genes from the source organism, and the second column contains 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, where the evalue, identity and aligLen are set at extreme values, such that all orthologous pairs will pass the filter when running 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 with

every column forced to char cellstr (matching RAVEN's own cell-array-of-char convention, regardless of the caller's default text-import type).

Parameters

gzFile : char

path to the gzipped TSV file, e.g. '.../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