Energy efficiency while trying to survive in a toxic environment (For E.

coli bacteria) Discrete Events

System description In order to survive in toxic environments, bacteria have evolved methods for regulating the cell contents. One such toxin is the commonly used antibiotic, tetracycline, which can be used to treat E. coli infections in humans. This common toxin and bacterial strain pair was chosen to take advantage of existing biochemical data. Tetracycline affects E. coli by interrupting protein formation, specifically by preventing the addition of new amino acids. The presence of tetracycline within the cell causes the cell to lose energy as amino acids try to enter the ribosome active site. A tetracycline concentration of approximately 10 ug/mL results in bacteria death (8). In an insidious twist, the bacteria mistakes tetracycline for a food source and actively brings in the toxin at a rate of 1.6 ng/min/AD530 for 6 minutes (1). After this time, the bacteria stops actively transporting the drug into the cell, but still takes in tetracycline at a rate of about 0.14/ng/min/AD530 (1) E. coli has three main mechanisms for dealing with high tetracycline concentrations. The most common mode of resistance to tetracycline attack is to produce ribosomes with a different structure that tetracycline cannot bind to, so that protein formation is not affected at all. This mode of resistance is not studied here the relationship between changing ribosome structure and bacterial energy use is not well understood and unsuitable for event modeling. The two remaining modes of resistance are transporting tetracycline out of the cell at a faster rate than intake and enzymatic degradation of tetracycline. Objective Of the 38 known genes producing E. coli resistance to tetracycline, 23 genes code for transport proteins and only three genes code for enzymes (4). This suggests that in general, protein transport is more favorable than enzymatic degradation. However, the existence of enzymes suggests that under some circumstances, enzymes are more favorable. This system will be studied to determine whether transport is favored over enzymatic degradation and search for an instance where enzymatic degradation results in an energy advantage. Methods A literature search was conducted to determine the mechanism of the two systems, the energy involved, and rates. The transporter system was then modeled as a single M/M/c node with outwards TC flux only and a more complicated open network accounting for different possible states of the transport protein. The enzyme system was modeled as a two-node flow-forward open network. The open networks were examined during the initial period of rapid drug intake. Finally, the condition favoring

the presence of enzymes was determined to be an exit-only network with energy calculations extending beyond the period of rapid drug intake. A 15 minute simulation was chosen empirically as representative of the system and for a reasonable simulation time. Determining system parameters For this model, the proteins are the resources and individual molecules of tetracycline (TC) are the jobs. Arrivals Calculations for the influx of TC into the system are as follows: Rapid intake stage (6 minutes) ( )( )( )( )( )

Reduced intake

Criteria for cell fatality The number of TC resulting in fatality is calculated below. For simulation purposes, the number of TC in queues were counted, not the total number of TC molecules, because TC currently within an enzyme or a transport protein cannot attack the ribosomes. ( )( )( )( )

Service rate The transport protein EmrE and the enzyme TetX were chosen to take advantage of existing biochemical data describing rates. EmrE is a multidrug transporter that fluxes shifts between facing into the membrane and facing out of the membrane 4.9 times per second. EmrE can only bind to a TC molecule when it is facing the TC molecule. This results in a transport rate of 294 TC per minute per transporter. TetX has a catalytic rate of 0.7 TC per second = 42 TC per enzyme per minute. Optimization The goal is to minimize the energy lost. Energy is lost as a result of tetracycline attacking ribosomes, the production and insertion into the membrane of transporter proteins, and the production of

enzymes. Tetracycline results in the energy loss of Each peptide bond uses 2 kcal/mol. TetX has 387 peptide bonds, for a total of 774 kcal/mol. EmrE has 109 peptide bonds, for a total of 218 kcal/mol. EmrE must also be inserted into the membrane at a cost of 8 kcal/mol, for a grand total of 226 kcal/mol. The overall energy for e enzymes and t transporters is and average queue length q over a

duration I. It was assumed that the production of enzymes and transporters was an upfront cost over the brief durations studied. I

Results The simple transport model The transport process can be simply modeled as a single node M/M/c network with = 4300 TC/min. and = 294 TC/min. An M/M/c network was chosen because the transport proteins are identical. Furthermore, in a M/M/c system, jobs leave the queue for the next available server, which is similar to what happens to molecules in a diffusion-limited system such as this one, in which TC travel to proteins via concentration gradients. Solving analytically, this yields that for c > 14 for the system to remain stable. The number of TC in the system is thus
( ) ( )( )

which means

where

{[

[(

) ( )(

)]}

This system was solved using Mathematica for c = 15 yields p = 0.982, P0 = 5.73 E-14, and LQ = 0.0000443 < 9500. However, since fatality was determined by maximum queue length, c > 15 for survival. This was similar to simulation parameters which showed that a minimum of 10 transporters was required for survival. Optimization yielded 26 transport proteins at a cost of 6.2 Mcal/mol. Over the 6 minute simulation, the average wait time was 0.203 seconds, average queue length was 0, maximum queue length was 5, and utilization of 56.3%. The calculated utilization for a 26-ser M/M/c system was also 56.7% and the queue was also approximately 0, indicating that this system is most likely accurate. By Littles Law, number in the system is approximately 15 molecules TC. From these results, it can be seen that at a minimized energy, the transport proteins are not operating at full capacity, which enables

the system to have a short line. Furthermore, a threshold level of transporters must be present to ensure survival.

Simple Transport Model

1000 Energ (Gca/mol) log scale 100 10 1 0 0.1 0.01 0.001 # Transport Proteins 10 20 30 40 50 60

The more realistic transport model

The transport process is better modeled as 4 nodes, each representing a state of the system: (1) diffusion, (2) normal transport, (3) false binding, and (4) backwards flux. The arrival rate into the system is still the maximum uptake rate. However, instead of directly progressing to transport, the TC must first diffuse to a transporter. The diffusion rate of a small molecule in water is over 2 um, the length of

the bacteria, gives a service rate of 3000/min. This is modeled as a M/M/Inf node because diffusion merely serves to introduce a delay. From state 1, it is possible to reach a protein, but not be able to bind

because the protein is facing the wrong direction. This probability was calculated by comparing the rate of diffusion (3000/min) with the rate of two protons binding (600/min), the step required for switching the transport protein back to inwards-facing after transporting out a TC molecule. Given x and y are two exponential random variables with rates m and n, the probability of the event associated with x occurring before that associated with y is: [ ] ] [ | ] ( ) [
( )

(Source: Wolfram)

Thus, the probability is 0.038 that a TC exiting state 1 will re-enter state 1. It is also possible for the TC to bind and then fall off. This occurs when the 2 protons bind (rate 600/min) faster than the TC unbinds, causing the 2 protons to replace the TC in the transporter active site Thus with a probability of 0.005, a TC molecule will progress to state 2. State 2 is a M/M/c server with c = the number of proteins. In simulation, this is not really a resource, because using this as a resource gives an overly high estimate of the actual number of transport protein resources available. Instead, a transport protein is requested immediately before requesting this state, and the protein and state are relinquished after a service rate of 1200/min, the time it takes for a TC to bind to the transport protein. Proton and TC binding rates were estimated based on Henzler-Wildman lab unpublished data. State 2 uses the same 294/min flux service rate implemented in the simple transport model. State 2 is a M/M/c server implemented similarly to state 3, with TC queuing for the transport protein rather than the state. However, upon exiting state 2, it is possible to rebind to the transport protein and re-enter the membrane. This occurs with probability: P[binding occurs before diffusion] P[the transporter is facing outwards] = (0.29) (0.038) = 0.011. State 4 is also a M/M/c server, also implemented similarly to state 3, with a service rate of 294/min representing transport flux of the TC back into the cell. It is clear that with the addition of the diffusion process and branches backwards in this nonfeed-forward system that the effective transport rate per transport protein is slower than previously. Thus, it makes sense that the simulation yields an increase in the minimum number of transporter proteins necessary for survival to 19. Furthermore, optimization yields 320 transporter with an energy cost of 73 Mcal/mol, an increase due to both the tremendous increase in transporters used. Each TC stays on average 4.38 s in the cell with 0 s in the diffusion (1), 0.18 s in normal flux (2), 0.06 s in false

binding (3), and 0.18 s in backwards flux each time it visits the corresponding state, n.b. these are response times. However, each TC still stays in the system for approximately 0.203 s, which means that the slightly slower effective transport rate per protein was compensated for by increasing the number of proteins. This is supported by Littles Law there is still the same approximately 15 molecules of TC in the cell as seen in the simple model. Similarly to the simple model, the average queue length is 0, but utilization has increased to 85% in the realistic model. From a usage standpoint, this is a very inefficient system, even when optimized for energy, because the transport protein accounts for 72.3 Mcal/mol, or 99%, of the energy cost.

Realistic Transport Model

100 Energy (Gcal/mol) log scale

10

1 0 0.1 100 200 300 400 500 600

Series1

0.01

# Transport Proteins

The enzyme model This model is a two-node model, feed-forward model. Arrivals occur at the rate of maximum uptake and enter the diffusion node, which is M/M/Inf as described earlier. TC molecules then enter the degradation node, which destroys the molecule at a rate of 42 TC per minute. The enzyme TetX is both larger and slower than the EmrE transport protein, so it makes sense that the minimum number of enzyme proteins required is increased further, to 66. Optimization yields 125 enzyme proteins at the huge energy cost of 101 Mcal/mol. This is partially due to the slow rate, as the average system time is 1.435 s. By Littles Law, the mean number of TC in the cell is also higher at 104 molecules. Utilization was 82%, but the cost from the protein was still quite high at 96.8 Mcal/mol.

Enzyme Model
1000 Energy (Gcal/mol) log scale

100

10

1 0 0.1 100 200 300 400 # Enzymes 500 600 700 800

The combined model (quasi-closed loop) The enzyme TetX is both expensive in terms of energy and very slow. The only advantage offered is that the enzyme destroys TC instead of pumping it out. However, the above systems are maximum-uptake systems, with the extracellular environment modeled as having a very high TC concentration such that maximum uptake does not deplete the supply of TC. This means that in effect, destroying a TC and exporting a TC have the same effect in these sorts of systems. As the results have shown, the enzyme is more energy expensive than the transporter, even when optimized. The energy difference is exacerbated when operating on the margin of least number of proteins necessary for survival. In this situation the realistic transport model yields an energy cost of 29 Gcal/mol while the enzyme model requires 250 Gcal/mol. However, the existence of the enzyme indicates that there must be some benefit. One benefit to an enzyme is that it destroys the TC molecule whereas the transporter pumps the TC out. In a situation where the cell is only exposed to low levels of TC, the network is similar to a closed-loop. The TC molecules transported out can be reabsorbed, and this is where enzymatic degradation has an advantage. The realistic transport model was combined with the enzyme model. The simulation parameters of 1000 TC and 15 minutes was chosen as a balance between a good approximation of reality and reasonable simulation time. All the TC started on the outside. This model uses 6 states. (1) Uptake into the cell was modeled as a M/M/Inf node with a faster rate for the first 6 minutes as previously described. The uptake node is followed by the (2) diffusion node, which is implemented with service rate of

3000/min. The diffusion node redirects small percentages to (3) false binding or (2) back to diffusion as described in the realistic transport model. Those not TC not redirected are shunted to the (3) enzyme degradation node or the (4) normal transport node, with probability equal to the fraction of enzyme or transport protein present. TC exiting the cell from the normal transport mode loop around to the uptake mode. This is not really closed loop because exiting from the enzyme degradation node is permanent.

Overall the energy costs were higher, as expected from running over a long period of time. However, it can be seen that there is a significant energy advantage to having both enzymes and transporters (lower figure) when one is below the optimal number of transporters for that energy level, although the minimum energy is lower with a transporter system-only or significant numbers of transporters. This energy advantage is seen as the large energy gap between the red and blue traces. Furthermore, as shown in the upper figure, there is a sharp energy decrease as the number of enzymes increase until the optimum level is reached. A slow increase in energy follows. Thus, enzymes do lower the energy burden at low TC concentrations. This is important for the bacteria in two ways. Firstly, the bacteria is not constantly assaulted by high TC concentrations, but rather more frequently exposed to low TC concentrations. Secondly, one limitation of these models is that they do not capture the dynamics of the protein systems. The number of enzymes and transport proteins in a real cell change with time. If this is accounted for, enzymes are extremely necessary

because it is both easier to store cytosolic enzymes such as TetX and faster to make more TetX. In contrast, the folding and insertion of membrane proteins is a much slower process and extraneous membrane proteins, i.e. transport proteins when there is nothing to transport, take up valuable membrane real estate.

Combined Model
1000

Energy (Gcal/mol)

100

10

320 Transporters 0 Transporters

1 0 0.1 500 1000 # Enzymes 1500

Combined Model
1000

Energy (Gcal/mol)

100

10

125 Enzymes 0 enzymes

1 0 0.1 1000 2000 3000 4000 5000 6000

# Transporters

Finally, the overall energy cost of both transporters and enzymes is quite high, on the order of Gcal/mol. This is probably why most E. coli resist tetracycline attack by modifying ribosome structure.

Code: Simplified Model

'' Open network modeling simple antibiotic transporter '' Assuming maximum uptake rate preamble

processes include TCgenerator, stop.sim, and TC resources include protein define number.protein as an integer variable define protein.sys.time as a real variable define stop.time as a real variable define energy as a real variable tally avg.protein.sys.time as the mean of protein.sys.time accumulate avg.queue.length as the average, max.queue.length as the maximum of n.q.protein accumulate protein.utilization as the average of n.x.protein define TC.inside as an integer variable define x as a real variable end main let number.protein = 26 create every protein(1) let u.protein(1)=number.protein let stop.time = 6 activate a TCgenerator now activate a stop.sim in stop.time days '' these are really minutes start simulation end routine repChange ''reports change at each instance print 1 line with time.v and TC.inside thus **.*** *************** end ''routine repChange process stop.sim define cost as a real variable let cost = 226*number.protein+avg.queue.length*20*stop.time*60*7.5 print 1 line thus PRINTOUT BEGINS print 2 lines with time.v thus Simulation ran for ** minutes print 2 lines with avg.protein.sys.time*60, avg.queue.length, max.queue.length, protein.utilization*100/number.protein, and cost/1000000 thus wait (s) Avg. Q Max Q Utilization Cost ***.*** ******** ******** ***.***** ********.**** kcal/mol print 1 line thus PRINTOUT ENDS ''read x stop end process TCgenerator define IAT as a real variable while time.v <= stop.time do if time.v <= 6

let IAT = exponential.f(1/4330.000,1) wait IAT days activate a TC now else let IAT = exponential.f(1/379.000,1) wait IAT days activate a TC now always call repChange let TC.inside = TC.inside + 1 loop end process TC define arrival.time as a real variable let arrival.time = time.v request 1 protein(1) define WT as a real variable let WT = exponential.f(1/294.000,2) work WT days relinquish 1 protein(1) let protein.sys.time = time.v - arrival.time let TC.inside = TC.inside - 1 call repChange end

Realistic Model
'' Open network modeling more complicated antibiotic transporter '' Assuming maximum uptake rate (open) preamble processes include TCgenerator, stop.sim, and TC every TC has a current.state define current.state as an integer variable resources include state and protein define number.protein as an integer variable define TC.inside as an integer variable define stop.time as a real variable define protein.sys.time as a real variable define cell.sys.time as a real variable define diffusion.sys.time, normal.sys.time, fallOff.sys.time, and reflux.sys.time as real variables tally avg.protein.sys.time as the mean of protein.sys.time tally avg.cell.sys.time as the mean of cell.sys.time tally avg.diffusion.sys.time as the mean of diffusion.sys.time tally avg.normal.sys.time as the mean of normal.sys.time tally avg.fallOff.sys.time as the mean of fallOff.sys.time tally avg.reflux.sys.time as the mean of reflux.sys.time tally avg.TC.inside as the mean, max.TC.inside as the maximum of TC.inside accumulate avg.queue.length as the average, max.queue.length as the maximum of n.q.protein accumulate avg.queue.state.length as the average, max.queue.state.length

as the maximum of n.q.state accumulate protein.utilization as the average of n.x.protein '' Various states: these are the nodes define .diffusion to mean 1 define .normal to mean 2 define .fallOff to mean 3 define .reflux to mean 4 define x as a real variable end main let number.protein = 320 create every protein(1) let u.protein(1) = number.protein create every state(4) let u.state(.diffusion) = 100000 '' large for M/M/inf let u.state(.normal) = number.protein ''Represents a maximum let u.state(.fallOff) = number.protein let u.state(.reflux) = number.protein let stop.time = 6 let TC.inside = 0 activate a TCgenerator now activate a stop.sim in stop.time days ''these are really minutes start simulation end

routine repChange ''reports change at each instance ''print 1 line with time.v, n.q.protein(1), TC.inside, ''n.q.state(.diffusion), n.q.state(.normal), n.q.state(.fallOff), ''and n.q.state(.reflux) thus ''**.*** *************** *************** *************** *************** *************** *************** end ''routine repChange process stop.sim define cost as a real variable let cost = 226*number.protein+avg.queue.length*20*stop.time*60*7.5 print 1 line thus PRINTOUT BEGINS print 2 lines with time.v thus Simulation ran for ** minutes print 3 lines with avg.protein.sys.time*60, avg.queue.length, max.queue.length, protein.utilization*100/u.protein(1), and number.protein*226 thus Data specifically for proteins... (not all relevant!) wait (s) Avg. Q Max Q Utilization Cost ***.*** ******** ******** ***.***** ********.**** kcal/mol print 7 lines with avg.diffusion.sys.time, avg.queue.state.length(.diffusion), max.queue.state.length(.diffusion), avg.normal.sys.time, avg.queue.state.length(.normal), max.queue.state.length(.normal), avg.fallOff.sys.time, avg.queue.state.length(.fallOff),

max.queue.state.length(.fallOff), avg.reflux.sys.time, avg.queue.state.length(.reflux), max.queue.state.length(.reflux), avg.cell.sys.time, avg.TC.inside, and max.TC.inside thus Whole system data State SysTime(s) Avg.Q Max.Q Diff ***.*** ********** ********** Normal ***.*** ********** ********** FallOff ***.*** ********** ********** Reflux ***.*** ********** ********** Cell ***.*** ********** ********** print 1 line with cost/1000000 thus Cost = *********.*** print 1 line thus PRINTOUT ENDS ''read x stop end process TCgenerator '' maximum uptake define IAT as a real variable while time.v <= stop.time do if time.v <= 6 let IAT = exponential.f(1/4330.000,1) else let IAT = exponential.f(1/379.000,1) always wait IAT days activate a TC giving 1 now let TC.inside = TC.inside + 1 call repChange loop end process TC given current.state define arrival.time as a real variable define arrival.state.time as a real variable let arrival.time = time.v define node as an integer variable let node = current.state define probability as a real variable while node ne 0 do let arrival.state.time = time.v if node = .diffusion request 1 state(.diffusion) work exponential.f(1/3000.000,3) days relinquish 1 state(.diffusion) let diffusion.sys.time = time.v - arrival.state.time let probability = random.f(2) if probability <= 0.038 node = .diffusion

elseif probability <= (0.038 + 0.005) node = .fallOff else node = .normal always elseif node = .normal request 1 protein(1) request 1 state(.normal) define WT as a real variable let WT = exponential.f(1/294.000,4) work WT days relinquish 1 protein(1) relinquish 1 state(.normal) let normal.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time let probability = random.f(2) if probability <= 0.011 node = .reflux else node = 0 ''exit successful let TC.inside = TC.inside - 1 always elseif node = .fallOff request 1 protein(1) request 1 state(.fallOff) work exponential.f(1/1200.000,5) days relinquish 1 protein(1) relinquish 1 state(.fallOff) let fallOff.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time node = .diffusion elseif node = .reflux request 1 protein(1) request 1 state(.reflux) define WT2 as a real variable let WT2= exponential.f(1/294.000,4) work WT2 days relinquish 1 protein(1) relinquish 1 state(.reflux) let reflux.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time always call repChange loop let cell.sys.time = time.v - arrival.time end

Enzyme Model
''Open network model ''Antibiotic degrading enzyme '' Assuming maximum uptake rate preamble

processes include TCgenerator, stop.sim, and TC every TC has a current.location define current.location as an integer variable resources include enzyme and state define .diffusion to mean 1 define .degrade to mean 2 define TC.inside as an integer variable define number.enzyme as an integer variable define enzyme.sys.time as a real variable define diffusion.sys.time and degrade.sys.time as real variables define cell.sys.time as a real variable define stop.time as a real variable tally avg.enzyme.sys.time as the mean of enzyme.sys.time tally avg.diffusion.sys.time as the average of diffusion.sys.time tally avg.degrade.sys.time as the average of degrade.sys.time tally avg.cell.sys.time as the average of cell.sys.time tally avg.TC.inside as the average, max.TC.inside as the max of TC.inside accumulate avg.queue.length as the average, max.enzyme.queue.length as the maximum of n.q.enzyme accumulate avg.queue.state.length as the average, max.queue.state.length as the maximum of n.q.state accumulate enzyme.utilization as the average of n.x.enzyme end main let number.enzyme = 125 create every enzyme(1) let u.enzyme(1) = number.enzyme create every state(2) let u.state(.diffusion)=1000000 let u.state(.degrade) = number.enzyme let stop.time = 6 let TC.inside = 0 activate a TCgenerator now activate a stop.sim in stop.time days '' these are really minutes start simulation end routine repChange ''reports change at each instance ''print 1 line with time.v, n.q.enzyme(1), TC.inside, n.q.state(.diffusion), ''and n.q.state(.degrade) thus ''**.*** *************** *************** *************** *************** end ''routine repChange process stop.sim define cost as a real variable let cost = 2*387*number.enzyme+avg.queue.length*20*stop.time*60*7.5 print 1 line thus PRINTOUT BEGINS print 2 lines with time.v thus Simulation ran for ** minutes

print 1 line with number.enzyme thus *** enzyme experiment print 2 lines with avg.enzyme.sys.time*60, avg.queue.length, max.enzyme.queue.length, enzyme.utilization*100/number.enzyme, and 2*387*number.enzyme thus wait (s) Avg. Q Max Q Utilization Cost ***.*** ******** ******** ***.***** ********.**** kcal/mol print 5 lines with avg.diffusion.sys.time*60, avg.queue.state.length(.diffusion), max.queue.state.length(.diffusion), avg.degrade.sys.time*60, avg.queue.state.length(.degrade), max.queue.state.length(.degrade), avg.cell.sys.time*60, avg.TC.inside, and max.TC.inside thus Whole system data State SysTime(s) Avg.Q Max.Q Diff ***.*** ********** ********** Degr ***.*** ********** ********** Cell ***.*** ********** ********** print 1 line with cost/1000000 thus Cost = **********.*** print 1 line thus PRINTOUT ENDS stop end process TCgenerator define IAT as a real variable while time.v <= stop.time do if time.v <= 6 let IAT = exponential.f(1/4330.000,1) else let IAT = exponential.f(1/379.000,1) always wait IAT days activate a TC giving 1 now let TC.inside = TC.inside + 1 call repChange loop end process TC given current.state define arrival.time as a real variable let arrival.time = time.v define node as an integer variable let node = current.state define probability as a real variable while node ne 0 do if node = .diffusion request 1 state(.diffusion) work exponential.f(1/3000.000,3) days relinquish 1 state(.diffusion) let diffusion.sys.time = time.v - arrival.time let node = 2

else request 1 enzyme(1) request 1 state(.degrade) define WT as a real variable let WT = exponential.f(1/42.000,2) work WT days relinquish 1 enzyme(1) relinquish 1 state(.degrade) let enzyme.sys.time = time.v - arrival.time let degrade.sys.time = time.v - arrival.time let node = 0 let TC.inside = TC.inside - 1 always loop let cell.sys.time = time.v - arrival.time call repChange end

Combined Model
'' Open network modeling combined system '' Assuming maximum TC, limited uptake, (closed) preamble processes include TCgenerator, stop.sim, and TC every TC has a current.state define current.state as an integer variable resources include state, protein, and enzyme define number.protein and number.enzyme as integer variables define TC.inside as an integer variable define stop.time as a real variable define protein.sys.time and enzyme.sys.time as real variables define cell.sys.time as a real variable define diffusion.sys.time, normal.sys.time, fallOff.sys.time, reflux.sys.time, degrade.sys.time, and outside.sys.time as real variables tally avg.protein.sys.time as the mean of protein.sys.time tally avg.enzyme.sys.time as the mean of enzyme.sys.time tally avg.cell.sys.time as the mean of cell.sys.time tally avg.diffusion.sys.time as the mean of diffusion.sys.time tally avg.normal.sys.time as the mean of normal.sys.time tally avg.fallOff.sys.time as the mean of fallOff.sys.time tally avg.reflux.sys.time as the mean of reflux.sys.time tally avg.degrade.sys.time as the mean of degrade.sys.time tally avg.outside.sys.time as the mean of outside.sys.time tally avg.TC.inside as the mean, max.TC.inside as the maximum of TC.inside accumulate avg.protein.queue.length as the average, max.protein.queue.length as the maximum of n.q.protein accumulate avg.enzyme.queue.length as the average, max.enzyme.queue.length as the maximum of n.q.enzyme accumulate avg.queue.state.length as the average, max.queue.state.length as the maximum of n.q.state accumulate protein.utilization as the average of n.x.protein accumulate enzyme.utilization as the average of n.x.enzyme '' Various states: these are the nodes

define .diffusion to mean 1 define .normal to mean 2 define .fallOff to mean 3 define .reflux to mean 4 define .degrade to mean 5 define .outside to mean 6 define .destroy to mean 0 define k as an integer variable end main let number.protein = 0 let number.enzyme = 30 create every protein(1) let u.protein(1)=number.protein create every enzyme(1) let u.enzyme(1) = number.enzyme create every state(6) let u.state(.diffusion) = 1000000 '' large for M/M/inf let u.state(.normal) = number.protein ''Represents a maximum let u.state(.fallOff) = number.protein let u.state(.reflux) = number.protein let u.state(.degrade) = number.enzyme let u.state(.outside) = 1000000 let stop.time = 15 let TC.inside = 0 let k = 0 activate a TCgenerator now activate a stop.sim in stop.time days ''these are really minutes start simulation end

routine repChange ''reports change at each instance k = k+ 1 if k = 1000 ''print 1 line with time.v, n.q.protein(1), n.q.enzyme(1), TC.inside, ''n.q.state(.diffusion), n.q.state(.normal), n.q.state(.fallOff), ''n.q.state(.reflux), n.q.state(.degrade), and n.q.state(.outside) thus ''**.*** *************** *************** *************** *************** *************** *************** *************** *************** *************** k=0 always end ''routine repChange process stop.sim define cost as a real variable let cost = 226*number.protein + 387*2*number.enzyme + avg.TC.inside*20*stop.time*60*7.5 print 1 line thus PRINTOUT BEGINS print 2 lines with time.v thus Simulation ran for ** minutes

print 1 line with number.protein and number.enzyme thus **** proteins, **** enzymes print 3 lines with avg.protein.sys.time*60, avg.protein.queue.length, max.protein.queue.length, protein.utilization*100/u.protein(1), and 226*number.protein thus Data specifically for proteins... (not all relevant!) wait (s) Avg. Q Max Q Utilization Cost ***.*** ******** ******** ***.***** ********.**** kcal/mol print 3 lines with avg.enzyme.sys.time*60, avg.enzyme.queue.length, max.enzyme.queue.length, enzyme.utilization*100/u.enzyme(1), and 387*2*number.enzyme thus Data specifically for enzymes... (not all relevant!) wait (s) Avg. Q Max Q Utilization Cost ***.*** ******** ******** ***.***** ********.**** kcal/mol print 9 lines with avg.diffusion.sys.time*60, avg.queue.state.length(.diffusion), max.queue.state.length(.diffusion), avg.normal.sys.time*60, avg.queue.state.length(.normal), max.queue.state.length(.normal), avg.fallOff.sys.time*60, avg.queue.state.length(.fallOff), max.queue.state.length(.fallOff), avg.reflux.sys.time*60, avg.queue.state.length(.reflux), max.queue.state.length(.reflux), avg.degrade.sys.time*60, avg.queue.state.length(.degrade), max.queue.state.length(.degrade), avg.outside.sys.time*60, avg.queue.state.length(.outside), max.queue.state.length(.outside), avg.cell.sys.time*60, avg.TC.inside, and max.TC.inside thus Whole system data State SysTime(s) Avg.Q Max.Q Diff ***.*** ********** ********** Normal ***.*** ********** ********** FallOff ***.*** ********** ********** Reflux ***.*** ********** ********** Degrade ***.*** ********** ********** Outside ***.*** ********** ********** Cell ***.*** ********** ********** print 1 line with cost/1000000 thus Cost = *******************.*** Gcal/mole print 1 line with TC.inside thus ********** TC at end print 1 line thus PRINTOUT ENDS stop end process TCgenerator '' maximum uptake define i as a real variable for i = 1 to 9500 do activate a TC giving 6 now call repChange loop end

process TC given current.state define arrival.time as a real variable define arrival.state.time as a real variable let arrival.time = time.v define node as an integer variable let node = current.state define probability as a real variable while node ne 0 do let arrival.state.time = time.v if node = .diffusion request 1 state(.diffusion) work exponential.f(1/3000.000,3) days relinquish 1 state(.diffusion) let diffusion.sys.time = time.v - arrival.state.time let probability = random.f(2) if probability <= 0.038 let node = .diffusion elseif probability <= (0.038 + 0.005) let node = .fallOff else let probability = random.f(3) if probability <= (number.enzyme)/(number.enzyme+number.protein) let node = .degrade else let node = .normal always always elseif node = .normal request 1 state(.normal) request 1 protein(1) define WT as a real variable let WT = exponential.f(1/294.000,4) work WT days relinquish 1 protein(1) relinquish 1 state(.normal) let normal.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time let probability = random.f(2) if probability <= 0.011 let node = .reflux else let node = .outside ''exit successful let TC.inside = TC.inside - 1 always elseif node = .fallOff request 1 state(.fallOff) request 1 protein(1) work exponential.f(1/1200.000,5) days relinquish 1 protein(1) relinquish 1 state(.fallOff) let fallOff.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time

let node = .diffusion elseif node = .reflux request 1 state(.reflux) request 1 protein(1) define WT2 as a real variable let WT2= exponential.f(1/294.000,6) work WT2 days relinquish 1 protein(1) relinquish 1 state(.reflux) let reflux.sys.time = time.v - arrival.state.time let protein.sys.time = time.v - arrival.state.time let node = .diffusion elseif node = .degrade request 1 state(.degrade) request 1 enzyme(1) define WT3 as a real variable let WT3 = exponential.f(1/42.000,7) work WT3 days relinquish 1 enzyme(1) relinquish 1 state(.degrade) let degrade.sys.time = time.v - arrival.state.time let enzyme.sys.time = time.v - arrival.state.time let node = .destroy let TC.inside = TC.inside - 1 elseif node = .outside request 1 state(.outside) define WT4 as a real variable if time.v <= 6 let WT4 = exponential.f(1/4330.000,1) else let WT4 = exponential.f(1/379.000,1) always work WT4 days relinquish 1 state(.outside) let node = .diffusion let TC.inside = TC.inside + 1 let outside.sys.time = time.v - arrival.state.time always call repChange loop let cell.sys.time = time.v - arrival.time end References 1. McMurry, L., & Levy, S. B. (1978). Two transport systems for tetracycline in sensitive e. coli: Critical role for an initial rapid uptake system insensitive to energy inhibitors. Antimicrobial Agents and Chemotherapy, 14(2), 201209. Retrieved from http://www.ncbi.nlm.nih.gov/pmc/articles/PMC352433/pdf/aac00290-0049.pdf 2. Morrison, E.A., DeKoster, G.T., Dutta, S. et al and Henzler-Wildman, K.A. (2012). Antiparallel EmrE exports drugs by exchanging between asymmetric structures. Nature(481), 45-50. Retrieved from http://www.nature.com/nature/journal/v481/n7379/full/nature10703.html?WT.ec_id=NATURE-20120105 3. Chalmers, G., Kozak, G.K., Hillyer, E., Reid-Smith, R., and Boerlin, P. (2010). Low minimum inhibitory concentrations asssociated with the tetracycline-resistance gene

4. 5.

6. 7. 8. 9.

Roberts, M.C. (2005). Update on acquired tetracycline resistance genes. FEMS Microbiology Letters, 245(2):195304. Retrieved from http://onlinelibrary.wiley.com/doi/10.1016/j.femsle.2005.02.034/full Stoica, A., Stroescu, M., Chiciudean, T.G., Tache, F., and Dobre, T. (2007). Tetracycline diffusion through bacterial cellulose--polyvinyl alcohol membranes. Annals of DAAAM & Proceedings. Retrieved from http://www.thefreelibrary.com/Tetracycline+diffusion+through+bacterial+cellulose--polyvinyl+alcohol...a0177174822 "Facts about E. coli: dimensions, as discussed in bacteria: Diversity of structures of bacteria: - Britannica Online Encyclopedia" Britannica.com "E. coli Statistics". The CyberCell Database. "Antimicrobial properties: Toxicity of tetracyclines towards bacteria" University of Bristol: Molecule of the Month. http://www.chm.bris.ac.uk/motm/tetracycline/antimicr.htm Saupe, S. G. (2009, February 13). Water, diffusion and osmosis. Retrieved from http://employees.csbsju.edu/ssaupe/biol327/Lecture/water.htm