def initializeProteinMonomers(bulkMolCntr, sim_data, randomState, massCoeff):
monomersView = bulkMolCntr.countsView(
sim_data.process.translation.monomerData["id"])
monomerMass = massCoeff * sim_data.mass.getFractionMass(
sim_data.conditionToDoublingTime[sim_data.condition]
)["proteinMass"] / sim_data.mass.avgCellToInitialCellConvFactor
# TODO: unify this logic with the fitter so it doesn't fall out of step
# again (look at the calcProteinCounts function)
monomerExpression = normalize(
sim_data.process.transcription.rnaExpression[sim_data.condition][
sim_data.relation.rnaIndexToMonomerMapping] *
sim_data.process.translation.translationEfficienciesByMonomer /
(np.log(2) /
sim_data.conditionToDoublingTime[sim_data.condition].asNumber(units.s)
+ sim_data.process.translation.monomerData["degRate"].asNumber(
1 / units.s)))
nMonomers = countsFromMassAndExpression(
monomerMass.asNumber(units.g),
sim_data.process.translation.monomerData["mw"].asNumber(
units.g / units.mol), monomerExpression,
sim_data.constants.nAvogadro.asNumber(1 / units.mol))
monomersView.countsIs(randomState.multinomial(nMonomers,
monomerExpression))
def initialize(self, sim, sim_data):
super(PolypeptideInitiation, self).initialize(sim, sim_data)
# Load parameters
mrnaIds = sim_data.process.translation.monomerData["rnaId"]
self.proteinLengths = sim_data.process.translation.monomerData["length"].asNumber()
self.translationEfficiencies = normalize(sim_data.process.translation.translationEfficienciesByMonomer)
self.fracActiveRibosomeDict = sim_data.process.translation.ribosomeFractionActiveDict
self.ribosomeElongationRateDict = sim_data.process.translation.ribosomeElongationRateDict
# Determine changes from parameter shuffling variant
shuffleIdxs = None
if hasattr(sim_data.process.translation, "translationEfficienciesShuffleIdxs") and sim_data.process.translation.translationEfficienciesShuffleIdxs is not None:
shuffleIdxs = sim_data.process.translation.translationEfficienciesShuffleIdxs
self.translationEfficiencies = self.translationEfficiencies[shuffleIdxs]
# Create view on to active 70S ribosomes
self.activeRibosomes = self.uniqueMoleculesView('activeRibosome')
# Create views onto bulk 30S and 50S ribosomal subunits
self.ribosome30S = self.bulkMoleculeView(sim_data.moleculeIds.s30_fullComplex)
self.ribosome50S = self.bulkMoleculeView(sim_data.moleculeIds.s50_fullComplex)
# Create view onto bulk mRNAs
self.mRnas = self.bulkMoleculesView(mrnaIds)
def evolveState(self):
# Calculate number of ribosomes that could potentially be initalized based on
# counts of free 30S and 50S subunits
inactiveRibosomeCount = np.min([
self.ribosome30S.count().sum(),
self.ribosome50S.count().sum(),
])
# Calculate initiation probabilities for ribosomes based on mRNA counts and associated
# mRNA translational efficiencies
proteinInitProb = normalize(
self.mRnas.counts() * self.translationEfficiencies
)
# Calculate actual number of ribosomes that should be activated based on probabilities
self.activationProb = self._calculateActivationProb(self.fracActiveRibosome, self.proteinLengths, self.ribosomeElongationRate, proteinInitProb, self.timeStepSec())
ribosomeToActivate = np.int64(self.activationProb * inactiveRibosomeCount)
if ribosomeToActivate == 0:
return
# Sample multinomial distribution to determine which mRNAs have full 70S
# ribosomes initalized on them
nNewProteins = self.randomState.multinomial(
ribosomeToActivate,
proteinInitProb
)
# Each ribosome is assigned a protein index for the protein that corresponds to the
# polypeptide it will polymerize. This is done in blocks of protein ids for efficiency.
proteinIndexes = np.empty(ribosomeToActivate, np.int64)
nonzeroCount = (nNewProteins > 0)
startIndex = 0
for proteinIndex, counts in itertools.izip(
np.arange(nNewProteins.size)[nonzeroCount],
nNewProteins[nonzeroCount],
):
proteinIndexes[startIndex:startIndex+counts] = proteinIndex
startIndex += counts
# Create active 70S ribosomes and assign their protein indexes calculated above
activeRibosomes = self.activeRibosomes.moleculesNew(
"activeRibosome",
ribosomeToActivate
)
activeRibosomes.attrIs(
proteinIndex = proteinIndexes
)
# Decrement free 30S and 70S ribosomal subunit counts
self.ribosome30S.countDec(nNewProteins.sum())
self.ribosome50S.countDec(nNewProteins.sum())
# Write number of initalized ribosomes to listener
self.writeToListener("RibosomeData", "didInitialize", nNewProteins.sum())
def initializeRNA(bulkMolCntr, sim_data, randomState, massCoeff):
rnaView = bulkMolCntr.countsView(
sim_data.process.transcription.rnaData["id"])
rnaMass = massCoeff * sim_data.mass.getFractionMass(
sim_data.conditionToDoublingTime[sim_data.condition]
)["rnaMass"] / sim_data.mass.avgCellToInitialCellConvFactor
rnaExpression = normalize(
sim_data.process.transcription.rnaExpression[sim_data.condition])
nRnas = countsFromMassAndExpression(
rnaMass.asNumber(units.g),
sim_data.process.transcription.rnaData["mw"].asNumber(
units.g / units.mol), rnaExpression,
sim_data.constants.nAvogadro.asNumber(1 / units.mol))
rnaView.countsIs(randomState.multinomial(nRnas, rnaExpression))
def initializeRibosomes(bulkMolCntr, uniqueMolCntr, sim_data, randomState):
"""
Purpose: Activates ribosomes as unique molecules, and distributes them along length of RNA,
decreases counts of unactivated ribosomal subunits (ribosome30S and ribosome50S).
Normalizes ribosomes placement per length of protein
"""
# Load parameters
nAvogadro = sim_data.constants.nAvogadro
currentNutrients = sim_data.conditions[sim_data.condition]['nutrients']
fracActiveRibosome = sim_data.process.translation.ribosomeFractionActiveDict[
currentNutrients]
mrnaIds = sim_data.process.translation.monomerData['rnaId']
proteinLengths = sim_data.process.translation.monomerData[
'length'].asNumber()
proteinSequences = sim_data.process.translation.translationSequences
translationEfficiencies = normalize(
sim_data.process.translation.translationEfficienciesByMonomer)
mRnas = bulkMolCntr.countsView(mrnaIds)
aaWeightsIncorporated = sim_data.process.translation.translationMonomerWeights
endWeight = sim_data.process.translation.translationEndWeight
#find number of ribosomes to activate
ribosome30S = bulkMolCntr.countsView(
[sim_data.moleculeIds.s30_fullComplex]).counts()[0]
ribosome50S = bulkMolCntr.countsView(
[sim_data.moleculeIds.s50_fullComplex]).counts()[0]
inactiveRibosomeCount = np.minimum(ribosome30S, ribosome50S)
ribosomeToActivate = np.int64(fracActiveRibosome * inactiveRibosomeCount)
# protein synthesis probabilities
proteinInitProb = normalize(mRnas.counts() * translationEfficiencies)
# normalize to protein length
probLengthAdjusted = proteinInitProb * proteinLengths
probNormalized = probLengthAdjusted / probLengthAdjusted.sum()
# Sample a multinomial distribution of synthesis probabilities to determine what RNA are initialized
nNewProteins = randomState.multinomial(ribosomeToActivate, probNormalized)
# protein Indices
proteinIndices = np.empty(ribosomeToActivate, np.int64)
startIndex = 0
nonzeroCount = (nNewProteins > 0)
for proteinIndex, counts in izip(
np.arange(nNewProteins.size)[nonzeroCount],
nNewProteins[nonzeroCount]):
proteinIndices[startIndex:startIndex + counts] = proteinIndex
startIndex += counts
# TODO (Eran) -- make sure there aren't any peptides at same location on same rna
updatedLengths = np.array(randomState.rand(ribosomeToActivate) *
proteinLengths[proteinIndices],
dtype=np.int)
# update mass
sequences = proteinSequences[proteinIndices]
massIncreaseProtein = computeMassIncrease(sequences, updatedLengths,
aaWeightsIncorporated)
massIncreaseProtein[
updatedLengths != 0] += endWeight # add endWeight to all new Rna
# Create active 70S ribosomes and assign their protein Indices calculated above
activeRibosomes = uniqueMolCntr.objectsNew('activeRibosome',
ribosomeToActivate)
activeRibosomes.attrIs(
proteinIndex=proteinIndices,
peptideLength=updatedLengths,
massDiff_protein=massIncreaseProtein,
)
# decrease free 30S and 50S ribosomal subunit counts
bulkMolCntr.countsIs(ribosome30S - ribosomeToActivate,
[sim_data.moleculeIds.s30_fullComplex])
bulkMolCntr.countsIs(ribosome50S - ribosomeToActivate,
[sim_data.moleculeIds.s50_fullComplex])
def do_plot(self, simOutDir, plotOutDir, plotOutFileName, simDataFile,
validationDataFile, metadata):
if not os.path.isdir(simOutDir):
raise Exception, "simOutDir does not currently exist as a directory"
if not os.path.exists(plotOutDir):
os.mkdir(plotOutDir)
# Get the names of proteins from the KB
sim_data = cPickle.load(open(simDataFile, "rb"))
ids_complexation = sim_data.process.complexation.moleculeNames
ids_complexation_complexes = sim_data.process.complexation.ids_complexes
ids_equilibrium = sim_data.process.equilibrium.moleculeNames
ids_equilibrium_complexes = sim_data.process.equilibrium.ids_complexes
ids_translation = sim_data.process.translation.monomerData[
"id"].tolist()
ids_protein = sorted(
set(ids_complexation + ids_equilibrium + ids_translation))
bulkContainer = BulkObjectsContainer(ids_protein, dtype=np.float64)
view_complexation = bulkContainer.countsView(ids_complexation)
view_complexation_complexes = bulkContainer.countsView(
ids_complexation_complexes)
view_equilibrium = bulkContainer.countsView(ids_equilibrium)
view_equilibrium_complexes = bulkContainer.countsView(
ids_equilibrium_complexes)
view_translation = bulkContainer.countsView(ids_translation)
bulkMolecules = TableReader(os.path.join(simOutDir, "BulkMolecules"))
moleculeIds = bulkMolecules.readAttribute("objectNames")
proteinIndexes = np.array(
[moleculeIds.index(moleculeId) for moleculeId in ids_protein],
np.int)
proteinCountsBulk = bulkMolecules.readColumn("counts")[:,
proteinIndexes]
bulkMolecules.close()
# Account for monomers
bulkContainer.countsIs(proteinCountsBulk.mean(axis=0))
# Account for unique molecules
uniqueMoleculeCounts = TableReader(
os.path.join(simOutDir, "UniqueMoleculeCounts"))
ribosomeIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRibosome")
rnaPolyIndex = uniqueMoleculeCounts.readAttribute(
"uniqueMoleculeIds").index("activeRnaPoly")
nActiveRibosome = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, ribosomeIndex]
nActiveRnaPoly = uniqueMoleculeCounts.readColumn(
"uniqueMoleculeCounts")[:, rnaPolyIndex]
uniqueMoleculeCounts.close()
bulkContainer.countsInc(nActiveRibosome.mean(), [
sim_data.moleculeIds.s30_fullComplex,
sim_data.moleculeIds.s50_fullComplex
])
bulkContainer.countsInc(nActiveRnaPoly.mean(),
[sim_data.moleculeIds.rnapFull])
# Account for small-molecule bound complexes
view_equilibrium.countsInc(
np.dot(sim_data.process.equilibrium.stoichMatrixMonomers(),
view_equilibrium_complexes.counts() * -1))
# Account for monomers in complexed form
view_complexation.countsInc(
np.dot(sim_data.process.complexation.stoichMatrixMonomers(),
view_complexation_complexes.counts() * -1))
avgCounts = view_translation.counts()
relativeCounts = avgCounts / avgCounts.sum()
expectedCountsArbitrary = normalize(
sim_data.process.transcription.rnaExpression[sim_data.condition][
sim_data.relation.rnaIndexToMonomerMapping] *
sim_data.process.translation.translationEfficienciesByMonomer /
(np.log(2) / sim_data.doubling_time.asNumber(units.s) +
sim_data.process.translation.monomerData["degRate"].asNumber(
1 / units.s)))
expectedCountsRelative = expectedCountsArbitrary / expectedCountsArbitrary.sum(
)
plt.figure(figsize=(8.5, 11))
maxLine = 1.1 * max(np.log10(expectedCountsRelative.max() + 1),
np.log10(relativeCounts.max() + 1))
plt.plot([0, maxLine], [0, maxLine], '--r')
plt.plot(np.log10(expectedCountsRelative + 1),
np.log10(relativeCounts + 1),
'o',
markeredgecolor='k',
markerfacecolor='none')
plt.xlabel("log10(Expected protein distribution (from fitting))")
plt.ylabel(
"log10(Actual protein distribution (average over life cycle))")
plt.title("PCC (of log values): %0.2f" %
pearsonr(np.log10(expectedCountsRelative + 1),
np.log10(relativeCounts + 1))[0])
exportFigure(plt, plotOutDir, plotOutFileName, metadata)
plt.close("all")