def add_remaining_complex_formulas(model, modification_formulas):
"""
Add formula to complexes that are not formed from a complex formation
reaction (ie. complexes involved in metabolic reactions)
"""
element_dict = {}
# Reset all formulas first
complex_list = []
for c in model.metabolites:
# If not complex or formed by complex formation reaction, do not reset
if not isinstance(c, cobrame.Complex) or c.id in model.process_data:
continue
for r in c.reactions:
if hasattr(r, 'update'):
r.update()
c.formula = ''
c.elements = {}
complex_list.append(c)
# Get formulas only for complexes without complex formation reaction
for c in complex_list:
element_dict[c] = get_remaining_complex_elements(
model, c, modification_formulas)
# Adding elements for complexes dynamically can change function output
# Update all of them after
for c, elements in element_dict.items():
massbalance.elements_to_formula(c, elements)
def _add_formula_to_transcript(self, transcript):
"""
Add element formula to transcript based on nucleotide composition.
1 OH group is removed for each nucleotide to account for polymerization
of mononucleotides. This was done to instead of considering the 3'
diphosphate group as a simplification to avoid keeping track of the
3' nucleotide in cases of transcription unit splicing.
Parameters
----------
transcript : :class:`cobra.core.component.TranscribedGene`
Instance of gene being transcribed
"""
elements = defaultdict(int)
for nuc, value in iteritems(transcript.nucleotide_count):
nuc_obj = self._model.metabolites.get_by_id(nuc)
for e, n in iteritems(nuc_obj.elements):
elements[e] += value * n
# Remove -OH for each
elements['H'] -= len(transcript.nucleotide_sequence)
elements['O'] -= len(transcript.nucleotide_sequence)
massbalance.elements_to_formula(transcript, elements)
def _add_formula_to_complex(self, complex_data, complex_met):
"""
Add chemical formula as sum of all protein and modification components
detailed in subreaction data.
Parameters
----------
complex_data : :class:`cobrame.core.processdata.ComplexData`
Complex data for complex being formed in the reaction
complex_met : :class:`cobrame.core.processdata.ComplexData`
Metabolite of complex being formed in the reaction
"""
elements = defaultdict(int)
for component, count in iteritems(complex_data.stoichiometry):
component_obj = self._model.metabolites.get_by_id(component)
for e, n in iteritems(component_obj.elements):
elements[e] += n * count
elements = \
massbalance.get_elements_from_process_data(self, complex_data,
elements)
# Convert element dict to formula string and associate it with complex
massbalance.elements_to_formula(complex_met, elements)
def _add_formula_to_protein(self, translation_data, protein):
"""
Adds formula to protein based on amino acid sequence and subreactions
Some subreactions modify the composition of the protein, therefore
this must be accounted for.
Water is subtracted from the formula to with a multiplier of
len(amino_acid_sequence) - 1 to account for the condensation
reactions that occur during amino acid polymerization.
Parameters
----------
translation_data : :class:`cobra.core.processdata.TranslationData`
This is required to subtract elements removed/added to protein
when applying reaction defined in subreaction
protein : :class:`cobra.core.processdata.TranslationData`
Protein product that needs a chemical formula
"""
elements = defaultdict(int)
aa_count = self.translation_data.amino_acid_count
for aa_name, value in iteritems(aa_count):
aa_obj = self._model.metabolites.get_by_id(aa_name)
for e, n in iteritems(aa_obj.elements):
elements[e] += n * value
elements = massbalance.get_elements_from_process_data(
self, translation_data, elements)
# subtract water from composition
protein_length = len(translation_data.amino_acid_sequence)
elements["H"] -= (protein_length - 1) * 2
elements["O"] -= protein_length - 1
massbalance.elements_to_formula(protein, elements)
def calculate_biomass_contribution(self):
"""
Calculate net biomass increase/decrease as a result of the subreaction
process.
If subreaction adds a chemical moiety to a macromolecules via a
modification or other means, the biomass contribution of the
modification process should be accounted for and ultimately included
in the reaction it is involved in.
Returns
-------
float
Mass of moiety transferred to macromolecule by subreaction
"""
elements = self.element_contribution
# Create temporary metabolite for calculating formula weight
tmp_met = cobra.Metabolite('mass')
elements_to_formula(tmp_met, elements)
return tmp_met.formula_weight
def update(self, verbose=True):
"""
Creates reaction using the associated posttranslation data and adds
chemical formula to processed protein product
This function adds the following components to the reaction
stoichiometry (using 'data' as shorthand for
:class:`cobrame.core.processdata.PostTranslationData`):
1) Processed protein product defined in data.processed_protein_id
2) Unprocessed protein reactant defined in data.unprocessed_protein_id
3) Metabolites and enzymes defined in data.subreactions
4) Translocation pathways defined in data.translocation
5) Folding mechanism defined in data.folding_mechanims w/ coupling
coefficients defined in data.keq_folding, data.k_folding,
model.global_info['temperature'], data.aggregation_propensity,
and data.propensity_scaling
6) Surface area constraints defined in data.surface_are
7) Biomass if a significant chemical modification takes place (i.e.
lipid modifications for lipoproteins)
Parameters
----------
verbose : bool
Prints when new metabolites are added to the model when executing
update()
"""
self.clear_metabolites()
stoichiometry = defaultdict(float)
metabolites = self._model.metabolites
posttranslation_data = self.posttranslation_data
unprocessed_protein = posttranslation_data.unprocessed_protein_id
processed_protein = posttranslation_data.processed_protein_id
# folding properties
folding_mechanism = posttranslation_data.folding_mechanism
aggregation_propensity = posttranslation_data.aggregation_propensity
scaling = posttranslation_data.propensity_scaling
if folding_mechanism:
temp = str(self._model.global_info['temperature'])
keq_folding = posttranslation_data.keq_folding[temp]
k_folding = posttranslation_data.k_folding[temp] * 3600. # in hr-1
# Get or make processed protein metabolite
try:
protein_met = metabolites.get_by_id(processed_protein)
except KeyError:
protein_met = cobrame.ProcessedProtein(processed_protein,
unprocessed_protein)
self._model.add_metabolites(protein_met)
# Add subreactions (e.g. lipid modifications for lipoproteins)
stoichiometry = self.add_subreactions(posttranslation_data.id,
stoichiometry)
# Add translocation pathways, if applicable
if posttranslation_data.translocation:
stoichiometry = \
self.add_translocation_pathways(posttranslation_data.id,
unprocessed_protein,
stoichiometry)
# Add folding protein coupling coefficients, if applicable
if folding_mechanism == 'folding_spontaneous':
dilution = (keq_folding + mu / k_folding)
stoichiometry[unprocessed_protein] -= (dilution + 1.)
stoichiometry[protein_met.id] += 1.
elif folding_mechanism:
dilution = aggregation_propensity * scaling * (keq_folding + 1.)+1.
stoichiometry[unprocessed_protein] -= (1. / dilution + 1.)
stoichiometry[protein_met.id] += 1. / dilution
stoichiometry[protein_met.id.replace('_folded', '')] += (1.)
else:
stoichiometry[unprocessed_protein] = -1.
stoichiometry[protein_met.id] = 1.
# Add surface area constraints for all translocated proteins, if
# applicable
surface_area = posttranslation_data.surface_area
if surface_area:
for SA, value in iteritems(surface_area):
try:
sa_constraint = metabolites.get_by_id(SA)
except KeyError:
warn('Constraint %s added to model' % SA)
sa_constraint = cobrame.Constraint(SA)
self._model.add_metabolites([sa_constraint])
stoichiometry[sa_constraint.id] += value
# Convert metabolite strings to metabolite objects
object_stoichiometry = self.get_components_from_ids(stoichiometry,
verbose=verbose)
# Add formula as sum of unprocessed protein and modification components
elements = defaultdict(int)
elements.update(metabolites.get_by_id(unprocessed_protein).elements)
elements = \
massbalance.get_elements_from_process_data(self,
posttranslation_data,
elements)
# Convert element dict to formula string and associate it with complex
massbalance.elements_to_formula(protein_met, elements)
# Add biomass from significant modifications (i.e. lipids for
# lipoproteins)
biomass = self.add_biomass_from_subreactions(posttranslation_data)
if biomass > 0 and posttranslation_data.biomass_type:
self.add_metabolites({metabolites.get_by_id(
posttranslation_data.biomass_type): biomass})
elif biomass > 0 and not posttranslation_data.biomass_type:
raise ValueError('If subreactions in PostTranslationData modify '
'the protein, the biomass_type must be provided')
self.add_metabolites(object_stoichiometry, combine=False)
