fileNames = c( paste('simulationsText','succinateInfectedSimulation.txt', sep= .Platform$file.sep),
paste('simulationsText','acetateInfectedSimulation.txt', sep= .Platform$file.sep),
paste('simulationsText','glucoseInfectedSimulation.txt', sep= .Platform$file.sep),
paste('simulationsText','tryptoneInfectedSimulation.txt', sep= .Platform$file.sep) )
options( warn = 1 )
mediaLegend <- c('Succinate', 'Acetate','Glucose','Tryptone')
# key time point at which either a reference line is plotted on sparks, or flux value is converted to arrow width
tIdx = 1
# plotting parameters
totalScaleUnits = 30
arrowsBarbAngle = 30
arrowsBarbLength = 0.25
textSize = 8
zeroThresh = 1e-5
# colsSparks <- c('mediumorchid3','orange1')
colsSparks <- c('darkgoldenrod1','olivedrab3','steelblue3','coral3')
colsClusters <- c('goldenrod1', 'mediumorchid3','firebrick1','olivedrab3', 'cadetblue4', 'dodgerblue3',
'thistle3', 'seagreen3', 'snow4', 'cyan4', 'springgreen3',
'violetred4','midnightblue','chocolate4') # ,, 'darkorange2'
colLowSpark <- 'grey50'
colHighSpark <- 'grey50'
# plot type
# 1 is with varrying arrow weights, 2 is a map with equal arrow weights, 3 colors arrows by cluster
plotType = 2
sparkFlag <- TRUE
sparkScaleFlag <- TRUE
normSparkFlag <- TRUE
upFlag <- FALSE
# ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
# ^ user input & parameter tweaks above here above here ^
# basic preparations
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# read in data
# dataTable <- read.table(fileName, sep='\t', header = TRUE)
# get subset of table with values for host (such as fluxes)
# hostTable <- subset(dataTable, hostFlag == 1) # remove eventually
nSim <- length( fileNames )
hostList <- list()
#
for( i in 1:nSim){
# read in data
dataTableTemp <- read.table(fileNames[i], sep='\t', header = TRUE)
hostTableTemp <- subset(dataTableTemp, hostFlag == 1)
hostList[i] <- list( hostTableTemp )
}
# library load
library(grid)
# open graphics device
# postscript(file = "figure6",horizontal = FALSE, paper = "letter", family = "Courier")
# pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# pdf(file='figure6.pdf', height=7.5, width=7.5, onefile=TRUE, family='Courier')
postscript(paste('figureOutput',"figure6a_18cm_width.eps", sep= .Platform$file.sep), width = 6.8, height = 6.8, horizontal = FALSE, onefile = FALSE,
paper = "special", pointsize = 8) # , family='Courier'
# plotting viewport
pushViewport( viewport(width=unit(6.6,"inches"),height=unit(6.6,"inches"), name = 'plotViewport',
xscale = c(0,totalScaleUnits), yscale = c(0,totalScaleUnits) ) )
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
gpText <- gpar(fontsize = textSize) # , just = c("centre", "centre")
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
allShift <- 3
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
xGlycolysis = 5 + allShift
xLowerGlycolysis = xGlycolysis
yG6P = 24
xTCA = xLowerGlycolysis + 2
yTCA = 4.5
rTCA = 3
wSparkLines <- 1
hSparkLines <- 0.5
xPP <- xGlycolysis + 5
yPP = yG6P - 2
xAA1 <- 14 + allShift
sAA <- 1.5
yAA <- yTCA-rTCA/3 - 2*sAA
yGLT <- yTCA-rTCA/3
yASP <- yTCA+rTCA*5/6 + 1
xAA2 <- 17.5 + allShift
ySER <- yG6P - 9
yTYR <- yG6P - 11
yPYR <- yG6P - 13
xMembrane <- xGlycolysis - 5.5
yMembrane <- yG6P - 2 - 4*sAA
sSL <- 0.25
dNT <- 1.5*sAA
sNT <- 1.25*sAA
yNT <- yPP - sNT + 2
xNT <- xAA2 + 0.5
yT7 <- 3.5
xT7 <- 29
sT7 <- 2
vS <- 0.25
hS <- 0.25
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# subfunctions
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
sparkLine <- function( xLocationSpark, yLocationSpark, wSpark, hSpark, xValuesSpark, yValuesSpark, idxKeySpark = 1, cexSpark = 0.4 ) {
# should the unit conversions occur in here? or be passed?
xValuesSpark <- xValuesSpark[[1]]
yValuesSpark <- yValuesSpark[[1]]
# this is the "inital" value where the dotted line will be placed, with values above in green and below in red
oSpark <- yValuesSpark[idxKeySpark ]
# ranges to use in axes for sparkline, extend slightly from data to avoid rough edges produced by clipping
xRangeSpark <- xValuesSpark[length(xValuesSpark)] - xValuesSpark[1]
xScaleSpark <- c(xValuesSpark[1], xValuesSpark[length(xValuesSpark)]+xRangeSpark*0.05)
yRangeSpark <- max(yValuesSpark)-min(yValuesSpark)
zeroThreshSparkRange <- 1e-9
sparkON <- TRUE
if ( abs(yRangeSpark) > zeroThreshSparkRange ){
yScaleSpark <- c( min(yValuesSpark)-0.1*yRangeSpark, max(yValuesSpark)+0.1*yRangeSpark )
}
else {
yScaleSpark <- c( (oSpark - 1/2), (oSpark + 1/2) )
yRangeSpark <- 1
sparkON <- FALSE
}
if( sparkON ){
# total sprkline viewport
pushViewport( viewport( width = unit( wSpark ,"native"), height = unit( hSpark ,"native"), y = unit( yLocationSpark ,"native"), x = unit( xLocationSpark ,"native"), name = 'sparkViewport',
xscale = xScaleSpark, yscale = yScaleSpark, just = c("left", "bottom"), gp = gpar( cex = cexSpark )))
if( sparkScaleFlag ){
allTick <- pretty( yValuesSpark )
if( (allTick[ length(allTick) ] - allTick[1]) < 1.5*yRangeSpark ){
grid.yaxis( at = c(allTick[1], allTick[ length(allTick) ] )) # at = c(-1, 1)
}
else{
grid.yaxis( at = c(yScaleSpark[1], yScaleSpark[2] ))
}
}
# upper viewport & plotting of values that are above the initial
pushViewport( viewport( width = unit( (xScaleSpark[2] - xScaleSpark[1]),"native"), height = unit( (yScaleSpark[2]-oSpark) ,"native"),
y = unit( oSpark ,"native"), x = unit( xScaleSpark[1] ,"native"),
name = 'sparkUpViewport', xscale = xScaleSpark, yscale = c(oSpark, yScaleSpark[2]), just = c("left", "bottom"), clip = "on"))
grid.lines( x = unit( xValuesSpark, "native" ), y = unit( yValuesSpark, "native" ) , gp = gpar(col = colHighSpark))
popViewport()
# lower viewport & plotting of values that are below the initial
pushViewport( viewport( width = unit( (xScaleSpark[2] - xScaleSpark[1]),"native"), height = unit( (oSpark-yScaleSpark[1]) ,"native"),
y = unit( yScaleSpark[1] ,"native"), x = unit( xScaleSpark[1] ,"native"),
name = 'sparkLowViewport', xscale = xScaleSpark, yscale = c( yScaleSpark[1],oSpark), just = c("left", "bottom"), clip = "on"))
grid.lines( x = unit( xValuesSpark, "native" ), y = unit( yValuesSpark, "native" ) , gp = gpar(col = colLowSpark))
popViewport()
# "mid" viewport, plotting of vales considered to be at the inital
midHeight = convertUnit( unit(1, 'points'), 'native', valueOnly = TRUE, axisFrom = "y", typeFrom = "dimension" )
pushViewport( viewport( width = unit( (xScaleSpark[2] - xScaleSpark[1]),"native"), height = unit( midHeight ,"native"),
y = unit( oSpark ,"native"), x = unit( xScaleSpark[1] ,"native"),
name = 'sparkMidViewport', xscale = xScaleSpark, yscale = c( oSpark-midHeight/2, oSpark+midHeight/2), just = c("left", "center"), clip = "on"))
grid.lines( x = unit( xValuesSpark, "native" ), y = unit( yValuesSpark, "native" ) , gp=gpar(col = "gray47"))
popViewport()
# dotted line at initial value
grid.lines( x = unit( xScaleSpark, "native" ), y = unit(c(oSpark, oSpark), "native" ), gp=gpar(col = "gray47",lty="dotted") )
# grid.yaxis()
popViewport()
}
}
sparkLineMulti <- function( xLocationSpark, yLocationSpark, wSpark, hSpark, xValuesSpark, yValuesSpark, colorSparks, idxKeySpark = 1, cexSpark = 0.6 ) {
# xValuesSpark will be a list, find length (assume ySPark Values will have the same length)
nSparks = length( xValuesSpark )
zeroThreshSparkRange <- 1e-10
# rescale sparks if flagged
if( normSparkFlag ){
for(iSpark in 1:nSparks){
yValuesSpark[[iSpark]] <- yValuesSpark[[iSpark]] - yValuesSpark[[iSpark]][2]
maxMagnitude <- max( abs( yValuesSpark[[iSpark]] ) )
if( maxMagnitude > zeroThreshSparkRange ) yValuesSpark[[iSpark]] <- yValuesSpark[[iSpark]] / maxMagnitude
}
}
# find max & min values for axes
yValuesSparkMax <- max( unlist(yValuesSpark) )
yValuesSparkMin <- min( unlist(yValuesSpark) )
xValuesSparkMax <- max( unlist(xValuesSpark) )
xValuesSparkMin <- min( unlist(xValuesSpark) )
# print( yValuesSparkMax )
# print( yValuesSparkMin )
# ranges to use in axes for sparkline, extend slightly from data to avoid rough edges produced by clipping
xRangeSpark <- xValuesSparkMax - xValuesSparkMin
xScaleSpark <- c(xValuesSparkMin, xValuesSparkMax + xRangeSpark*0.05)
yRangeSpark <- yValuesSparkMax - yValuesSparkMin
sparkON <- TRUE
if ( abs(yRangeSpark) > zeroThreshSparkRange ){
yScaleSpark <- c( yValuesSparkMin-0.1*yRangeSpark, yValuesSparkMax+0.1*yRangeSpark )
}
else {
yScaleSpark <- c( (yValuesSparkMin - 1/2), (yValuesSparkMin + 1/2) )
yRangeSpark <- 1
sparkON <- TRUE
}
if( sparkON ){
# total sprkline viewport
pushViewport( viewport( width = unit( wSpark ,"native"), height = unit( hSpark ,"native"), y = unit( yLocationSpark ,"native"), x = unit( xLocationSpark ,"native"), name = 'sparkViewport',
xscale = xScaleSpark, yscale = yScaleSpark, just = c("left", "bottom"), gp = gpar( cex = cexSpark )))
# grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
grid.lines( x = unit( xScaleSpark ,"native"), y= unit( c(0,0) ,"native"), gp=gpar(lty="solid", col = "gray80"))
grid.lines( x = unit( c(0,0) ,"native"), y= unit( yScaleSpark ,"native"), gp=gpar(lty="solid", col = "gray80"))
for( i in 1:nSparks){
grid.lines( x = unit( xValuesSpark[[i]], "native" ), y = unit( yValuesSpark[[i]], "native" ) , gp = gpar(col = colorSparks[i] ))
}
# allTick <- pretty( c( yValuesSparkMax, yValuesSparkMin ) )
if( sparkScaleFlag & !normSparkFlag ){
allTick <- pretty( c( yValuesSparkMax, yValuesSparkMin ) )
if( (allTick[ length(allTick) ] - allTick[1]) < 1.5*yRangeSpark ){
grid.yaxis( at = c(allTick[1], allTick[ length(allTick) ] )) # at = c(-1, 1)
}
else{
grid.yaxis( at = c(yScaleSpark[1], yScaleSpark[2] ))
}
}
# if( (allTick[ length(allTick) ] - allTick[1]) < 1.5*yRangeSpark ){
# grid.yaxis( at = c(allTick[1], allTick[ length(allTick) ] )) # at = c(-1, 1)
# }
# else{
# grid.yaxis( at = c(yScaleSpark[1], yScaleSpark[2] ))
# }
# # grid.yaxis()
popViewport()
}
}
prepareValues <- function( fluxNames, fluxSigns ){
timeValues <- list()
fluxValues <- list()
nIso <- length(fluxNames)
fluxMissingFlag <- FALSE
for( i in 1:nSim){
timeValues <- c( timeValues, list(hostList[[i]][["t"]]) )
fluxNet <- rep(0, length(hostList[[i]][["t"]]) )
hostNames <- names( hostList[[i]] )
for( j in 1:nIso){
fluxName <- fluxNames[j]
if( fluxName %in% hostNames ){
fluxNet <- fluxNet + fluxSigns[j]*hostList[[i]][[ fluxName ]]
}
else{
fluxMissingFlag <- TRUE
}
} # for j
fluxValues <- c( fluxValues, list(fluxNet) )
} # for i
listValues <- list( timeValues, fluxValues, fluxMissingFlag )
return(listValues)
} # prepareValues
maskForArrow <- function( xArrow, yArrow, plotMode, fValue, valueMaxDisplayWeight = 20,weightArrowMax = 5 ){
# line weight
if ( plotMode == 1 ){
if ( abs(fValue) > valueMaxDisplayWeight ){
fValue <- sign( fValue ) * valueMaxDisplayWeight
}
arwLineWidth <- 1 + ( weightArrowMax - 1 ) * abs(fValue) / valueMaxDisplayWeight
}
else{
# plot mode 2 is only one weight of arrow, also default to this
arwLineWidth <- 1
}
maskWidth <- arwLineWidth + 4
grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), gp = gpar( lwd = maskWidth, col = "white" ))
}
arrowPlot <- function( xArrow, yArrow, plotMode, fValue, fluxNames, arrowBarbAngle = arrowsBarbAngle,
arrowBarbLength = arrowsBarbLength, abrevFlag = FALSE, weightArrowMax = 5,
zeroThresh = 1e-5, valueMaxDisplayWeight = 20, arrowDirection = 'fwd', fluxMissingFlag = TRUE){
# arrowDirection should be one of 'fwd', 'rev', 'none'
# set graphical parameters based on mode and flux value
# ........................................................................................................
arwLty <- 1
# line weight
if ( plotMode == 1 ){
fValue <- fValue[tIdx]
if ( abs(fValue) > valueMaxDisplayWeight ){
fValue <- sign( fValue ) * valueMaxDisplayWeight
}
arwLineWidth <- 1 + ( weightArrowMax - 1 ) * abs(fValue) / valueMaxDisplayWeight
}
else{
# plot mode 2 & 3 is only one weight of arrow, also default to this
arwLineWidth <- 1
}
# arrowhead placement and color
arwColor = 'black'
if ( plotMode == 1 && !((arrowDirection) == 'none') ){
# plot arrowhead only in direction of rxn
if ( fValue > zeroThresh ){
# forward (or zero) flux
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
}
else{
if( fValue < (-zeroThresh) ){
# backward flux
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
}
else{
# case when flux is zero, use
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "both", type = "open")
arwColor = 'grey70'
}
}
}
else{
if ( arrowDirection == 'fwd' ){
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
}
else{
if ( arrowDirection == 'rev' ){
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "both", type = "open")
}
else{
arwHead <- NULL
}
}
}
plotReverseTooFlag <- FALSE
# arrow color if plot type 3
if( plotType == 3 ){
arwColor <- colsClusters[1]
nIso <- length(fluxNames)
if( nIso == 1 ){
# only one flux, use this flux to cluster
arwColor = colsClusters[ fluxClusters[ fluxNames[1] ] ]
# print('one iso - - - - - - - - - - - - ' )
# print( fluxNames[1] )
# print( fluxClusters[ fluxNames[1] ] )
# print( colsClusters[ fluxClusters[ fluxNames[1] ] ] )
} # if only one flux
else{
# multiple fluxes associated
# determine how many of the fluxes are nonzero and varying
logicalRealClusters <- (fluxClusters[ fluxNames ] > 2)
nRealClusters <- sum(logicalRealClusters, na.rm=TRUE)
#
if( nRealClusters == 0 ){
if( any( (fluxClusters[ fluxNames ] == 2), na.rm=TRUE ) ){
# there is at least one constant non-zero flux, black arrow
arwColor <- colsClusters[2]
} # constant nonzero
} # no varrying clusters
else{
if( nRealClusters == 1 ){
# only one real cluster, color arrow
arwColor <- colsClusters[ fluxClusters[ fluxNames[logicalRealClusters] ] ]
# print('one real - - - - - - - - - - - -' )
# print( fluxNames[logicalRealClusters] )
# print( fluxClusters[ fluxNames[logicalRealClusters] ] )
# print( colsClusters[ fluxClusters[ fluxNames[logicalRealClusters] ] ] )
} # one varrying flux
else{
realClusters <- fluxNames[logicalRealClusters]
arwColor <- colsClusters[ fluxClusters[ realClusters[1] ] ]
# print( c('warning multiple varrying fluxes for: ', realClusters ) )
} # more than 1 varying flux
} # any varying fluxes
} # multiple fluxes associated with arrow
# set up arrow head for type 3
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open") # changed from both
# plotReverseTooFlag <- TRUE
allPositive <- all( fValue >= 0, na.rm=TRUE)
allNegative <- all( fValue <= 0 , na.rm=TRUE)
if( !allNegative ){ #if( allPositive ){
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
if( arrowDirection == 'rev' ){
plotReverseTooFlag <- TRUE
}
}
else{
if( allNegative ){
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
plotReverseTooFlag <- TRUE
}
}
} # set up colors for plot type 3
if( (arrowDirection) == 'none' ) arwHead <- NULL
if ( !abrevFlag ){
if(fluxMissingFlag){
arwLty <- 1
arwColor <- 'grey50'; #colsClusters[2] # colsClusters[1]
if( (arrowDirection) == 'rev') arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "both", type = "open")
}
if( plotType == 2 && (arrowDirection) == 'rev'){
plotReverseTooFlag <- TRUE
}
# plot arrow
if( plotReverseTooFlag && !((arrowDirection) == 'none') ){
# arwHeadRev <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "both", type = "open")
arwHeadRev1 <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
# arwHeadRev2 <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHeadRev1, gp = gpar( lwd = arwLineWidth, col = 'grey50' , lty = arwLty))
# grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHeadRev2, gp = gpar( lwd = arwLineWidth, col = arwColor , lty = arwLty))
arwHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
}
# arwHeadRev1 <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
# arwHeadRev2 <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
# grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHeadRev1, gp = gpar( lwd = arwLineWidth, col = 'grey50' , lty = arwLty))
# grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHeadRev2, gp = gpar( lwd = arwLineWidth, col = arwColor , lty = arwLty))
#
grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHead, gp = gpar( lwd = arwLineWidth, col = arwColor, lty = arwLty ))
}
else{
# note that this method is only intended to function for single linear segments
segmentLength <- sqrt( (xArrow[2] - xArrow[1])^2 + (yArrow[2] - yArrow[1])^2 )
abrevLengthOneDotPts <- 3 * arwLineWidth
abrevLengthOneDot <- convertUnit( unit(abrevLengthOneDotPts, "points"), "native", valueOnly = TRUE )
abrevLengthThreeDotsPts <- 6 * arwLineWidth
abrevLengthTheeDots <- convertUnit( unit(abrevLengthThreeDotsPts, "points"), "native", valueOnly = TRUE )
abrevLength <- ifelse( abrevLengthTheeDots > (0.7 * segmentLength), abrevLengthOneDot, abrevLengthTheeDots)
# abrevLength <- abrevLengthTheeDots
abrevFraction <- abrevLength / segmentLength
xSegment <- (xArrow[2] - xArrow[1])
ySegment <- (yArrow[2] - yArrow[1])
# 'tail' segment
xTailAbrev <- (xArrow[1] + xSegment*(1-abrevFraction)/2)
xTail <- c(xArrow[1], xTailAbrev )
yTailAbrev <- (yArrow[1] + ySegment*(1-abrevFraction)/2)
yTail <- c( yArrow[1], yTailAbrev )
# 'head' segment
xHeadAbrev <- (xArrow[2] - xSegment*(1-abrevFraction)/2)
xHead <- c( xHeadAbrev, xArrow[2] )
yHeadAbrev <- (yArrow[2] - ySegment*(1-abrevFraction)/2)
yHead <- c( yHeadAbrev, yArrow[2] )
# 'abrev' segment
xAbrev <- c( xTailAbrev, xHeadAbrev )
yAbrev <- c( yTailAbrev, yHeadAbrev )
# deal with head options
# arrowhead placement and color
# arwColor = 'black'
if ( plotMode == 1 && !((arrowDirection) == 'none') ){
# plot arrowhead only in direction of rxn
if ( fValue > zeroThresh ){
# forward flux
arwHeadHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
arwHeadTail <- NULL
}
else{
if( fValue < (-zeroThresh) ){
# backward flux
arwHeadTail <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
arwHeadHead <- NULL
}
else{
# case when flux is zero, use
arwHeadHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
arwHeadTail <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
arwColor = 'grey80'
}
}
}
else{
if ( arrowDirection == 'fwd' ){
arwHeadHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
arwHeadTail <- NULL
}
else{
if ( arrowDirection == 'rev' ){
arwHeadHead <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "last", type = "open")
arwHeadTail <- arrow(angle = arrowBarbAngle, length = unit(arrowBarbLength, "native"), ends = "first", type = "open")
}
else{
arwHeadHead <- NULL
arwHeadTail <- NULL
}
}
}
# plot
if(fluxMissingFlag){
arwLty <- 2
arwColor <- colsClusters[1]
}
grid.lines(x = unit(xTail,"native"), y = unit(yTail,"native"), arrow = arwHeadTail, gp = gpar( lwd = arwLineWidth, col = arwColor, lty = arwLty ) )
grid.lines(x = unit(xHead,"native"), y = unit(yHead,"native"), arrow = arwHeadHead, gp = gpar( lwd = arwLineWidth, col = arwColor, lty = arwLty ) )
grid.lines(x = unit(xAbrev,"native"), y = unit(yAbrev,"native"), gp = gpar( lwd = arwLineWidth, col = arwColor, lty = '11' ) )
}
# ........................................................................................................
}
addFluxArwAndSpark <- function(xArrow, yArrow, dirArrow, abrevArrow, xSpark, ySpark, fluxNames, fluxSigns, maskFlag = FALSE){
if( upFlag || !(length(xArrow) == 1) ){
# begin by preparing vlaues
valuesFlux <- prepareValues( fluxNames, fluxSigns )
fValueArw <- valuesFlux[[2]][[1]]
missingFlag <- valuesFlux[[3]]
# plot arrows
if( is.list(xArrow) ){
# arrows given as list, must plot multiple
nArw <- length( xArrow )
# check for need to mask before plotting arrows
if( maskFlag ){
for( i in 1:nArw ){
maskForArrow( xArrow = xArrow[[i]], yArrow = yArrow[[i]], plotMode = plotType, fValue = fValueArw)
} # for i
} # if mask
# plot arrows
for( i in 1:nArw){
arrowPlot( xArrow = xArrow[[i]], yArrow = yArrow[[i]] , arrowDirection = dirArrow[i], fValue = fValueArw, fluxNames = fluxNames,
arrowBarbAngle = arrowsBarbAngle, arrowBarbLength = arrowsBarbLength, abrevFlag = abrevArrow[i],
plotMode = plotType, fluxMissingFlag = missingFlag)
} # for i
}
else{
# only one segment to arrow
# check for need to mask before plotting arrows
if( maskFlag ){
maskForArrow( xArrow = xArrow, yArrow = yArrow, plotMode = plotType, fValue = fValueArw)
} # if mask
# plot arrow
arrowPlot( xArrow = xArrow, yArrow = yArrow , arrowDirection = dirArrow, fValue = fValueArw, fluxNames = fluxNames,
arrowBarbAngle = arrowsBarbAngle, arrowBarbLength = arrowsBarbLength,
abrevFlag = abrevArrow, plotMode = plotType, fluxMissingFlag = missingFlag)
} # else xArrow is list
# test if sparkline is to be plotted
if( sparkFlag & !(is.null( xSpark ))){
if(is.character(ySpark)){
ySparkChar <- ySpark
# assume center
ySpark <- (max(unlist(yArrow)) + min(unlist(yArrow)))/2 - hSparkLines/2
if( ySparkChar == 'A'){
# above
ySpark <- max(unlist(yArrow)) + vS
}
if( ySparkChar == 'B' ){
# below
ySpark <- min(unlist(yArrow)) - vS - hSparkLines
}
if( ySparkChar == 'BC' ){
# below
ySpark <- min(unlist(yArrow)) - hSparkLines/2
}
if( ySparkChar == 'BB' ){
# below
ySpark <- min(unlist(yArrow))
}
if( ySparkChar == 'AE'){
# above
ySpark <- max(unlist(yArrow)) + 1.5*vS
}
if( ySparkChar == 'BE' ){
# below
ySpark <- min(unlist(yArrow)) - 1.5*vS - hSparkLines
}
} # if y char
if(is.character(xSpark)){
xSparkChar <- xSpark
xSpark <- (max(unlist(xArrow)) + min(unlist(xArrow)))/2 - wSparkLines/2
if( xSparkChar == 'R'){
# above
xSpark <- max(unlist(xArrow)) + hS
}
if( xSparkChar == 'L' ){
# below
xSpark <- min(unlist(xArrow)) - hS - wSparkLines
}
if( xSparkChar == 'LF' ){
# below
xSpark <- min(unlist(xArrow)) - wSparkLines
}
if( xSparkChar == 'RC' ){
# below
xSpark <- (max(unlist(xArrow)) + min(unlist(xArrow)))/2
}
} # if y char
if( nSim > 1 ){
# plot the sparkline
sparkLineMulti(xLocationSpark = xSpark, yLocationSpark = ySpark, wSpark = wSparkLines, hSpark = hSparkLines,
xValuesSpark = valuesFlux[[1]], yValuesSpark = valuesFlux[[2]], colorSparks = colsSparks, idxKeySpark = tIdx)
}
else{
sparkLine( xLocationSpark= xSpark, yLocationSpark= ySpark, wSpark = wSparkLines, hSpark = hSparkLines,
xValuesSpark = valuesFlux[[1]], yValuesSpark = valuesFlux[[2]], idxKeySpark = tIdx )
}
}
}
}
clusterFluxes <- function( fluxTable ){
dataAll <- fluxTable
# remove any concentrations based on name begining with CONC
nameOfCols <- colnames(dataAll)
# # try
# for( i in 1:length(nameOfCols)){
# valuesTemp <- dataAll[[ nameOfCols[i] ]] - dataAll[[ nameOfCols[i] ]][1]
# if( any( abs( valuesTemp ) > zeroThresh ) ){
# dataAll[[ nameOfCols[i] ]] <- valuesTemp / max( abs( valuesTemp ) )
# }
# }
notFluxes <- c( grep("^CONC", nameOfCols, value=TRUE), 't', 'biomass', 'hostFlag')
justFluxes <- nameOfCols[!nameOfCols %in% notFluxes ]
dataFluxes <- dataAll[justFluxes]
# get fluxes that vary (to not break the distance metrics)
zeroThresh <- 1e-9
fluxStDevs <- apply(dataFluxes, 2, sd)
logicalFluxesThatVary <- fluxStDevs > zeroThresh
dataForDist <- as.matrix(dataFluxes[ ,logicalFluxesThatVary ])
# dataForDist <- diff( dataForDist, lag = 1 )
# get distance matrix, currently using correlation measure
distancesForCluster <- as.dist( (1 - cor(dataForDist)) )
# distancesForCluster <- dist(dataForDist, method = "euclidean")
# #
# library(lsa) # only needed for cosine
# distancesForCluster <- cosine( as.matrix(dataForDist))
# distancesForCluster <- as.dist( distancesForCluster )
# cluster, devide into groups
clusterObjOfFluxes <- hclust(distancesForCluster, method="average")
clusterGroups <- cutree(clusterObjOfFluxes, k = NULL, h = 0.58)
# print( clusterGroups )
clusterOutput <- list( clusterGroups, justFluxes, dataAll )
return( clusterOutput )
}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Preparations for map plotting
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if( plotType == 3 ){
# note that this only takes the first flux and colors the map
clusterOutput <- clusterFluxes( hostList[[1]] )
fluxClusters <- clusterOutput [[1]]
fluxAllNames <- clusterOutput [[2]]
hostList[[1]] <- clusterOutput [[3]]
# color index translation initialization
colIdxTrans <- rep( 0, max(fluxClusters) )
# check if the number of flux clusters exceeded the number of defined colors
if( length(colsClusters) < length(fluxClusters) ){
nRepCols <- ceiling( length(fluxClusters)/length(colsClusters) )
colsClusters <- rep(colsClusters, nRepCols)
} # if more clusters than colors
# print( names( fluxClusters ) )
nonClusteredFluxNames <- fluxAllNames[!fluxAllNames %in% names( fluxClusters ) ]
nonClusteredFluxesForZeroTest <- lapply(hostList[[1]][nonClusteredFluxNames], max)
zeroFluxNames <- names(nonClusteredFluxesForZeroTest[ nonClusteredFluxesForZeroTest < zeroThresh ])
constantFluxNames <- names(nonClusteredFluxesForZeroTest[ nonClusteredFluxesForZeroTest >= zeroThresh ])
zeroFluxClusters <- rep( 1, length(zeroFluxNames) )
names( zeroFluxClusters ) <- zeroFluxNames
constantFluxClusters <- rep( 2, length(constantFluxNames) )
names( constantFluxClusters ) <- constantFluxNames
fluxClusters <- c( (fluxClusters+2), constantFluxClusters, zeroFluxClusters )
# print( fluxClusters )
colsClusters <- c( 'gray85', 'black', colsClusters )
}
# print( colsClusters )
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Plot arrows
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
plotTheMap <- function(){
# O2 in
# ........................................................................................................
grid.text("O2(media)", x = unit(xGlycolysis+ 9, "native"), y = unit(yG6P + 5.5, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = c(xGlycolysis+ 9,xGlycolysis+ 9), yArrow = c(yG6P + 5,yG6P + 3), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C',
fluxNames = c('eO2'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
plotGlycolysisMain <- function(){
# Glucose in media
# .........................................
grid.text("Glucose(media)", x = unit(xGlycolysis, "native"), y = unit(yG6P + 5.5, "native"), gp = gpText )
# .........................................
# GLC up to g6p
# ........................................................................................................
t <- seq(from=pi/4, to=-pi/4, by=-pi/20)
x_GlucInToG6P <- cos(t)*3 + xGlycolysis - 1.75
y_GlucInToG6P <- yG6P + 2.75 + sin(t)*3
addFluxArwAndSpark(xArrow = x_GlucInToG6P, yArrow = y_GlucInToG6P,
dirArrow = 'fwd', abrevArrow = FALSE, xSpark = 'R', ySpark = 'C',
fluxNames = c('tMALX1','tMALX2','tGLCPTS'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# ........................................................................................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis, xGlycolysis), yArrow = c(yG6P+5, yG6P+3.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'BB',
fluxNames = c('tGLCUP'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# G1P
# .........................................
grid.text("G1P", x = unit(xGlycolysis - 2.5, "native"), y = unit(yG6P , "native"), gp = gpText )
# .........................................
# PGMR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis - 0.75, xGlycolysis - 1.75), yArrow = c(yG6P , yG6P ),
dirArrow = 'rev', abrevArrow = FALSE, xSpark = 'C', ySpark = 'A',
fluxNames = c('cPGMR','cYQABR'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
# GLCD
# .........................................
grid.text("GLCD", x = unit(xGlycolysis, "native"), y = unit(yG6P + 3, "native"), gp = gpText )
# .........................................
# GLK
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis, xGlycolysis), yArrow = c(yG6P+2.5, yG6P+0.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cGLK'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# G6P
# .........................................
grid.text("G6P", x = unit(xGlycolysis, "native"), y = unit(yG6P, "native"), gp = gpText )
# .........................................
# PGIR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis, xGlycolysis), yArrow = c(yG6P-0.5, yG6P-1.5), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cPGIR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# F6P
# .........................................
grid.text("F6P", x = unit(xGlycolysis, "native"), y = unit(yG6P - 2, "native"), gp = gpText )
# .........................................
# PFKB etc
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis+0.25, xGlycolysis+0.25), yArrow = c(yG6P-2.5, yG6P-3.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cPFKB','cPFKA'), fluxSigns = c(1,1), maskFlag = FALSE)
addFluxArwAndSpark(xArrow = c(xGlycolysis-0.25, xGlycolysis-0.25), yArrow = c(yG6P-3.5, yG6P-2.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cFBP'), fluxSigns = c(1), maskFlag = FALSE)
# ........................................................................................................
# FDP
# .........................................
grid.text("FDP", x = unit(xGlycolysis, "native"), y = unit(yG6P - 4, "native"), gp = gpText )
# .........................................
# FBAR
# ........................................................................................................
addFluxArwAndSpark(xArrow = list(c(xGlycolysis, xGlycolysis, xGlycolysis+1),c(xGlycolysis, xGlycolysis, xGlycolysis-1)),
yArrow = list(c(yG6P-4.5, yG6P-5.5, yG6P-6.5),c(yG6P-4.5, yG6P-5.5, yG6P-6.5)) , dirArrow = c('rev','rev'),
abrevArrow = c(FALSE, FALSE), xSpark = (xGlycolysis - sSL - wSparkLines), ySpark = (yG6P-5.5),
fluxNames = c('cB1773R' , 'cFBAR' , 'cFBABR'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# ........................................................................................................
# DHAP
# .........................................
grid.text("DHAP", x = unit(xGlycolysis-1.1, "native"), y = unit(yG6P - 7, "native"), gp = gpText )
# .........................................
# G3P
# .........................................
grid.text("G3P", x = unit(xGlycolysis+1.1, "native"), y = unit(yG6P - 7, "native"), gp = gpText )
# .........................................
# TPIAR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis-0.35, xGlycolysis+0.35), yArrow = c(yG6P-7, yG6P-7), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cTPIAR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# (GAPAR, GAPCR) & PGKR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis+1, xLowerGlycolysis), yArrow = c(yG6P-7.5, yG6P-8.5), dirArrow = 'rev',
abrevArrow = TRUE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cPGKR'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
# 3PG
# .........................................
grid.text("3PG", x = unit(xLowerGlycolysis, "native"), y = unit(yG6P - 9, "native"), gp = gpText )
# .........................................
# (GPMAR, GPMBR) & ENOR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis, xLowerGlycolysis), yArrow = c(yG6P-9.5, yG6P-10.5), dirArrow = 'rev',
abrevArrow = TRUE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cENOR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# PEP
# .........................................
grid.text("PEP", x = unit(xLowerGlycolysis, "native"), y = unit(yG6P - 11, "native"), gp = gpText )
# .........................................
# PYKF,PYKA & PPSA
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis+0.25, xLowerGlycolysis+0.25), yArrow = c(yG6P-11.5, yG6P-12.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cPYKF','cPYKA'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis-0.25, xLowerGlycolysis-0.25), yArrow = c(yG6P-12.5, yG6P-11.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cPPSA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# PYR
# .........................................
grid.text("PYR", x = unit(xLowerGlycolysis, "native"), y = unit(yG6P - 13, "native"), gp = gpText )
# .........................................
# ACEE
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis, xLowerGlycolysis), yArrow = c(yG6P-13.5, yG6P-14.5), dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = (xLowerGlycolysis+0.75), 'C',
fluxNames = c('cACEE'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# AcCoA
# .........................................
grid.text(" AcCoA", x = unit(xLowerGlycolysis, "native"), y = unit(yG6P - 15, "native"), gp = gpText )
# .........................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis-0.75, xLowerGlycolysis-4.25), yArrow = c(yG6P-15.12, yG6P-15.12), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = (xLowerGlycolysis - 3 - wSparkLines), ySpark = 'B',
fluxNames = c('cACKAR'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
# AC
# .........................................
grid.text("AC", x = unit(xLowerGlycolysis-5, "native"), y = unit(yG6P - 15, "native"), gp = gpText )
# .........................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xLowerGlycolysis-5, xLowerGlycolysis-5), yArrow = c(yG6P-17.5, yG6P-15.5), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('tACUPR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# AC[ex]
# .........................................
grid.text("AC(media)", x = unit(xTCA-rTCA/3 - 4.75, "native"), y = unit(yG6P - 18, "native"), gp = gpText , just = c("right", "center"))
# .........................................
# GLYCOGEN
# .........................................
grid.text("GLYCGN", x = unit(xGlycolysis - 5.5, "native"), y = unit(yG6P , "native"), gp = gpText )
# .........................................
# to GLYCOGEN
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis - 3.25, xGlycolysis - 4.25), yArrow = c(yG6P , yG6P ),
dirArrow = 'fwd', abrevArrow = FALSE, xSpark = "C", ySpark = 'B',
fluxNames = c('cGLGA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
}
plotGlycolysisMain()
# to ASP
# ........................................................................................................
t <- seq(from=pi*9/8, to=pi/2, by=-pi/20)
xOAAtoASP <- c((cos(t)*0.5 + xTCA-rTCA/2 - 0.5), xAA1 - 0.75)
yOAAtoASP <- c((sin(t)*0.5 + yTCA+rTCA*5/6 + 0.5), yASP )
addFluxArwAndSpark(xArrow = xOAAtoASP, yArrow = yOAAtoASP, dirArrow = 'rev', abrevArrow = FALSE, xSpark = (xLowerGlycolysis+3), ySpark = (yASP+1/3),
fluxNames = c('cASPC1R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# from OAA
# ........................................................................................................
t <- seq(from=pi*3/2, to=pi, by=-pi/20)
t2 <- seq(from=pi, to=pi/2, by=-pi/20)
xOAAtoPEP <- c((cos(t)*0.75 + xTCA-rTCA/2 - 1.25), (cos(t2)*0.75 + xTCA-rTCA/2 - 1.25))
yOAAtoPEP <- c((sin(t)*0.75 + yTCA+rTCA*5/6 + 0.65), (sin(t2)*0.75 + yG6P - 11 - 0.75) )
addFluxArwAndSpark(xArrow = xOAAtoPEP, yArrow = yOAAtoPEP, dirArrow = 'fwd', abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cPCKA'), fluxSigns = c( 1 ), maskFlag = TRUE)
xPEPtoOAA <- rev(c((cos(t)*0.5 + xTCA-rTCA/2 - 1.25), (cos(t2)*0.5 + xTCA-rTCA/2 - 1.25)))
yPEPtoOAA <- rev(c((sin(t)*0.5 + yTCA+rTCA*5/6 + 0.65), (sin(t2)*0.5 + yG6P - 11 - 0.75) ))
addFluxArwAndSpark(xArrow = xPEPtoOAA, yArrow = yPEPtoOAA, dirArrow = 'fwd', abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cPPC'), fluxSigns = c( 1 ), maskFlag = TRUE)
# ........................................................................................................
# from MAL
# ........................................................................................................
t <- seq(from=pi*5/4, to=pi, by=-pi/20)
t2 <- seq(from=pi, to=pi/2, by=-pi/20)
xMALtoPYR <- c((cos(t)*0.75 + xTCA-rTCA - 0.4), (cos(t2)*0.75 + xTCA-rTCA - 0.4),xLowerGlycolysis-0.75 )
yMALtoPYR <- c((sin(t)*0.75 + yTCA+rTCA/3 + 0.65), (sin(t2)*0.75 + yG6P - 13 - 0.75), (yG6P - 13))
addFluxArwAndSpark(xArrow = xMALtoPYR, yArrow = yMALtoPYR, dirArrow = 'fwd', abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
fluxNames = c('cMAEB','cSFCA'), fluxSigns = c( 1,1 ), maskFlag = TRUE)
# ........................................................................................................
# ACEB, GLCB (glx part 2)
# ........................................................................................................
t <- seq(from=pi/3, to=-pi/2, by=-pi/20)
xACNR_1 <- c((cos(t)*rTCA/2 + xTCA - rTCA*2/3), xTCA - rTCA*3/4)
yACNR_1 <- c((sin(t)*rTCA/2 + yTCA + rTCA*5/6), yTCA + rTCA/3 )
xACNR_2 <- c(xTCA - rTCA*0.35, xTCA - rTCA*3/4)
yACNR_2 <- c( yTCA + rTCA/3, yTCA + rTCA/3)
addFluxArwAndSpark(xArrow = list( xACNR_1,xACNR_2), yArrow = list( yACNR_1,yACNR_2), dirArrow = c('fwd', 'fwd'), abrevArrow = c(FALSE, FALSE),
xSpark = NULL, ySpark = NULL, fluxNames = c('cACEB', 'cGLCB'), fluxSigns = c( 1,1 ), maskFlag = TRUE)
# ........................................................................................................
# the TCA cycle
plotTCACycle <- function(){
# GLTA
# ........................................................................................................
fValueGLTA <- 1
t1 <- seq(from=-3*pi/4, to=-pi/2, by=pi/100)
t2 <- seq(from=2*pi/3*0.95, to=pi/3*1.05, by=-pi/100)
xGLTA_1 <- (cos(t1)*rTCA + xTCA)
yGLTA_1 <- (sin(t1)*rTCA + 2*rTCA+yTCA)
xGLTA_2 <- (cos(t2)*rTCA + xTCA)
yGLTA_2 <- (sin(t2)*rTCA + yTCA)
addFluxArwAndSpark(xArrow = list(xGLTA_1,xGLTA_2), yArrow = list(yGLTA_1,yGLTA_2), dirArrow = c('none','fwd'),
abrevArrow = c(FALSE, FALSE), xSpark = NULL, ySpark = NULL,
fluxNames = c('cGLTA'), fluxSigns = c( 1 ), maskFlag = TRUE)
# ........................................................................................................
# Succ in (proton co)
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-4.5,xTCA-rTCA/3-1.75), yArrow = c(yTCA-rTCA*5/6+0.2,yTCA-rTCA*5/6+0.2), dirArrow = c('fwd'),
abrevArrow = c(FALSE), xSpark = 'L', ySpark = 'A',
fluxNames = c('tDCTA1','tDCUB1','tDCUA1'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# ........................................................................................................
# Succ in (fum exch)
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-4.5,xTCA-rTCA/3-1.75), yArrow = c(yTCA-rTCA*5/6-0.2,yTCA-rTCA*5/6-0.2), dirArrow = c('fwd'),
abrevArrow = c(FALSE), xSpark = 'L', ySpark = 'B',
fluxNames = c('tDCUA5R','tDCUB5R','tDCUC2R'), fluxSigns = c( -1,-1,-1 ), maskFlag = FALSE)
# ........................................................................................................
# Succ in (cit exch)
# ........................................................................................................
# addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-0.5,xTCA-rTCA/3-0.5), yArrow = c(yTCA-rTCA*5/6-2.25,yTCA-rTCA*5/6-0.25), dirArrow = c('fwd'),
# abrevArrow = c(FALSE), xSpark = (xTCA-rTCA/3-2.5), ySpark = (yTCA-rTCA*5/6-3),
# fluxNames = c('tCITT'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
# Succ in (tart exch)
# ........................................................................................................
# addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-0.25,xTCA-rTCA/3-0.25), yArrow = c(yTCA-rTCA*5/6-2.25,yTCA-rTCA*5/6-0.25), dirArrow = c('fwd'),
# abrevArrow = c(FALSE), xSpark = (xTCA-rTCA/3-2.5), ySpark = (yTCA-rTCA*5/6-3),
# fluxNames = c('tYGJER'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
# Succ in (atp)
# ........................................................................................................
# addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-0.25,xTCA-rTCA/3-0.25), yArrow = c(yTCA-rTCA*5/6-2.25,yTCA-rTCA*5/6-0.25), dirArrow = c('fwd'),
# abrevArrow = c(FALSE), xSpark = (xTCA-rTCA/3-2.5), ySpark = (yTCA-rTCA*5/6-3),
# fluxNames = c('cYIAO'), fluxSigns = c( -1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("Succ(media)", x = unit(xTCA-rTCA/3 - 4.75, "native"), y = unit(yTCA-rTCA*5/6, "native"), gp = gpText, just = c("right", "center") )
# TCA metabolites
# .........................................
grid.text("CIT", x = unit(xTCA+rTCA/2, "native"), y = unit(yTCA+rTCA*5/6, "native"), gp = gpText, just = c("left", "center") )
grid.text("ICIT", x = unit(xTCA+rTCA, "native"), y = unit(yTCA+rTCA/3, "native"), gp = gpText, just = c("center", "center") )
grid.text("AKG", x = unit(xTCA+rTCA, "native"), y = unit(yTCA-rTCA/3, "native"), gp = gpText, just = c("center", "center") )
grid.text("SucCoA", x = unit(xTCA+rTCA/3, "native"), y = unit(yTCA-rTCA*5/6, "native"), gp = gpText, just = c("left", "center") )
grid.text("Succ", x = unit(xTCA-rTCA/3, "native"), y = unit(yTCA-rTCA*5/6, "native"), gp = gpText, just = c("right", "center") )
grid.text("FUM", x = unit(xTCA-rTCA, "native"), y = unit(yTCA-rTCA/3, "native"), gp = gpText, just = c("center", "center") )
grid.text("MALL", x = unit(xTCA-rTCA, "native"), y = unit(yTCA+rTCA/3, "native"), gp = gpText, just = c("center", "center") )
grid.text("OAA", x = unit(xTCA-rTCA/2, "native"), y = unit(yTCA+rTCA*5/6, "native"), gp = gpText, just = c("right", "center") )
# .........................................
# ACNAR (CIT to ICIT)
# ........................................................................................................
t <- seq(from=pi/4, to=pi/6, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'R', ySpark = "C",
fluxNames = c('cACNAR','cACNBR'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
# ICDAR (ICIT to AKG)
# ........................................................................................................
t <- seq(from=pi/15, to=-pi/15, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA) , dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'R', ySpark = 'C',
fluxNames = c('cICDAR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# AKG to SuccCoA
# ........................................................................................................
t <- seq(from=-pi/6, to=-pi/4, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = "R", ySpark = 'C',
fluxNames = c('cSUCA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# SUCCR (succ to sucCoA)
# ........................................................................................................
t <- seq(from=-pi/3*1.2, to=-2*pi/3*0.9, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'C', ySpark = 'B',
fluxNames = c('cSUCCR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# SDHA1
# ........................................................................................................
t <- seq(from=pi+pi/4, to=7*pi/6, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA) , dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = 'RC', ySpark = 'A' ,
fluxNames = c('cSDHA1'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ADD other reverse rxns
t <- seq(to=pi+pi/4, from=7*pi/6, by=pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA - 0.4), yArrow = (sin(t)*rTCA + yTCA) , dirArrow = 'fwd',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cFRDA1'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# FUMAR, FUMBR, FUMCR (FUM to MAL)
# ........................................................................................................
t <- seq(from=pi+pi/15, to=pi-pi/15, by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = (xTCA-rTCA-1.25*wSparkLines), ySpark = 'C',
fluxNames = c('cFUMAR', 'cFUMBR', 'cFUMCR' ), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# ........................................................................................................
# MDHR (mal to oaa)
# ........................................................................................................
t <- seq(from=pi*5/6, to=(pi/4*3), by=-pi/100)
addFluxArwAndSpark(xArrow = (cos(t)*rTCA + xTCA), yArrow = (sin(t)*rTCA + yTCA), dirArrow = 'rev',
abrevArrow = FALSE, xSpark = 'L', ySpark = 'C',
fluxNames = c('cMDHR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# cACEA
# ........................................................................................................
t <- seq(from=pi/2, to=pi, by=pi/20)
xACEA_1 <- c(xTCA + rTCA*3/4,(cos(t)*rTCA + xTCA + rTCA*0.6))
xACEA_2 <- c(xTCA + rTCA*3/4, xTCA)
yACEA_1 <- c(yTCA + rTCA/3,(sin(t)*rTCA + yTCA - rTCA*2/3))
yACEA_2 <- c( yTCA + rTCA/3, yTCA + rTCA/3)
addFluxArwAndSpark(xArrow = list(xACEA_1, xACEA_2), yArrow = list( yACEA_1, yACEA_2), dirArrow = c('fwd','fwd'),
abrevArrow = c(FALSE,FALSE), xSpark = 'C', ySpark = 'C',
fluxNames = c('cACEA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("GLX", x = unit(xTCA - rTCA/6, "native"), y = unit(yTCA + rTCA/3, "native"), gp = gpText, just = c("center", "center") )
}
plotTCACycle()
# the pentose phosphate pathway
plotPentosPhosphatePathway <- function(){
# PP pathway
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
grid.text("S7P", x = unit(xPP + 1, "native"), y = unit(yPP , "native"), gp = gpText )
grid.text("X5P", x = unit(xPP - 1, "native"), y = unit(yPP + 2 , "native"), gp = gpText )
grid.text("RU5P", x = unit(xPP, "native"), y = unit( yG6P + 2 , "native"), gp = gpText )
grid.text("R5P", x = unit(xPP + 1, "native"), y = unit(yPP + 2 , "native"), gp = gpText )
grid.text("E4P", x = unit(xPP + 0.5 , "native"), y = unit(yPP - 1 , "native"), gp = gpText )
grid.text("6PGC", x = unit(xPP - 2.35, "native"), y = unit( yG6P + 2 , "native"), gp = gpText )
# RPER (RU5P to X5P)
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xPP - 0.5, xPP - 1), yArrow = c(yG6P + 1.5, yPP + 2.5), dirArrow = 'rev', abrevArrow = FALSE, xSpark = (xPP - 2), ySpark = (yPP + 2.75),
fluxNames = c('cRPER'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# 'cRPIAR','RPIBR'
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xPP + 0.5, xPP + 1), yArrow = c(yG6P + 1.5, yPP + 2.5), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = (xPP + 1.8), ySpark = (yPP + 2.75), fluxNames = c('cRPIAR','cRPIBR'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
# GND
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xPP - 1.5, xPP - 0.9), yArrow = c(yG6P + 2, yG6P + 2), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xPP - 1.5), ySpark = (yG6P + 2.25), fluxNames = c('cGND'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# PGL
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis + 0.75, xPP - 3), yArrow = c(yG6P + 0.25, yG6P + 1.5 ), dirArrow = 'fwd', abrevArrow = TRUE, xSpark = NULL, ySpark = NULL, fluxNames = c('cPGL'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# TKTB1R & TKTA1R ( S7P G3P to X5P R5P)
# ........................................................................................................
t <- seq(from=pi/4, to=-pi/6, by=-pi/20)
xTKTA1Retc_1 <- rev(c((cos(t) + xPP - 1), (xGlycolysis + 1.9) ))
yTKTA1Retc_1 <- rev(c((sin(t) + yPP + 1),yG6P-6.65) )
t <- seq(from=pi*3/4, to=pi*5/4, by=pi/20)
xTKTA1Retc_2 <- rev((cos(t) + xPP + 1))
yTKTA1Retc_2 <- rev((sin(t) + yPP + 1))
addFluxArwAndSpark(xArrow = list(xTKTA1Retc_1, xTKTA1Retc_2), yArrow = list(yTKTA1Retc_1, yTKTA1Retc_2), dirArrow = c('rev', 'rev'),
abrevArrow = c(FALSE,FALSE), xSpark = (xPP + 1.5), ySpark = (yPP + sSL + 0.4),
fluxNames = c('cTKTB1R','cTKTA1R'), fluxSigns = c( 1,1), maskFlag = FALSE)
# ........................................................................................................
# TALBR & TALAR (e4p f6p to g3p s7p )
# ........................................................................................................
t1 <- seq(from=pi/8, to=pi/2, by=pi/20)
t2 <- seq(from=pi/2, to=pi, by=pi/20)
fValueTALARetc <- 1
xTALARetc_1 <- (c((cos(t1) + xPP - 1 ), (cos(t2) + xGlycolysis + 2.25 ), xGlycolysis + 1.25 ))
yTALARetc_1 <- (c((sin(t1) + yPP - 1), (sin(t2) + yPP - 1), yG6P - 6.5))
xTALARetc_2 <- rev(c((xPP + 0.25), xGlycolysis + 0.75 ))
yTALARetc_2 <- rev(c(yPP, yPP))
addFluxArwAndSpark(xArrow = list(xTALARetc_1,xTALARetc_2), yArrow = list(yTALARetc_1,yTALARetc_2), dirArrow = c('rev', 'rev'),
abrevArrow = c(FALSE,FALSE), xSpark = (xGlycolysis + 4), ySpark = (yG6P - 5 - sSL),
fluxNames = c('cTALBR' , 'cTALAR'), fluxSigns = c( 1,1 ), maskFlag = TRUE)
# ........................................................................................................
# TKTB2R & TKTA2R
# ........................................................................................................
t <- seq(from=-7*pi/8, to=-pi/2, by=pi/20)
fValueTKTA2Retc <- 2
xTKTA2Retc_1 <- (c((cos(t) + xGlycolysis + 1.5 ), xPP - 0.25 ))
yTKTA2Retc_1 <- (c((sin(t) + yPP), yPP - 1))
t1 <- seq(from=0, to=-pi/2, by=-pi/20)
t2 <- seq(from=pi/2, to=pi, by=pi/20)
xTKTA2Retc_2 <- rev(c(xPP - 1.25,(cos(t1) + xPP - 2.25 ),(cos(t2) + xPP - 2.35 ), xGlycolysis + 1.65 ))
yTKTA2Retc_2 <- rev(c(yPP + 1.5, (sin(t1) + yPP),(sin(t2) + yPP-2), yG6P-6.5))
addFluxArwAndSpark(xArrow = list(xTKTA2Retc_1,xTKTA2Retc_2), yArrow = list(yTKTA2Retc_1,yTKTA2Retc_2), dirArrow = c('rev', 'rev'),
abrevArrow = c(FALSE,FALSE), xSpark = (xGlycolysis + 2), ySpark = (yG6P-2 + sSL),
fluxNames = c('cTKTB2R','cTKTA2R'), fluxSigns = c( 1,1 ), maskFlag = TRUE)
# ........................................................................................................
}
plotPentosPhosphatePathway()
dAA <- 0.4
plotAminoAcidBranches <- function(){
# grid.rect(x = unit(xAA1 - 1*sAA, "native"), y = unit( yGLT - 1.5*sAA, "native") , height = unit(11.5*sAA, "native"), width = unit( 4*sAA, "native"), gp=gpar(lty="dashed", col = "grey50") ,just = c("left", "bottom"))
grid.text("PRO", x = unit(xAA2, "native"), y = unit(yGLT , "native"), gp = gpText )
grid.text("ARG", x = unit(xAA1, "native"), y = unit(yGLT + 1*sAA , "native"), gp = gpText )
grid.text("GLT", x = unit(xAA1, "native"), y = unit(yGLT , "native"), gp = gpText )
grid.text("GLN", x = unit(xAA1, "native"), y = unit(yGLT - 1*sAA , "native"), gp = gpText )
# grid.text("HIS", x = unit(xAA1, "native"), y = unit(yAA + 4*sAA , "native"), gp = gpText )
# up GLN
addFluxArwAndSpark(xArrow = c( xAA1 + 0.75), yArrow = c(yGLT-sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'R', ySpark = 'A', fluxNames = c('tGLNHPQ'), fluxSigns = c( 1 ), maskFlag = FALSE)
# GLT to GLN
addFluxArwAndSpark(xArrow = c(xAA1,xAA1), yArrow = c(yAA+ 2*sAA-dAA,yAA+ 1*sAA + dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# up GLT
addFluxArwAndSpark(xArrow = c( xAA1 + 0.75), yArrow = c(yGLT+dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'R', ySpark = 'A', fluxNames = c('tGLTUP'), fluxSigns = c( 1 ), maskFlag = FALSE)
# GLT to PRO
addFluxArwAndSpark(xArrow = c( xAA1 + 0.75, xAA2 - 0.75), yArrow = c(yGLT,yGLT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA2 - 0.75), ySpark = ( yGLT - 0.5 - hSparkLines), fluxNames = c('cPROC'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up PRO
addFluxArwAndSpark(xArrow = c( xAA2 + 0.75), yArrow = c(yGLT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'A', fluxNames = c('tPROUPR','tPROUP2','tPROUP2'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# GLT to ARG
addFluxArwAndSpark(xArrow = c(xAA1,xAA1), yArrow = c(yAA+ 2*sAA+dAA,yAA+ 3*sAA -dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = ( xAA1 + 1 ), ySpark = (yGLT + 0.75), fluxNames = c('cARGHR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up ARG
addFluxArwAndSpark(xArrow = c( xAA1 + 0.75), yArrow = c(yGLT+sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1+1.5*sAA), ySpark = 'C', fluxNames = c('tARGUP','tARGUP2','tARCDR'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# AKG to GLT
addFluxArwAndSpark(xArrow = c(xTCA+rTCA+0.75,xAA1-0.75), yArrow = c(yTCA-rTCA/3,yAA+ 2*sAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
grid.text("ASP", x = unit(xAA1, "native"), y = unit(yASP, "native"), gp = gpText )
grid.text("ASN", x = unit(xAA1, "native"), y = unit(yASP - 1*sAA , "native"), gp = gpText )
grid.text("THR", x = unit(xAA2, "native"), y = unit(yASP , "native"), gp = gpText )
grid.text("ILE", x = unit(xAA2, "native"), y = unit(yASP + 1*sAA , "native"), gp = gpText )
grid.text("LYS", x = unit(xAA2, "native"), y = unit(yASP - 1*sAA , "native"), gp = gpText )
# THR(pre) to LYS
t <- seq(from =pi*13/12, to = pi*17/12, by = pi/20)
addFluxArwAndSpark(xArrow = (cos(t)*sAA + xAA2 - sAA/4), yArrow = (sin(t)*sAA + yASP ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA2-0.75), ySpark = (yASP - sAA - 0.5 - hSparkLines), fluxNames = c('cLYSA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up LYS
addFluxArwAndSpark(xArrow = (xAA2+0.75), yArrow = (yASP - 1*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'B', fluxNames = c('tLYSUP1R','tLYSUP2','tLYSUP3'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# up THR
addFluxArwAndSpark(xArrow = (xAA2+0.75), yArrow = (yASP ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'B', fluxNames = c('tTHRUP1','tTHRUP2R','tTHRUP3'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# from ASP to THR
addFluxArwAndSpark(xArrow = c(xAA1+0.75,xAA2-2), yArrow = c(yASP,yASP), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'RC', ySpark = 'A' , fluxNames = c('cASDR'), fluxSigns = c( 1 ), maskFlag = TRUE)
addFluxArwAndSpark(xArrow = c(xAA2-1.75,xAA2-0.75), yArrow = c(yASP,yASP), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c('cTHRC1'), fluxSigns = c( 1 ), maskFlag = FALSE)
# GLY to THR
# ........................................................................................................
addFluxArwAndSpark(xArrow = c( xAA1 +0.75 ,xAA2-0.75), yArrow = c(ySER - 1*sAA - dAA*0.75, yASP+0.5 ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L' , ySpark = (ySER - 1*sAA - 0.75 - hSparkLines ), fluxNames = c('cLTAAR','cGLYA4R'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
# THR to ILE
# arrowPlot( xArrow = c(xAA2, xAA2), yArrow = c(yASP + dAA ,yASP + 1*sAA - dAA ), arrowDirection = 'fwd', fValue = fValueX,
# arrowBarbAngle = arrowsBarbAngle, arrowBarbLength = arrowsBarbLength, abrevFlag = FALSE, plotMode = plotType,
# weightArrowMax = 5, zeroThresh = 1e-5, valueMaxDisplayWeight = 20)
addFluxArwAndSpark(xArrow = c(xAA2, xAA2), yArrow = c(yASP + dAA ,yASP + 1*sAA - dAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'C', ySpark = (yASP + 1*sAA+0.4), fluxNames = c('cILVE1R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up ILE
addFluxArwAndSpark(xArrow = (xAA2+0.75), yArrow = (yASP + 1*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'A', fluxNames = c('tBCAAUP2R','tILEUP'), fluxSigns = c( 1,1), maskFlag = FALSE)
# ASP to ASN
addFluxArwAndSpark(xArrow = c(xAA1+dAA,xAA1+dAA), yArrow = c(yASP-dAA,yASP- sAA +dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c('cASNA1'), fluxSigns = c( 1 ), maskFlag = FALSE)
addFluxArwAndSpark(xArrow = c(xAA1,xAA1), yArrow = c(yASP-dAA,yASP- sAA +dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1 - 0.25 - sSL - wSparkLines), ySpark = (yASP- hSparkLines - sSL), fluxNames = c('cASNB1'), fluxSigns = c( 1 ), maskFlag = FALSE)
addFluxArwAndSpark(xArrow = c(xAA1-dAA,xAA1-dAA), yArrow = c(yASP- sAA +dAA,yASP-dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c('cANSA','cANSB','cYBIK'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# up ASP
addFluxArwAndSpark(xArrow = (xAA1-0.75), yArrow = (yASP - dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'B', fluxNames = c('tASPUP1','tASPUP2','tDCUB2','tDCUA2','tDCTA2'), fluxSigns = c( 1,1,1,1,1), maskFlag = FALSE)
# up ASN
addFluxArwAndSpark(xArrow = (xAA1+0.75), yArrow = (yASP - 1*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'B', fluxNames = c('tASNUP1R','tASNUP2'), fluxSigns = c( 1,1), maskFlag = FALSE)
grid.text("TYR", x = unit(xAA2, "native"), y = unit(yTYR , "native"), gp = gpText )
grid.text("PHE", x = unit(xAA2, "native"), y = unit(yTYR + 1*sAA, "native"), gp = gpText )
grid.text("TRP", x = unit(xAA2, "native"), y = unit(yTYR + 2*sAA, "native"), gp = gpText )
grid.text("HIS", x = unit(xAA2, "native"), y = unit(yTYR + 3*sAA, "native"), gp = gpText )
# PEP to TYR(pre)
t <- seq(from = pi, to = 3*pi/2, by = pi/20)
xAROC_1 = c(xPP + 0.5 , xPP + 0.5, (cos(t) + xPP + 0.5 + 1),xAA2-2)
yAROC_1 = c(yPP - 1.5, yTYR+1, (sin(t) + yTYR + 1),yTYR)
addFluxArwAndSpark(xArrow = list(xAROC_1,c(xGlycolysis+0.75,xAA2-2)), yArrow = list(yAROC_1,c(yG6P - 11,yG6P - 11)), dirArrow = c('fwd','fwd'), abrevArrow = c(FALSE, FALSE),
xSpark = (xLowerGlycolysis+3), ySpark = (yTYR+sSL), fluxNames = c('cAROC'), fluxSigns = c( 1 ), maskFlag = TRUE)
# TYR(pre) to TYR
addFluxArwAndSpark(xArrow = c(xAA2-1.75,xAA2-0.75), yArrow = c(yTYR,yTYR), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA2-0.75), ySpark = (yTYR - 0.5 - hSparkLines), fluxNames = c('cTYRB2R', 'cASPC2R'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# up TYR
addFluxArwAndSpark(xArrow = c(xAA2+0.75), yArrow = c(yTYR), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'B', fluxNames = c('tTYRUPR', 'tTYRUP2R','tTYRUP3R'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# up PHE
addFluxArwAndSpark(xArrow = c(xAA2+0.75), yArrow = c(yTYR + 1*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'BE', fluxNames = c('tPHEUPR', 'tPHEUP2R'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# up TRP
addFluxArwAndSpark(xArrow = c(xAA2+0.75), yArrow = c(yTYR + 2*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'LF', ySpark = 'A', fluxNames = c('tTRPUPR', 'tTRPUP2R','tTRPUP3R'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# TYR(pre) to PHE
t <- seq(from = pi*11/12, to = pi*7/12, by = -pi/20)
addFluxArwAndSpark(xArrow = (cos(t)*sAA + xAA2 - sAA/4), yArrow = (sin(t)*sAA + yTYR ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA2-0.75), ySpark = (yTYR + sAA - 0.5 - hSparkLines), fluxNames = c('cTYRB1R','cASPC3R','cILVE3R'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# TYR(pre) to TRP
t <- seq(from = pi, to = pi/2, by = -pi/20)
xArrow1 = c(xAA2 - 2 , xAA2 - 2, (cos(t) + xAA2 - 1),xAA2 - 0.75)
yArrow1 = c(yTYR+dAA, yTYR+2*sAA -1, (sin(t) + yTYR + 2*sAA -1),yTYR + 2*sAA)
# HIS(pre) to TRP
t <- seq(from = pi, to = pi*3/2, by = pi/20)
xArrow2 = c(xAA2 - 2 , xAA2 - 2, (cos(t) + xAA2 - 1),xAA2 - 0.75)
yArrow2 = c(yTYR+3*sAA, yTYR+2*sAA +1, (sin(t) + yTYR + 2*sAA +1),yTYR + 2*sAA)
addFluxArwAndSpark(xArrow = list(xArrow1, xArrow2), yArrow = list(yArrow1, yArrow2), dirArrow = c('fwd','fwd'), abrevArrow = c(FALSE,FALSE),
xSpark = 'R', ySpark = (yTYR + 2*sAA - 0.4 - hSparkLines), fluxNames = c('cTRPA','cTRPA2','cTNAA3R'), fluxSigns = c( 1,1,-1 ), maskFlag = FALSE)
# PPRP to HIS(pre)
t <- seq(from = pi, to = 5*pi/4, by = pi/20)
xArrow1 = c(xAA2 - 2,xAA2 - 2)
yArrow2 = c(yNT-0.25 + sNT,yTYR+3*sAA + dAA)
addFluxArwAndSpark(xArrow = xArrow1, yArrow = yArrow2, dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# HIS(pre) to HIS
addFluxArwAndSpark(xArrow = c(xAA2-1.75,xAA2-0.75), yArrow = c(yTYR+3*sAA,yTYR+3*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'R', ySpark = 'A', fluxNames = c('cHISD'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up HIS
addFluxArwAndSpark(xArrow = c(xAA2+0.75), yArrow = c(yTYR+3*sAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'A', fluxNames = c( 'tHISUP', 'tHISUP2R'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
grid.text("VAL", x = unit(xAA1, "native"), y = unit(yPYR , "native"), gp = gpText )
grid.text("LEU", x = unit(xAA1, "native"), y = unit(yPYR - 1*sAA, "native"), gp = gpText )
grid.text("ALA", x = unit(xAA2, "native"), y = unit(yPYR , "native"), gp = gpText )
# Val(pre) to VAL
addFluxArwAndSpark(xArrow = c(xAA1-1.75,xAA1-0.75), yArrow = c(yPYR,yPYR), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'RC', ySpark = 'B', fluxNames = c('cILVE2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up VAL
addFluxArwAndSpark(xArrow = c(xAA1+0.75), yArrow = c(yPYR), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'B', fluxNames = c('tBCAAUP3R','tVALUP'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# up LEU
addFluxArwAndSpark(xArrow = c(xAA1-0.75), yArrow = c(yPYR- sAA ), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'B', fluxNames = c('tBCAAUP1R','tLEUUP','tLEUUP2'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# up ALA
addFluxArwAndSpark(xArrow = c(xAA2+0.75), yArrow = c(yPYR), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'AE', fluxNames = c('tALAUP','tCYCAR','tYTFQ2R'), fluxSigns = c( 1,1,1), maskFlag = FALSE)
# PYR to VAL(pre)
addFluxArwAndSpark(xArrow = c(xGlycolysis + 0.75,xAA1-2), yArrow = c(yPYR,yPYR), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xLowerGlycolysis+3), ySpark = (yPYR-1/3-hSparkLines), fluxNames = c('cILVD2'), fluxSigns = c( 1 ), maskFlag = FALSE)
# VAL(pre) to LEU
t <- seq(from =pi*13/12, to = pi*17/12, by = pi/20)
addFluxArwAndSpark(xArrow = (cos(t)*sAA + xAA1 - sAA/4 ), yArrow = (sin(t)*sAA + yPYR ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = ( xAA1 - 3), ySpark = 'BB', fluxNames = c('cILVE4','cTYRB'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# PYR to ALA
t1 <- seq(from = pi*3/4, to = pi/2, by = -pi/20)
t2 <- seq(from = pi/2, to = pi/4, by = -pi/20)
xArrow1 = c( (cos(t1) + xGlycolysis + 1.5),(cos(t2) + xAA2 - 1.5))
yArrow2 = c((sin(t1) + yPYR - dAA),(sin(t2) + yPYR -dAA ))
addFluxArwAndSpark(xArrow = xArrow1, yArrow = yArrow2, dirArrow = 'rev', abrevArrow = FALSE,
xSpark = (xLowerGlycolysis+3), ySpark = (yPYR+5/6), fluxNames = c('cALABR'), fluxSigns = c( 1 ), maskFlag = TRUE)
grid.text("SER", x = unit(xAA1, "native"), y = unit(ySER, "native"), gp = gpText )
grid.text("GLY", x = unit(xAA1, "native"), y = unit(ySER - 1*sAA, "native"), gp = gpText )
grid.text("CYS", x = unit(xAA1, "native"), y = unit(ySER + 1*sAA, "native"), gp = gpText )
grid.text("MET", x = unit(xAA1, "native"), y = unit(ySER + 2*sAA, "native"), gp = gpText )
# 3PG to SER
addFluxArwAndSpark(xArrow = c(xGlycolysis+0.75,xAA1-0.75), yArrow = c(ySER,ySER), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xLowerGlycolysis+3), ySpark = (ySER+sSL), fluxNames = c('cSERB'), fluxSigns = c( 1 ), maskFlag = TRUE)
# up SER
addFluxArwAndSpark(xArrow = c( xAA1-0.75), yArrow = c(ySER + dAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'BB', fluxNames = c('tSERUP1R','tSERUP2','tSERUP3R'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# SER to CYS
addFluxArwAndSpark(xArrow = c(xAA1, xAA1), yArrow = c(ySER + dAA ,ySER + 1*sAA - dAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1 - wSparkLines - sSL), ySpark = (ySER + dAA), fluxNames = c('cCYSK','cCYSM'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# up CYS
addFluxArwAndSpark(xArrow = c( xAA1-0.75), yArrow = c(ySER + 1*sAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'A', fluxNames = c('tCYSUP','tCYSUP2','tCYSUP3'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
# CYS to MET
addFluxArwAndSpark(xArrow = c(xAA1, xAA1), yArrow = c(ySER + 1*sAA+ dAA ,ySER + 2*sAA - dAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1 - wSparkLines - sSL), ySpark = (ySER + sAA + dAA), fluxNames = c('cMETH','cMETE'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# up MET
addFluxArwAndSpark(xArrow = c( xAA1-0.75), yArrow = c(ySER + 2*sAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'R', ySpark = 'A', fluxNames = c('tMETUP'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# SER to GLY
addFluxArwAndSpark(xArrow = c(xAA1, xAA1), yArrow = c(ySER - dAA ,ySER - 1*sAA + dAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1 - wSparkLines - sSL), ySpark = (ySER - hSparkLines - dAA), fluxNames = c('cGLYA3'), fluxSigns = c( 1 ), maskFlag = FALSE)
# up GLY
addFluxArwAndSpark(xArrow = c( xAA1-0.75), yArrow = c(ySER - 1*sAA ), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C', fluxNames = c('tYAAJR','tYEAV2R','tGLYUP1R'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
}
plotAminoAcidBranches()
plotMembraneBranches <- function(){
grid.text("mPG", x = unit(xMembrane, "native"), y = unit(yMembrane - sAA , "native"), gp = gpText )
grid.text("mCLPN", x = unit(xMembrane, "native"), y = unit(yMembrane - 2*sAA , "native"), gp = gpText )
grid.text("mPS", x = unit(xMembrane, "native"), y = unit(yMembrane + sAA , "native"), gp = gpText )
grid.text("mPE", x = unit(xMembrane, "native"), y = unit(yMembrane + 2*sAA , "native"), gp = gpText )
grid.text("mLPS", x = unit(xMembrane, "native"), y = unit(yMembrane + 3*sAA , "native"), gp = gpText )
grid.text("mPeptido", x = unit(xMembrane, "native"), y = unit(yMembrane + 4*sAA , "native"), gp = gpText )
# from ACCOA
# ........................................................................................................
t <- seq(from=pi*3/2, to=pi, by=-pi/20)
xACCOAtoLipoPre <- c(xLowerGlycolysis - 0.75,(cos(t) + xLowerGlycolysis -1.25 - 1), xLowerGlycolysis - 3.25)
yACCOAtoLipoPre <- c(yG6P - 14.87,(sin(t) + yG6P - 14.87 + 1), yMembrane - 0.25)
addFluxArwAndSpark(xArrow = xACCOAtoLipoPre, yArrow = yACCOAtoLipoPre, dirArrow = 'fwd', abrevArrow = FALSE, xSpark = 'L', ySpark = (yG6P - 13),
fluxNames = c('cFABB2','cFABF', 'cFABH2'), fluxSigns = c( 1,1,1 ), maskFlag = TRUE)
# last one is not really an isozyme, fix later
# ........................................................................................................
# #
# # ........................................................................................................
# addFluxArwAndSpark(xArrow = c((xLowerGlycolysis - 3.5),xMembrane + 0.25), yArrow = c(yMembrane+0.25, yMembrane+0.25), dirArrow = 'fwd', abrevArrow = FALSE,
# xSpark = NULL, ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# # ........................................................................................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c((xLowerGlycolysis - 3.5),xMembrane + 0.25), yArrow = c(yMembrane, yMembrane), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c('cCDSAR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# there is a back only rxn option here, add later
# ........................................................................................................
# pre to PS_EC
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xMembrane,xMembrane), yArrow = c(yMembrane + 0.25, yMembrane + 1*sAA - dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C', fluxNames = c('cPSSAR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xMembrane,xMembrane), yArrow = c(yMembrane - 0.25, yMembrane - 1*sAA + dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C', fluxNames = c('cPGPA','cPGPB'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xMembrane,xMembrane), yArrow = c(yMembrane - 1*sAA - dAA, yMembrane - 2*sAA + dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C', fluxNames = c('cCLSR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xMembrane,xMembrane), yArrow = c(yMembrane + 1*sAA + dAA, yMembrane + 2*sAA - dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C', fluxNames = c('cPSD'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# F6P to prePeptido
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis - 0.75,xGlycolysis - 1.75), yArrow = c(yG6P - 2, yG6P - 2), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c('cGLMU2'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# prePeptido to peptido
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xGlycolysis - 2, xMembrane + 1.5), yArrow = c(yG6P - 2, yG6P - 2), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'A', fluxNames = c('cUNKRXN7'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# to LPS_EC
# ........................................................................................................
t <- seq(from=0 , to=-pi/2, by= -pi/20)
t2 <- seq(from=0 , to=pi/2, by= pi/20)
x_toLPS1 <- c(xGlycolysis - 2, cos(t) + xGlycolysis - 2 - 1 ,xMembrane + 0.75)
y_toLPS1 <- c(yG6P - 2 - 0.25, sin(t) + yMembrane+ 3*sAA + 1 ,yMembrane + 3*sAA)
x_toLPS2 <- c(xLowerGlycolysis - 3.25, cos(t2) + xLowerGlycolysis - 3.25 - 1 ,xMembrane + 0.75)
y_toLPS2 <- c(yMembrane, sin(t2) + yMembrane + 3*sAA - 1 ,yMembrane + 3*sAA)
addFluxArwAndSpark(xArrow = list(x_toLPS1,x_toLPS2), yArrow = list(y_toLPS1,y_toLPS2), dirArrow = c('fwd','fwd'), abrevArrow = c(FALSE,FALSE),
xSpark = 'C', ySpark = (yMembrane + 3*sAA + vS), fluxNames = c('cRFAL'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
}
plotMembraneBranches()
plotNTBranches <- function(){
# grid.rect(x = unit(xNT + 0.5* dNT, "native"), y = unit( yNT - 6*sNT, "native") , height = unit(10*sNT, "native"), width = unit( 3*dNT, "native"), gp=gpar(lty="dashed", col = "grey50") ,just = c("left", "bottom"))
#
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xPP + 1.75,xNT- dNT-0.25), yArrow = c(yPP + 2, yNT+sNT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xPP + 3) , ySpark = 'B', fluxNames = c('cPRSAR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# GLY to
# ........................................................................................................
t <- seq( from = -pi/2, to = 0, by = pi/20)
addFluxArwAndSpark(xArrow = c((cos(t)*0.5 + xAA1+1.25-0.5),xAA1+1.25), yArrow = c((sin(t)*0.5+ 0.5+ySER - 1*sAA), yNT + sNT - 0.5), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xAA1 + 1 - wSparkLines) , ySpark = (yNT + - 3*hSparkLines ), fluxNames = c('cPURDR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# PPRP to AMP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT -dNT, xNT + dNT - 0.75 ), yArrow = c(yNT+sNT-0.25, yNT+sNT-0.25), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = (xNT + 0.5) , ySpark = ( yNT+sNT-0.5 - hSparkLines), fluxNames = c('cPURB2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("AMP", x = unit(xNT + dNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )
grid.text("ADP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )
grid.text("ATP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )
grid.text("dAMP", x = unit(xNT + dNT, "native"), y = unit(yNT , "native"), gp = gpText )
grid.text("dADP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT , "native"), gp = gpText )
grid.text("dATP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT , "native"), gp = gpText )
# dAMP to dADP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT, yNT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'A', fluxNames = c('cADK4R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dADP to dATP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT, yNT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'RC' , ySpark = 'A', fluxNames = c('cADK4R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# AMP to ADP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT+ sNT, yNT+ sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL, ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# ADP to ATP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT+ sNT, yNT+ sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL , ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# ATP to dATP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +3*dNT, xNT + 3*dNT), yArrow = c( yNT+sNT - dAA,yNT+ dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'C', fluxNames = c('cNRDD1'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# ADP to dADP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT, xNT + 2*dNT), yArrow = c( yNT+sNT - dAA,yNT+ dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL , ySpark = NULL, fluxNames = c('cNRDA1'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# PPRP to GMP and AMP
# ........................................................................................................
t <- seq( from = -pi/2, to = -pi/4, by = pi/20)
addFluxArwAndSpark(xArrow = list( c((cos(t) + xNT - dNT/2 ), xNT + dNT - 0.75 ), c(xNT -dNT, xNT + dNT - 0.75 )), yArrow = list( c((sin(t)+yNT+sNT+1+0.1), yNT + 2*sNT - 0.25) , c(yNT+sNT +0.1, yNT+sNT+0.1)), dirArrow = c('fwd','fwd'), abrevArrow = c(FALSE, FALSE),
xSpark = (xNT -dNT) , ySpark = (yNT +sNT+ 0.5), fluxNames = c('cGUAA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("GMP", x = unit(xNT + dNT, "native"), y = unit(yNT + 2*sNT, "native"), gp = gpText )
grid.text("GDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT + 2*sNT, "native"), gp = gpText )
grid.text("GTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT + 2*sNT, "native"), gp = gpText )
grid.text("dGMP", x = unit(xNT + dNT, "native"), y = unit(yNT + 3*sNT , "native"), gp = gpText )
grid.text("dGDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT + 3*sNT , "native"), gp = gpText )
grid.text("dGTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT + 3*sNT , "native"), gp = gpText )
# dGMP to dGDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT+3*sNT, yNT+3*sNT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cGMK2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dGDP to dGTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT + 2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT+3*sNT, yNT+3*sNT), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'RC' , ySpark = 'B', fluxNames = c('cGMK2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# GTP to dGTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +3*dNT, xNT + 3*dNT), yArrow = c(yNT+ 2*sNT + dAA, yNT+3*sNT - dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = NULL , ySpark = NULL, fluxNames = c('cNRDD2'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# GDP to dGDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT, xNT + 2*dNT), yArrow = c(yNT+ 2*sNT + dAA, yNT+3*sNT - dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'BB', fluxNames = c('cNRDA2'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# GMP to GDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT+ 2*sNT, yNT+ 2*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL , ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# GDP to GTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT+ 2*sNT, yNT+ 2*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = NULL , ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("dTMP", x = unit(xNT + dNT, "native"), y = unit(yNT - sNT , "native"), gp = gpText )
grid.text("dTDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT - sNT , "native"), gp = gpText )
grid.text("dTTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT - sNT , "native"), gp = gpText )
# dTMP to dTDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT-1*sNT, yNT-1*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'A', fluxNames = c('cTMKR'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dTDP to dTTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT-1*sNT, yNT-1*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C', ySpark = 'A', fluxNames = c('cNDK0R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("dUMP", x = unit(xNT + dNT, "native"), y = unit(yNT - 2*sNT , "native"), gp = gpText )
grid.text("dUDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT - 2*sNT , "native"), gp = gpText )
grid.text("dUTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT - 2*sNT , "native"), gp = gpText )
# dUMP to dTMP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +1*dNT , xNT + 1*dNT ), yArrow = c(yNT-2*sNT + dAA, yNT-1*sNT - dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'C', fluxNames = c('cTHYA'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dUMP to dUDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT-2*sNT, yNT-2*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cPYRH2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dUDP to dUTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT-2*sNT, yNT-2*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'A', fluxNames = c('cNDK6R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("UMP", x = unit(xNT + dNT, "native"), y = unit(yNT - 3*sNT , "native"), gp = gpText )
grid.text("UDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT - 3*sNT , "native"), gp = gpText )
grid.text("UTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT - 3*sNT , "native"), gp = gpText )
# UTP to dUTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +3*dNT , xNT + 3*dNT ), yArrow = c(yNT-3*sNT + dAA, yNT-2*sNT - dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'C', fluxNames = c('cNRDD4'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# UDP to dUDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT , xNT + 2*dNT ), yArrow = c(yNT-3*sNT + dAA, yNT-2*sNT - dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'BB', fluxNames = c('cNRDA4'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# UMP to UDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT-3*sNT, yNT-3*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cCMKB3R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# UDP to UTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT-3*sNT, yNT-3*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cNDK2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# UTP to CTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +3*dNT , xNT + 3*dNT ), yArrow = c(yNT-3*sNT - dAA, yNT-4*sNT + dAA), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'BB', fluxNames = c('cPYRG'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# to UMP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT -0.75, xNT +dNT - 0.75 ), yArrow = c(yNT-1.5*sNT, yNT-3*sNT+0.35), dirArrow = 'fwd', abrevArrow = TRUE,
xSpark = (xNT -0.75) , ySpark = 'A', fluxNames = c('cPYRF'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("CMP", x = unit(xNT + dNT, "native"), y = unit(yNT - 4*sNT , "native"), gp = gpText )
grid.text("CDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT - 4*sNT , "native"), gp = gpText )
grid.text("CTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT - 4*sNT , "native"), gp = gpText )
# CMP to CDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT-4*sNT, yNT-4*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cCMKA2R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# CDP to CTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT-4*sNT, yNT-4*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'RC' , ySpark = 'B', fluxNames = c('cNDK3R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
grid.text("dCMP", x = unit(xNT + dNT, "native"), y = unit(yNT - 5*sNT , "native"), gp = gpText )
grid.text("dCDP", x = unit(xNT + 2*dNT, "native"), y = unit(yNT - 5*sNT , "native"), gp = gpText )
grid.text("dCTP", x = unit(xNT + 3*dNT, "native"), y = unit(yNT - 5*sNT , "native"), gp = gpText )
# dCMP to dCDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +dNT + 0.75, xNT + 2*dNT - 0.75 ), yArrow = c(yNT-5*sNT, yNT-5*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cCMKA1R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# dCDP to dCTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT + 0.75, xNT + 3*dNT - 0.75 ), yArrow = c(yNT-5*sNT, yNT-5*sNT), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = 'C' , ySpark = 'B', fluxNames = c('cNDK7R'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# CTP to dCTP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +3*dNT , xNT + 3*dNT ), yArrow = c(yNT-4*sNT - dAA, yNT-5*sNT + dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'BB', fluxNames = c('cNRDD3'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# CDP to dCDP
# ........................................................................................................
addFluxArwAndSpark(xArrow = c(xNT +2*dNT , xNT + 2*dNT ), yArrow = c(yNT-4*sNT - dAA, yNT-5*sNT + dAA), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L' , ySpark = 'BB', fluxNames = c('cNRDA3','cNRDE'), fluxSigns = c( 1,1 ), maskFlag = FALSE)
# ........................................................................................................
}
plotNTBranches()
# yCellTop <- 28
# xCellRight <- 0
# rCell <- 2
# xCellLeft <- 30
# cShift <- 2
# tRT <- seq( from = pi/2, to =pi, by = pi/20)
# xRT <- cos(tRT)*rCell+(xCellRight+rCell)
# yRT <- sin(tRT)*rCell+ (yCellTop-rCell)
#
# tLT <- seq( from = 0, to =pi/2, by = pi/20)
# xLT <- cos(tLT)*rCell+(xCellLeft-rCell)
# yLT <- sin(tLT)*rCell+ (yCellTop-rCell)
#
# t1 <- seq( from = pi, to =5/4*pi, by = pi/20)
# x1 <- cos(t1)*rCell+(xCellRight+rCell)
# y1 <- sin(t1)*rCell+15
#
# t2 <- seq( from = pi/4, to =0, by = -pi/20)
# x2 <- cos(t2)*rCell+(xCellRight+rCell-rCell*sqrt(2)) + cShift
# y2 <- sin(t2)*rCell+15-(rCell*sqrt(2)) - cShift
#
# xCell <- c(xLT,xRT,x1, x2)
# yCell <- c(yLT,yRT, y1,y2)
#
# grid.lines( x= unit(xCell, "native"),y=unit(yCell, "native"), gp=gpar(lty="solid", col = "grey50") )
# xBioBox <- xMembrane
# wBioBox <- 3
# yBioBox <- 27.5
# hBioBox <- 2
#
# hViralBox <- 2*sT7+5.5
# yViralBox <- yT7-3.5
#
# xHostRight <- 30
# yHostBottom <- yViralBox + 0.5
# xHostLeft <- (xBioBox-wBioBox/2) - 1.25
# xHostTuck <- 4.8
# yHostTuck <- 7
# xViralBox <- xT7+1.5
# wViralBox <- (3.75*sT7)
#
#
#
# # - - - - - - - -
# grid.rect(x= unit(xBioBox, "native"),y=unit(yBioBox, "native"),width=unit(wBioBox, "native"),height=unit(hBioBox, "native"),
# gp=gpar(lty="dotted", col = "black"),just=c("center",'bottom'))
#
# xHost <- c( (xBioBox+wBioBox/2),xHostRight,xHostRight,NA, (xViralBox-wViralBox) , xHostTuck, xHostTuck,xHostLeft, xHostLeft, (xBioBox-wBioBox/2))
# yHost <- c( (yBioBox+1), (yBioBox+1), (yT7-2.5+ 2*sT7+4.5) ,NA,yHostBottom,yHostBottom,yHostTuck,yHostTuck,(yBioBox+1),(yBioBox+1))
# grid.lines( x= unit(xHost, "native"),y=unit(yHost, "native"), gp=gpar(lty="dotted", col = "black") )
xBioBox <- xMembrane
wBioBox <- 3
yBioBox <- 27.5
hBioBox <- 2
hViralBox <- 2*sT7+5.5
yViralBox <- yT7-3.5
xHostRight <- 30 -0.25
yHostBottom <- yViralBox + 0.5
xHostLeft <- (xBioBox-wBioBox/2) - 1.4
xHostTuck <- 4.8
yHostTuck <- 7
xViralBox <- xT7+1.25
wViralBox <- (3.75*sT7)
# - - - - - - - -
grid.rect(x= unit(xBioBox, "native"),y=unit(yBioBox, "native"),width=unit(wBioBox, "native"),height=unit(hBioBox, "native"),
gp=gpar(lty="dotted", col = "black"),just=c("center",'bottom'))
xHost <- c( (xBioBox+wBioBox/2),xHostRight,xHostRight,NA, (xViralBox-wViralBox) , xHostTuck, xHostTuck,xHostLeft, xHostLeft, (xBioBox-wBioBox/2))
yHost <- c( (yBioBox+1), (yBioBox+1), (yT7-2.5+ 2*sT7+4.5) ,NA,yHostBottom,yHostBottom,yHostTuck,yHostTuck,(yBioBox+1),(yBioBox+1))
grid.lines( x= unit(xHost, "native"),y=unit(yHost, "native"), gp=gpar(lty="dotted", col = "black") )
# - - - - - - - - - - - - - - - - - - - - - - - -
ySL <- 0.5
xL <- 22
xSL <- 5
wL <- 0.5
grid.lines( x= unit(c(xL,xL+wL), "native"),y=unit((yBioBox+1.5 + ySL), "native"), gp=gpar(lty="solid", col = colsSparks[1]) )
grid.lines( x= unit(c(xL,xL+wL), "native"),y=unit((yBioBox+1.5 + ySL*2), "native"), gp=gpar(lty="solid", col = colsSparks[2]) )
grid.lines( x= unit(c(xL,xL+wL)+xSL, "native"),y=unit((yBioBox+1.5 + ySL), "native"), gp=gpar(lty="solid", col = colsSparks[3]) )
grid.lines( x= unit(c(xL,xL+wL)+xSL, "native"),y=unit((yBioBox+1.5 + ySL*2), "native"), gp=gpar(lty="solid", col = colsSparks[4]) )
grid.text(mediaLegend[1], x= unit(c(xL+wL+0.25), "native"),y=unit((yBioBox+1.5 + ySL), "native") ,just = c("left", "center") )
grid.text(mediaLegend[2], x= unit(c(xL+wL+0.25), "native"),y=unit((yBioBox+1.5 + ySL*2), "native"),just = c("left", "center") )
grid.text(mediaLegend[3], x= unit(c(xL+wL+0.25)+xSL, "native"),y=unit((yBioBox+1.5 + ySL), "native"),just = c("left", "center") )
grid.text(mediaLegend[4], x= unit(c(xL+wL+0.25)+xSL, "native"),y=unit((yBioBox+1.5 + ySL*2), "native"),just = c("left", "center") )
# - - - - - - - - - - - - - - - - - - - - - - - -
# biomass
# ........................................................................................................
grid.text("Biomass", x = unit(xBioBox, "native"), y = unit(yBioBox+hBioBox-0.5, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = c(xBioBox+1,xBioBox+1), yArrow = c(yBioBox+hBioBox-1.75,yBioBox+hBioBox-1), dirArrow = 'fwd', abrevArrow = FALSE,
xSpark = 'L', ySpark = 'C',
fluxNames = c('bBIOMASS'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# - - - - - - - - viral rect
grid.rect(x= unit(xViralBox, "native"),y=unit(yViralBox, "native"),width=unit(wViralBox, "native"),height=unit(hViralBox, "native"),
gp=gpar(lty="dashed", col = "black"),just=c("right",'bottom'))
grid.text("VIRAL \nREACTIONS", x = unit(((xViralBox - wViralBox)+0.25), "native"), y = unit((yViralBox + 0.25), "native"), gp = gpText, just = c("left", "bottom") )
# phage 10A
# ........................................................................................................
t1 <- seq( from = pi/4, to =0, by = -pi/20)
t2 <- seq( from = pi, to =3*pi/2, by = pi/20)
t3 <- seq( from = -pi/4, to =0, by = pi/20)
t4 <- seq( from = pi, to =pi/2, by = -pi/20)
x_arwTo10A <- c((cos(t1) + (xAA2)) , (cos(t2) + (xAA2) + 2) , (xT7-2*sT7-0.75))
y_arwTo10A <- c((sin(t1) + (yTYR + 3*sAA) - 0.25),( sin(t2) + yT7+1 +0.5), yT7+0.5)
x_arwTo10A2 <- c((cos(t3) + (xAA2)) , (cos(t4) + (xAA2) + 2) , (xT7-2*sT7-0.75))
y_arwTo10A2 <- c((sin(t3) + (yGLT) - 1),( sin(t4) + yT7-1 +0.5), yT7+0.5)
grid.text("10A", x = unit(xT7-2*sT7, "native"), y = unit(yT7+0.5, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = list(x_arwTo10A,x_arwTo10A2), yArrow = list(y_arwTo10A,y_arwTo10A2), dirArrow = c('fwd', 'fwd'), abrevArrow = c(FALSE,FALSE),
xSpark = 'R', ySpark = (yT7+0.5+vS),
fluxNames = c('vR_PROTEIN_GP10A'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# phage PC
# ........................................................................................................
grid.text("PC", x = unit(xT7-0.75*sT7, "native"), y = unit(yT7+0.5, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = c(xT7-2*sT7+0.75,xT7-0.75*sT7-0.5), yArrow = c(yT7+0.5,yT7+0.5), dirArrow = 'rev', abrevArrow = FALSE, xSpark = 'C', ySpark = 'B',
fluxNames = c('vR_PROCAPSID'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# phage dNTPs
# ........................................................................................................
t <- seq( from = pi/4, to =0, by = -pi/20)
x_arwDATP <- c(cos(t) + (xT7) - 1, xT7)
y_arwDATP <- c(sin(t) + (yNT) - 0.75 , yT7+2*sT7+0.5)
x_arwDCTP <- c(cos(t) + (xT7) -1, xT7)
y_arwDCTP <- c(sin(t) + (yNT - 5*sNT) - 0.75, yT7+2*sT7+0.5)
x_arwDGTP <- c(cos(t) + (xT7) -1, xT7)
y_arwDGTP <- c(sin(t) + (yNT + 3*sNT) - 0.75, yT7+2*sT7+0.5)
x_arwDTTP <- c(cos(t) + (xT7) -1, xT7)
y_arwDTTP <- c(sin(t) + (yNT - sNT) - 0.75, yT7+2*sT7+0.5)
grid.text("t7dNTPs", x = unit(xT7, "native"), y = unit(yT7+2*sT7, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = list(x_arwDATP,x_arwDCTP,x_arwDGTP,x_arwDTTP), yArrow = list(y_arwDATP,y_arwDCTP,y_arwDGTP,y_arwDTTP),
dirArrow = c('fwd','fwd','fwd','fwd'), abrevArrow = c(FALSE, FALSE,FALSE, FALSE), xSpark = (xT7-0.25-wSparkLines), ySpark = (yT7+2*sT7+0.75),
fluxNames = c('vR_ECGENDEG'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# phage genome
# ........................................................................................................
grid.text("t7DNA", x = unit(xT7, "native"), y = unit(yT7+1*sT7, "native"), gp = gpText, just = c("center", "center") )
addFluxArwAndSpark(xArrow = c(xT7,xT7), yArrow = c(yT7+2*sT7-0.5,yT7+1*sT7+0.5), dirArrow = 'rev', abrevArrow = FALSE,
xSpark = (xT7-0.25-wSparkLines), ySpark = (yT7+1*sT7+0.75),
fluxNames = c('vR_GENOME'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# phage
# ........................................................................................................
grid.text("T7", x = unit(xT7, "native"), y = unit(yT7 - 2, "native"), gp = gpText, just = c("center", "center") )
t <- seq( from = pi/2, to =0, by = -pi/20)
x_arwFromPC <- c((xT7-0.75*sT7+0.5),cos(t) + (xT7) - 1, xT7)
y_arwFromPC <- c((yT7+0.5),sin(t) + (yT7 -0.5), yT7-1.5)
addFluxArwAndSpark(xArrow = list(c(xT7,xT7), x_arwFromPC), yArrow = list(c(yT7+1*sT7-0.5,yT7-1.5),y_arwFromPC), dirArrow = c('fwd','none'), abrevArrow = c(FALSE,FALSE), xSpark = (xT7-0.25-wSparkLines), ySpark = (yT7+0.75),
fluxNames = c('vR_PHAGE'), fluxSigns = c( 1 ), maskFlag = FALSE)
# addFluxArwAndSpark(xArrow = c(xT7-1*sT7+0.5,xT7-0.5), yArrow = c(yT7,yT7), dirArrow = 'rev', abrevArrow = FALSE, xSpark = NULL, ySpark = NULL,
# fluxNames = c('vR_PHAGE'), fluxSigns = c( 1 ), maskFlag = FALSE)
# ........................................................................................................
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# print('done plotting')
dev.off()
# print('device off')
}
plotTheMap()
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# repFluxes <- c('bBIOMASS','cRFAL','cPRSAR','vR_MRNA_GP10A','cHISD','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
repFluxes <- c('cRFAL','bBIOMASS','cPRSAR', 'cPGIR','cLYSA','cICDAR') #,'vR_PROTEIN_GP10A','vR_ECGENDEG','vR_MRNA_GP10A','vR_GENOME')
subLabels <- c('i','ii','iii','iv','v','vi','vii','viii','ix','x')
# open graphics device
# postscript(file = paste("testFluxPlotterREpresentativeFluxes",fileTagToPlot,sep=''),horizontal = FALSE, paper = "letter", family = "Courier")
# pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# pdf(file='figure4bHoriz.pdf', height=(hAll+0.5), width=(wAll+0.5), onefile=TRUE, family="Helvetica", pointsize = 7)
postscript(paste('figureOutput',"figure6b_18cm_width.eps", sep= .Platform$file.sep), width = 6.5, height = 1.25, horizontal = FALSE,
onefile = FALSE, paper = "special", pointsize = 8)
nRepFlux <- length(repFluxes)
layoutMat <- rbind(1:nRepFlux)
par(ps=8,oma = c(1,0.5,1,0.5))
layout( layoutMat )
xValuesSpark <- list()
yValuesSpark <- list()
for(iPlotFlux in 1:nRepFlux){
par( mar= (c(2, 2, 0, 0)+0.1), xpd = NA, cex=1)
for( iSim in 1:nSim){
# should the unit conversions occur in here? or be passed?
xValuesSpark[[iSim]] <- hostList[[iSim]][['t']]*60
yValuesSpark[[iSim]] <- hostList[[iSim]][[repFluxes[iPlotFlux]]]
yValuesSpark[[iSim]] <- yValuesSpark[[iSim]] - yValuesSpark[[iSim]][2]
maxVal <- max(abs(yValuesSpark[[iSim]]))
if( maxVal > 0 ){
yValuesSpark[[iSim]] <- yValuesSpark[[iSim]] / maxVal
}
}
yScaleSpark <- c(min(unlist(yValuesSpark)),max(unlist(yValuesSpark)))
yRangeSpark <- max(yScaleSpark) - min(yScaleSpark)
for( iSim in 1:nSim){
idxEnd <- which.min( abs( xValuesSpark[[iSim]] - 20 ) )
xValuesSparkThis <- xValuesSpark[[iSim]][1:idxEnd]
yValuesSparkThis <- yValuesSpark[[iSim]][1:idxEnd]
if( iSim == 1){
plot( x=xValuesSparkThis, y=yValuesSparkThis, col = colsSparks[iSim] , type='l', xlab = '', ylab = '', axes = FALSE,ylim = c(yScaleSpark[1],(yScaleSpark[2]+yRangeSpark*0.2 )))
}
else{
lines( x=xValuesSparkThis, y=yValuesSparkThis, col = colsSparks[iSim] )
}
}
atTicksOrig <- pretty( yScaleSpark )
if( atTicksOrig[1] < yScaleSpark[1] ){
atTicksOrig <- atTicksOrig[ 2:length(atTicksOrig) ]
}
if( atTicksOrig[length(atTicksOrig)] > yScaleSpark[2] ){
atTicksOrig <- atTicksOrig[ 1:(length(atTicksOrig)-1) ]
}
labels <- as.character( c(atTicksOrig[1],rep(NA, (length(atTicksOrig)-2)),atTicksOrig[length(atTicksOrig)]) )
axis(2,at = atTicksOrig, label = labels, cex=1)
axis(1,at = c(0,5,10,15,20),label = c('0', NA, NA,NA,'20'), cex=1)
title(paste(subLabels[iPlotFlux] ,sep=''), font.main = 1, cex = 1 )
}
dev.off()