ecoli.processes.polypeptide_elongation

Polypeptide Elongation

This process models the polymerization of amino acids into polypeptides by ribosomes using an mRNA transcript as a template. Elongation terminates once a ribosome has reached the end of an mRNA transcript. Polymerization occurs across all ribosomes simultaneously and resources are allocated to maximize the progress of all ribosomes within the limits of the maximum ribosome elongation rate, available amino acids and GTP, and the length of the transcript.

class ecoli.processes.polypeptide_elongation.BaseElongationModel(parameters, process)

Bases: object

Base Model: Request amino acids according to upcoming sequence, assuming max ribosome elongation.

amino_acid_counts(aasInSequences)

elongation_rate(states)

Sets ribosome elongation rate accordint to the media; returns max value of 22 amino acids/second.

evolve(states, total_aa_counts, aas_used, next_amino_acid_count, nElongations, nInitialized)

final_amino_acids(total_aa_counts, charged_trna_counts)

isTimeStepShortEnough(inputTimeStep, timeStepSafetyFraction)

request(states, aasInSequences)

ecoli.processes.polypeptide_elongation.MICROMOLAR_UNITS = 1.0 [umol/L]

Units used for all concentrations.

class ecoli.processes.polypeptide_elongation.PolypeptideElongation(parameters=None)

Bases: PartitionedProcess

Polypeptide Elongation PartitionedProcess

defaults:

proteinIds: array length n of protein names

calculate_request(timestep, states)

Set ribosome elongation rate based on simulation medium environment and elongation rate factor which is used to create single-cell variability in growth rate The maximum number of amino acids that can be elongated in a single timestep is set to 22 intentionally as the minimum number of padding values on the protein sequence matrix is set to 22. If timesteps longer than 1.0s are used, this feature will lead to errors in the effective ribosome elongation rate.

defaults: Dict[str, Any]

{   'KD_RelA': 0.26,
    'KI_SpoT': 20.0,
    'KMaa': 100.0,
    'KMtf': 1.0,
    'aaNames': [   'L-ALPHA-ALANINE[c]',
                   'ARG[c]',
                   'ASN[c]',
                   'L-ASPARTATE[c]',
                   'CYS[c]',
                   'GLT[c]',
                   'GLN[c]',
                   'GLY[c]',
                   'HIS[c]',
                   'ILE[c]',
                   'LEU[c]',
                   'LYS[c]',
                   'MET[c]',
                   'PHE[c]',
                   'PRO[c]',
                   'SER[c]',
                   'THR[c]',
                   'TRP[c]',
                   'TYR[c]',
                   'L-SELENOCYSTEINE[c]',
                   'VAL[c]'],
    'aaWeightsIncorporated': array([], dtype=float64),
    'aa_enzymes': [],
    'aa_exchange_names': [   'L-ALPHA-ALANINE[c]',
                             'ARG[c]',
                             'ASN[c]',
                             'L-ASPARTATE[c]',
                             'CYS[c]',
                             'GLT[c]',
                             'GLN[c]',
                             'GLY[c]',
                             'HIS[c]',
                             'ILE[c]',
                             'LEU[c]',
                             'LYS[c]',
                             'MET[c]',
                             'PHE[c]',
                             'PRO[c]',
                             'SER[c]',
                             'THR[c]',
                             'TRP[c]',
                             'TYR[c]',
                             'L-SELENOCYSTEINE[c]',
                             'VAL[c]'],
    'aa_exporters': [],
    'aa_from_synthetase': array([], shape=(1, 0), dtype=float64),
    'aa_from_trna': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0., 0.]),
    'aa_importers': [],
    'aa_supply_in_charging': False,
    'aa_supply_scaling': <function PolypeptideElongation.<lambda> at 0x7f7d77046c00>,
    'adjust_timestep_for_charging': False,
    'amino_acid_export': None,
    'amino_acid_import': None,
    'amino_acid_synthesis': None,
    'amino_acids': [   'L-ALPHA-ALANINE[c]',
                       'ARG[c]',
                       'ASN[c]',
                       'L-ASPARTATE[c]',
                       'CYS[c]',
                       'GLT[c]',
                       'GLN[c]',
                       'GLY[c]',
                       'HIS[c]',
                       'ILE[c]',
                       'LEU[c]',
                       'LYS[c]',
                       'MET[c]',
                       'PHE[c]',
                       'PRO[c]',
                       'SER[c]',
                       'THR[c]',
                       'TRP[c]',
                       'TYR[c]',
                       'L-SELENOCYSTEINE[c]',
                       'VAL[c]'],
    'basal_elongation_rate': 22.0,
    'cellDensity': 1100.0 [g/L],
    'charged_trna_names': [],
    'charging_molecule_names': [],
    'charging_stoich_matrix': array([], shape=(1, 0), dtype=float64),
    'degradation_index': 1,
    'disable_ppgpp_elongation_inhibition': False,
    'elong_rate_by_ppgpp': 0,
    'elongation_max': 22.0 [amino_acid/s],
    'emit_unique': False,
    'endWeight': array([2.99146113e-08]),
    'get_pathway_enzyme_counts_per_aa': None,
    'gtpPerElongation': 4.2,
    'import_constraint_threshold': 0,
    'import_threshold': 1e-05,
    'kS': 100.0,
    'k_RelA': 75.0,
    'k_SpoT_deg': 0.23,
    'k_SpoT_syn': 2.6,
    'krta': 1.0,
    'krtf': 500.0,
    'make_elongation_rates': <function PolypeptideElongation.<lambda> at 0x7f7d77046b60>,
    'max_time_step': 2.0,
    'mechanistic_aa_transport': False,
    'mechanistic_supply': False,
    'mechanistic_translation_supply': False,
    'n_avogadro': 6.02214076e+23 [1/mol],
    'next_aa_pad': 1,
    'ppgpp': 'ppGpp',
    'ppgpp_degradation_reaction': 'PPGPPSYN-RXN',
    'ppgpp_reaction_metabolites': [],
    'ppgpp_reaction_names': [],
    'ppgpp_reaction_stoich': array([], shape=(1, 0), dtype=float64),
    'ppgpp_regulation': False,
    'ppgpp_synthesis_reaction': 'GDPPYPHOSKIN-RXN',
    'proteinIds': array([], dtype=float64),
    'proteinLengths': array([], dtype=float64),
    'proteinSequences': array([], shape=(1, 0), dtype=float64),
    'proton': 'PROTON',
    'rela': 'RELA',
    'ribosome30S': 'ribosome30S',
    'ribosome50S': 'ribosome50S',
    'ribosomeElongationRate': 17.388824902723737,
    'ribosomeElongationRateDict': {   'minimal': 17.388824902723737 [amino_acid/s]},
    'seed': 0,
    'spot': 'SPOT',
    'synthesis_index': 0,
    'synthetase_names': [],
    'time_step': 1,
    'translation_aa_supply': {'minimal': array([], dtype=float64)},
    'translation_supply': False,
    'trna_charging': False,
    'uncharged_trna_names': array([], dtype=float64),
    'unit_conversion': 0,
    'variable_elongation': False,
    'water': 'H2O'}

evolve_state(timestep, states)

Set ribosome elongation rate based on simulation medium environment and elongation rate factor which is used to create single-cell variability in growth rate The maximum number of amino acids that can be elongated in a single timestep is set to 22 intentionally as the minimum number of padding values on the protein sequence matrix is set to 22. If timesteps longer than 1.0s are used, this feature will lead to errors in the effective ribosome elongation rate.

isTimeStepShortEnough(inputTimeStep, timeStepSafetyFraction)

name = 'ecoli-polypeptide-elongation'

ports_schema()

topology

{   'active_ribosome': ('unique', 'active_ribosome'),
    'boundary': ('boundary',),
    'bulk': ('bulk',),
    'bulk_total': ('bulk',),
    'environment': ('environment',),
    'listeners': ('listeners',),
    'polypeptide_elongation': ('process_state', 'polypeptide_elongation'),
    'timestep': ('timestep',)}

ecoli.processes.polypeptide_elongation.REMOVED_FROM_CHARGING = {'L-SELENOCYSTEINE[c]'}

Amino acids to remove from charging when running with steady_state_trna_charging

class ecoli.processes.polypeptide_elongation.SteadyStateElongationModel(parameters, process)

Bases: TranslationSupplyElongationModel

Steady State Charging Model: Requests amino acids based on the Michaelis-Menten competitive inhibition model.

distribution_from_aa(n_aa, n_trna, limited=False)

Distributes counts of amino acids to tRNAs that are associated with each amino acid. Uses self.process.aa_from_trna mapping to distribute from amino acids to tRNA based on the fraction that each tRNA species makes up for all tRNA species that code for the same amino acid. :param n_aa: counts of each amino acid to distribute to each tRNA :param n_trna: counts of each tRNA to determine the distribution :param limited: optional, if True, limits the amino acids

distributed to each tRNA to the number of tRNA that are available (n_trna)

Returns:

Distributed counts for each tRNA

Parameters:

• n_aa (ndarray[int]) –

• n_trna (ndarray[int]) –

• limited (bool) –

Return type:

ndarray[int]

elongation_rate(states)

evolve(states, total_aa_counts, aas_used, next_amino_acid_count, nElongations, nInitialized)

final_amino_acids(total_aa_counts, charged_trna_counts)

isTimeStepShortEnough(inputTimeStep, timeStepSafetyFraction)

request(states, aasInSequences)

class ecoli.processes.polypeptide_elongation.TranslationSupplyElongationModel(parameters, process)

Bases: BaseElongationModel

Translation Supply Model: Requests minimum of 1) upcoming amino acid sequence assuming max ribosome elongation (ie. Base Model) and 2) estimation based on doubling the proteome in one cell cycle (does not use ribosome elongation, computed in Parca).

amino_acid_counts(aasInSequences)

elongation_rate(states)

Sets ribosome elongation rate accordint to the media; returns max value of 22 amino acids/second.

ecoli.processes.polypeptide_elongation.calculate_trna_charging(synthetase_conc, uncharged_trna_conc, charged_trna_conc, aa_conc, ribosome_conc, f, params, supply=None, time_limit=1000, limit_v_rib=False, use_disabled_aas=False)

Calculates the steady state value of tRNA based on charging and incorporation through polypeptide elongation. The fraction of charged/uncharged is also used to determine how quickly the ribosome is elongating. All concentrations are given in units of MICROMOLAR_UNITS.

Parameters:

• synthetase_conc (Unum) – concentration of synthetases associated with each amino acid

• uncharged_trna_conc (Unum) – concentration of uncharged tRNA associated with each amino acid

• charged_trna_conc (Unum) – concentration of charged tRNA associated with each amino acid

• aa_conc (Unum) – concentration of each amino acid

• ribosome_conc (float) – concentration of active ribosomes

• f (Unum) – fraction of each amino acid to be incorporated to total amino acids incorporated

• params (dict[str, Any]) – parameters used in charging equations

• supply (Callable) – function to get the rate of amino acid supply (synthesis and import) based on amino acid concentrations. If None, amino acid concentrations remain constant during charging

• time_limit (float) – time limit to reach steady state

• limit_v_rib (bool) – if True, v_rib is limited to the number of amino acids that are available

• use_disabled_aas (bool) – if False, amino acids in REMOVED_FROM_CHARGING are excluded from charging

Returns:

5-element tuple containing - new_fraction_charged: fraction of total tRNA that is charged for each

amino acid species

• v_rib: ribosomal elongation rate in units of uM/s

• total_synthesis: the total amount of amino acids synthesized during charging in units of MICROMOLAR_UNITS. Will be zeros if supply function is not given.

• total_import: the total amount of amino acids imported during charging in units of MICROMOLAR_UNITS. Will be zeros if supply function is not given.

• total_export: the total amount of amino acids exported during charging in units of MICROMOLAR_UNITS. Will be zeros if supply function is not given.

Return type:

tuple[Unum, float, Unum, Unum, Unum]

ecoli.processes.polypeptide_elongation.dcdt_jit(t, c, n_aas_masked, n_aas, mask, kS, synthetase_conc, KMaa, KMtf, f, krta, krtf, max_elong_rate, ribosome_conc, limit_v_rib, aa_rate_limit, v_rib_max)

ecoli.processes.polypeptide_elongation.get_charging_supply_function(supply_in_charging, mechanistic_supply, mechanistic_aa_transport, amino_acid_synthesis, amino_acid_import, amino_acid_export, aa_supply_scaling, counts_to_molar, aa_supply, fwd_enzyme_counts, rev_enzyme_counts, dry_mass, importer_counts, exporter_counts, aa_in_media)

Get a function mapping internal amino acid concentrations to the amount of amino acid supply expected.

Parameters:

• supply_in_charging (bool) – True if using aa_supply_in_charging option

• mechanistic_supply (bool) – True if using mechanistic_translation_supply option

• mechanistic_aa_transport (bool) – True if using mechanistic_aa_transport option

• amino_acid_synthesis (Callable) – function to provide rates of synthesis for amino acids based on the internal state

• amino_acid_import (Callable) – function to provide import rates for amino acids based on the internal and external state

• amino_acid_export (Callable) – function to provide export rates for amino acids based on the internal state

• aa_supply_scaling (Callable) – function to scale the amino acid supply based on the internal state

• counts_to_molar (Unum) – conversion factor for counts to molar (MICROMOLAR_UNITS)

• aa_supply (ndarray[float]) – rate of amino acid supply expected

• fwd_enzyme_counts (ndarray[int]) – enzyme counts in forward reactions for each amino acid

• rev_enzyme_counts (ndarray[int]) – enzyme counts in loss reactions for each amino acid

• dry_mass (Unum) – dry mass of the cell with mass units

• importer_counts (ndarray[int]) – counts for amino acid importers

• exporter_counts (ndarray[int]) – counts for amino acid exporters

• aa_in_media (ndarray[bool]) – True for each amino acid that is present in the media

Returns:

Function that provides the amount of supply (synthesis, import, export) for each amino acid based on the internal state of the cell

Return type:

Callable[[ndarray[float]], Tuple[Unum, Unum, Unum]] | None

ecoli.processes.polypeptide_elongation.main()

ecoli.processes.polypeptide_elongation.ppgpp_metabolite_changes(uncharged_trna_conc, charged_trna_conc, ribosome_conc, f, rela_conc, spot_conc, ppgpp_conc, counts_to_molar, v_rib, charging_params, ppgpp_params, time_step, request=False, limits=None, random_state=None)

Calculates the changes in metabolite counts based on ppGpp synthesis and degradation reactions.

Parameters:

• uncharged_trna_conc (Unum) – concentration (MICROMOLAR_UNITS) of uncharged tRNA associated with each amino acid

• charged_trna_conc (Unum) – concentration (MICROMOLAR_UNITS) of charged tRNA associated with each amino acid

• ribosome_conc (Unum) – concentration (MICROMOLAR_UNITS) of active ribosomes

• f (ndarray[float]) – fraction of each amino acid to be incorporated to total amino acids incorporated

• rela_conc (Unum) – concentration (MICROMOLAR_UNITS) of RelA

• spot_conc (Unum) – concentration (MICROMOLAR_UNITS) of SpoT

• ppgpp_conc (Unum) – concentration (MICROMOLAR_UNITS) of ppGpp

• counts_to_molar (Unum) – conversion factor from counts to molarity (MICROMOLAR_UNITS)

• v_rib (Unum) – rate of amino acid incorporation at the ribosome (units of uM/s)

• charging_params (dict[str, Any]) – parameters used in charging equations

• ppgpp_params (dict[str, Any]) – parameters used in ppGpp reactions

• time_step (float) – length of the current time step

• request (bool) – if True, only considers reactant stoichiometry, otherwise considers reactants and products. For use in calculateRequest. GDP appears as both a reactant and product and the request can be off the actual use if not handled in this manner.

• limits (ndarray[float]) – counts of molecules that are available to prevent negative total counts as a result of delta_metabolites. If None, no limits are placed on molecule changes.

• random_state (RandomState) – random state for the process

Returns:

7-element tuple containing

• delta_metabolites: the change in counts of each metabolite involved in ppGpp reactions

• n_syn_reactions: the number of ppGpp synthesis reactions

• n_deg_reactions: the number of ppGpp degradation reactions

• v_rela_syn: rate of synthesis from RelA per amino acid tRNA species

• v_spot_syn: rate of synthesis from SpoT

• v_deg: rate of degradation from SpoT

• v_deg_inhibited: rate of degradation from SpoT per amino acid tRNA species

Return type:

tuple[ndarray[int], int, int, Unum, Unum, Unum, Unum]

ecoli.processes.polypeptide_elongation.run_plot(data, config)