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) )
fileTag = c('_s','_a','_g','_t')
fileTagToPlot = '_t'

# options( warn = 1 )
library(RColorBrewer)

# 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')
# colsClustersOrig <- c('goldenrod1', 'mediumorchid3','chocolate4','olivedrab3', 'cadetblue4', 
# 					'grey50', 'darkgreen', 'darkred',  'cyan4', 'seagreen', 
# 					'violetred4','midnightblue', 'dodgerblue3',  'darkorange2', 'firebrick1') # ,,  'darkorange2'
# colsClustersOrig <- brewer.pal(12,"Paired")
colsClustersOrig <- c( 'maroon4','darkolivegreen3', 'orange2','cornflowerblue','darkgreen','aquamarine3',  'royalblue4','lawngreen', 'firebrick4' , 'firebrick3',
						'maroon3','darkorchid','darkcyan','lightsteelblue','goldenrod1' ,'palegoldenrod','peachpuff','orangered1','salmon','chocolate4','chocolate','grey20')
colLowSpark <- 'black'
colHighSpark <- 'black'
colZeroFlux <- 'grey80'
colConstFlux <- 'grey50'
colNotFound <- 'black'
# plot type
# 1 is with varrying arrow weights, 2 is a map with equal arrow weights, 3 colors arrows by cluster
plotType = 3
sparkFlag <- TRUE
sparkScaleFlag <- TRUE
sparkColorFlag <- TRUE
# ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
# ^ 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 )
	# 
	nameOfCols <- colnames(hostTableTemp)
	notFluxes <- c( grep("^CONC", nameOfCols, value=TRUE), 't', 'biomass', 'hostFlag','status','growth','aBIOMASS')
	justFluxes <- nameOfCols[!nameOfCols %in% notFluxes ]
	hostTableTemp <- hostTableTemp[justFluxes]
	tableNames <- paste( colnames(hostTableTemp), fileTag[i], sep = '')
	colnames(hostTableTemp) <- tableNames
	if( i == 1 ){ 
		hostAll <- hostTableTemp 
		}
	else{
		hostAll <- cbind( hostAll, hostTableTemp ) 	
		}
}

# library load
library(grid)

# # open graphics device
# postscript(file = "testFluxPlotterPrototype",horizontal = FALSE, paper = "letter", family = "Courier")
# # pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# 
# # figure viewport
# pushViewport( viewport(width=unit(7.5,"inches"),height=unit(8,"inches"), name = 'figureViewport'))
# # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 
# # plotting viewport
# pushViewport( viewport(width=unit(7,"inches"),height=unit(7,"inches"), name = 'plotViewport',
# 	xscale = c(0,totalScaleUnits), yscale = c(0,totalScaleUnits), just = c("bottom"), y=unit(0.75,"inches")) )
# # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 


# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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.4
yMembrane <- yG6P - 2 - 4*sAA
sSL <- 0.25
hNT <- 2.3
sNT <- 2.1
yNT <- yPP - sNT + 2
xNT <- xAA2 + 0.5

yT7 <- 3.5
xT7 <- 29
sT7 <- 2

vS <- 0.35
hS <- 0.2

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 

# subfunctions
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

sparkLine <- function( xLocationSpark, yLocationSpark, wSpark, hSpark, xValuesSpark, yValuesSpark, idxKeySpark = 1 ,fluxColor = 'black') {
	# 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]-xRangeSpark*0.05, xValuesSpark[length(xValuesSpark)]+xRangeSpark*0.05)
	yRangeSpark <- max(yValuesSpark)-min(yValuesSpark)
	zeroThreshSparkRange <- 1e-12
	sparkON <- TRUE
	if ( abs(yRangeSpark) > zeroThreshSparkRange ){
		yScaleSpark <- c( min(yValuesSpark)-0.1*yRangeSpark, max(yValuesSpark)+0.1*yRangeSpark )
	}
	else {
		if( max(abs(yValuesSpark)) < zeroThreshSparkRange ) sparkON <- FALSE
		yScaleSpark <- c( (oSpark - 1/2), (oSpark + 1/2) )
		yRangeSpark <- 1
	}
	
	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( fontsize = 8 )))
		
		if( sparkScaleFlag ){
			
			allTick <- pretty( yValuesSpark )
			if( (allTick[ length(allTick) ]  - allTick[1]) < 1.5*yRangeSpark ){
				# grid.yaxis( at = c(allTick[1], allTick[ length(allTick) ] ), gp = gpar(col='grey65')) # at = c(-1, 1)
				yTick <- c(allTick[1], allTick[ length(allTick) ] )

			}
			else{
				yTick <- c(yScaleSpark[1], yScaleSpark[2] )
				# grid.yaxis( at = c(yScaleSpark[1], yScaleSpark[2] ), gp = gpar(col='grey65'))
				# grid.lines( x = unit( xScaleSpark[1], "native" ), y = unit( yScaleSpark, "native" ) , gp=gpar(col = "grey70"))
				# 				grid.text(as.character(yTick), x = unit( xScaleSpark[1], "native" ),y = unit( yTick, "native" ),  gp = gpar( fontsize = 6, col = 'grey40' ),just = c("right", "centre"))
				}
			
			logicalUnderThresh <- ( abs(yTick) < 1e-9 )
			yTick[ logicalUnderThresh ] <- 0
			
			grid.lines( x = unit( c(xScaleSpark[1], xScaleSpark[1]-xRangeSpark*0.075), "native" ), y = unit( c(yTick[1],yTick[1]), "native" ) , gp=gpar(col = "grey70"))
			grid.lines( x = unit( c(xScaleSpark[1], xScaleSpark[1]-xRangeSpark*0.075), "native" ), y = unit( c(yTick[2],yTick[2]), "native" ) , gp=gpar(col = "grey70"))
			grid.lines( x = unit( (xScaleSpark[1]), "native" ), y = unit( yScaleSpark, "native" ) , gp=gpar(col = "grey70"))
			 
			yTickStr <- as.character(yTick)
			for( iTick in 1:2){
				eMatch <- sum(grep('e', yTickStr[iTick]))
				# the really long case
				if( (nchar(yTickStr[iTick])  > 6 ) & !eMatch ){
					if( yTick[iTick] >= 0.001 ){
					yTickStr[iTick] <- formatC(yTick[iTick],digits = 2)
					}
					else{
						yTickStr[iTick] <- formatC(yTick[iTick],digits = 1)
					}
				}
				# test for and shorten long with 
				else{
					if( !eMatch ){
						if( yTick[iTick] > 10 ){
							yTickStr[iTick] <- formatC(yTick[iTick],digits = 3)
						}
						else{
							if( yTick[iTick] > 1 ){
								yTickStr[iTick] <- formatC(yTick[iTick],digits = 2)
							}
						}	
					}
				}
			}
			
			grid.text(yTickStr, x = unit( (xScaleSpark[1]-xRangeSpark*0.1), "native" ),y = unit( yScaleSpark, "native" ),  gp = gpar( fontsize = 6, col = 'grey50' ),
				just = c("right", "centre"), vjust = c(0.35, 0.65))
			
			
			# grid.text(as.character(yTick), x = unit( (xScaleSpark[1]-xRangeSpark*0.1), "native" ),y = unit( yTick, "native" ),  gp = gpar( fontsize = 6, col = 'white', fontface = "bold" ),
			# 				just = c("right", "centre"), vjust = c(0.1, 0.9))
			# grid.text(as.character(yTick), x = unit( (xScaleSpark[1]-xRangeSpark*0.1), "native" ),y = unit( yScaleSpark, "native" ),  gp = gpar( fontsize = 8, col = 'grey50' ),
						# just = c("right", "centre"), vjust = c(0.35, 0.65))
			
		}
		
		midCol <- 'gray50'
		ctrlCol <- 'gray50'
		
		if(sparkColorFlag){
			colLowSpark <- fluxColor
			colHighSpark <- fluxColor
			midCol <- fluxColor
		}

		# 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 = midCol))
		popViewport()

		# dotted line at initial value
		grid.lines( x = unit( xScaleSpark, "native" ), y = unit(c(oSpark, oSpark), "native" ), gp=gpar(col = ctrlCol,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 )
	
	# find max & min values for axes
	yValuesSparkMax <- max( unlist(yValuesSpark) )
	yValuesSparkMin <- min( unlist(yValuesSpark) )
	xValuesSparkMax <- max( unlist(xValuesSpark) )
	xValuesSparkMin <- min( unlist(xValuesSpark) )
	
	# 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
	zeroThreshSparkRange <- 1e-6
	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

		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 ){

			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)
			
			# try to cluster plotting just one
			# fluxNames <- paste( fluxNames, fileTag[k], sep='')
			
			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 <- colNotFound
				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 = colZeroFlux , 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))
			# 
			if(length(xArrow)>1){
				grid.lines(x = unit(xArrow,"native"), y = unit(yArrow,"native"), arrow = arwHead,  gp = gpar( lwd = arwLineWidth, col = arwColor, lty = arwLty ))
			}	
			else{
				grid.points(x = unit(xArrow,"native"), y = unit(yArrow,"native"), pch = '*', gp = gpar( cex = 1.5,lwd = arwLineWidth, col = arwColor ))
			}	
		}
		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){
	
	# 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 ))){
		arwColor <- ''
		
		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 == 'TF'){
				# Top(arrow) Top(spark)
				ySpark <- max(unlist(yArrow)) - hSparkLines
			}
			if( ySparkChar == 'TC'){
				# above
				ySpark <- max(unlist(yArrow)) - hSparkLines/2
			}
			if( ySparkChar == 'B' ){
				# below
				ySpark <- min(unlist(yArrow)) - vS - hSparkLines
			}
			if( ySparkChar == 'BC' ){
				# bottom(arrow) center(spark)
				ySpark <- min(unlist(yArrow)) - hSparkLines/2
			}
			if( ySparkChar == 'BB' ){
				# bottom(arrow) bottom(spark)
				ySpark <- min(unlist(yArrow))
			}
			if( ySparkChar == 'BN' ){
				# bottom(arrow) bottom(spark)
				ySpark <- min(unlist(yArrow)) - hSparkLines - vS/2
			}
			if( ySparkChar == 'AE'){
				# above extra
				ySpark <- max(unlist(yArrow)) + 1.5*vS
			}
			if( ySparkChar == 'BE' ){
				# below extra
				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(sparkColorFlag){
			
			arwColor <- colsClusters[1]
			
			nIso <- length(fluxNames)
			
			# try to cluster plotting just one
			# fluxNames <- paste( fluxNames, fileTag[k], sep='')
			
			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
			
		}
		
		if( nSim > 1 ){
			idxFileTagToPlot <- which( fileTag == fileTagToPlot )
			# print(valuesFlux[[1]][[idxFileTagToPlot]])
			sparkLine( xLocationSpark= xSpark, yLocationSpark= ySpark, wSpark = wSparkLines, hSpark = hSparkLines,
				 xValuesSpark = valuesFlux[[1]][idxFileTagToPlot], yValuesSpark = valuesFlux[[2]][idxFileTagToPlot], idxKeySpark = tIdx, fluxColor = arwColor )
			# # 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 , fluxColor = arwColor)
		}				
	}
	
}

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 <- hostAll

	# get fluxes that vary (to not break the distance metrics)
	zeroThresh <- 1e-12
	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.25)
	
	# get the clusters for this file only
	clusterFluxes <- names( clusterGroups )
	fluxNamesThisFileTag <- grep( paste( fileTagToPlot,'$', sep=''), clusterFluxes, value=TRUE)
	clustersThisFileTag <- clusterGroups[fluxNamesThisFileTag]
	namesStrippedFileTag <- sub( paste( fileTagToPlot,'$', sep=''),'' , names(clustersThisFileTag) )
	names(clustersThisFileTag) <- namesStrippedFileTag
	
	# get the fluxes only (previous version this occured above, now just redo for convince of not re-wiring other parts of code)
	allFluxes <- names( hostAll )
	fluxNamesThisFileTag <- grep( paste( fileTagToPlot,'$', sep=''), allFluxes, value=TRUE)
	justFluxes <- sub( paste( fileTagToPlot,'$', sep=''),'' , fluxNamesThisFileTag )
	
	clusterOutput <- list( clustersThisFileTag, justFluxes, clusterGroups )
	
	return( clusterOutput )
	
}

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


# Preparations for map plotting
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

if( plotType == 3 ){
	
	# note that this only takes the first flux and colors the map ( i think that this comment is old and irrelevent )
	clusterOutput <- clusterFluxes( hostAll ) # the input argument here is not actually used 
	# print('finished cluster')
	
	fluxClusters <- clusterOutput [[1]]
	fluxAllNames <- clusterOutput [[2]]
	allClust <- clusterOutput [[3]]
	
	colSmallClust <- 'grey30'
	nClust <- max(allClust)
	cClust <- rep(0,nClust)
	cRealClust <- 0
	colsClusters <- c( colZeroFlux, colConstFlux,  rep(0,(nClust-2)) )
	for(iClust in 1:nClust){
		logicalThisClust <- allClust == iClust
		cClust[iClust] <- sum(logicalThisClust)
		# print(iClust)
		# print( cClust[iClust] )
		if( cClust[iClust] < 10 ){
			colsClusters[iClust+2] <- colSmallClust
		}
		else{
			cRealClust <- cRealClust + 1
			colsClusters[iClust+2] <- colsClustersOrig[cRealClust]
			# cClustList[iClust] <- colsClustersOrig[cRealClust]
		}
	}
	
	# print(colsClusters)
	
	
	idxFileTagToPlot <- which( fileTag == fileTagToPlot )
	nonClusteredFluxNames <- fluxAllNames[!fluxAllNames %in% names( fluxClusters ) ]
	nonClusteredFluxesForZeroTest <- unlist(lapply( abs(hostList[[idxFileTagToPlot]][nonClusteredFluxNames]), max))
	zeroFluxNames <- names(nonClusteredFluxesForZeroTest[ nonClusteredFluxesForZeroTest < zeroThresh ])
	constantFluxNames <- names(nonClusteredFluxesForZeroTest[ abs(nonClusteredFluxesForZeroTest) >= zeroThresh ])
	zeroFluxClusters <- rep( 1, length(zeroFluxNames) )
	names( zeroFluxClusters ) <- zeroFluxNames
	constantFluxClusters <- rep( 2, length(constantFluxNames) )
	names( constantFluxClusters ) <- constantFluxNames
	fluxClusters <- c( (fluxClusters+2), constantFluxClusters, zeroFluxClusters )
	
	# colSmallClust <- 'black'
	# nClust <- max(fluxClusters)
	# cClust <- rep(0,nClust)
	# cRealClust <- 0
	# colsClusters <- c( colZeroFlux, colConstFlux,  rep(0,(nClust-2)) )
	# for(iClust in 3:nClust){
	# 	logicalThisClust <- fluxClusters == iClust
	# 	cClust[iClust] <- sum(logicalThisClust)
	# 	if( cClust[iClust] < 9 ){
	# 		colsClusters[iClust] <- colSmallClust
	# 	}
	# 	else{
	# 		cRealClust <- cRealClust + 1
	# 		colsClusters[iClust] <- colsClustersOrig[cRealClust]
	# 		# cClustList[iClust] <- colsClustersOrig[cRealClust]
	# 	}
	# }
	# print(cClust)
	# print(colsClusters)
}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


# Plot arrows
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

postscript(paste('figureOutput',"figure4a_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) ) )


	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("GLC(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 = (xGlycolysis + 2), ySpark = (yG6P + 3), 
									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 = 'C', 
									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 = ( xGlycolysis + sSL - wSparkLines), ySpark = (yG6P + 1), 
									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 = 'LF', ySpark = 'BC', 
									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 = (xLowerGlycolysis+1.25), ySpark = 'TF', 
									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+1.25), '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 - 2 - wSparkLines), ySpark = yG6P-16, 
									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.75,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 = (xTCA-rTCA/3-1.25-wSparkLines), ySpark = (yTCA-rTCA*5/6-2), 
									fluxNames = c('tDCTA1','tDCUB1','tDCUA1'), fluxSigns = c( 1,1,1 ), maskFlag = FALSE)
			# ........................................................................................................

			# Succ in (fum exch)
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xTCA-rTCA/3-4.75,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 = (xTCA-rTCA/3-0.5), ySpark = (yTCA-rTCA*5/6-3), 
									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 - 5, "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 = (xTCA+rTCA*3/2 - 0.5), ySpark = (yTCA+rTCA/2), 
									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 = (xTCA+rTCA*3/2-0.25), 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 = (xTCA+rTCA*3/2-1), 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 =  'BN', 
									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 = (xTCA-rTCA-wSparkLines*3/4), ySpark = (yTCA-rTCA-0.25*hSparkLines) , 
									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 = (xTCA-rTCA-1.25*wSparkLines), ySpark = (yTCA-rTCA+1*hSparkLines), 
									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 = (xLowerGlycolysis + 0.5), 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 = xTCA+rTCA/3, ySpark = yTCA - hSparkLines, 
									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.9), ySpark = 'TC', 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.6), 
									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 + 0.75 + 1), ySpark = 'A', 
									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 = (xPP - 1 - wSparkLines - 2*hS), ySpark = 'TC', 
									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 = 'LF', 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 = (xAA2+0.5), ySpark = (yASP +0.5), 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 = 'L', 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 = NULL, ySpark = NULL, 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 = 'C', ySpark = 'B', 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 = (yPYR - 0.5 - hSparkLines), 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 = 'C', ySpark = 'A', 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 = 'L', ySpark = 'TC', 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 = 'LF', ySpark = 'BB', 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* hNT, "native"), y = unit( yNT - 6*sNT, "native") , height = unit(10*sNT, "native"), width = unit( 3*hNT, "native"), gp=gpar(lty="dashed", col = "grey50") ,just = c("left", "bottom"))


			#
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xPP + 1.75,xNT- hNT-0.25), yArrow = c(yPP + 2, yNT+sNT),  dirArrow = 'fwd', abrevArrow = FALSE, 
									xSpark = (xPP + 3) , ySpark = 'A', 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 -hNT, xNT + hNT - 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 + hNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )
			grid.text("ADP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )
			grid.text("ATP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT + sNT , "native"), gp = gpText )

			grid.text("dAMP", x = unit(xNT + hNT, "native"), y = unit(yNT   , "native"), gp = gpText )
			grid.text("dADP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT   , "native"), gp = gpText )
			grid.text("dATP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT   , "native"), gp = gpText )

			# dAMP to dADP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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 +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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*hNT, xNT + 3*hNT), 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*hNT, xNT + 2*hNT), 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 + hNT/5 ), xNT + hNT - 0.75 ), c(xNT -hNT, xNT + hNT - 0.75 )), 
								yArrow = list( c((sin(t)+yNT+sNT+1+0.1), yNT + 1.5*sNT - 0.25) , c(yNT+sNT +0.1, yNT+sNT+0.1)),  
								dirArrow = c('fwd','fwd'), abrevArrow = c(FALSE, FALSE), 
									xSpark = (xNT -hNT) , ySpark = (yNT +sNT+ 0.5), fluxNames = c('cGUAA'), fluxSigns = c( 1 ), maskFlag = FALSE)
			# ........................................................................................................

			grid.text("GMP", x = unit(xNT + hNT, "native"), y = unit(yNT  + 1.5*sNT, "native"), gp = gpText )
			grid.text("GDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT  + 1.5*sNT, "native"), gp = gpText )
			grid.text("GTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT  + 1.5*sNT, "native"), gp = gpText )

			grid.text("dGMP", x = unit(xNT + hNT, "native"), y = unit(yNT + 2.5*sNT  , "native"), gp = gpText )
			grid.text("dGDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT + 2.5*sNT  , "native"), gp = gpText )
			grid.text("dGTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT + 2.5*sNT  , "native"), gp = gpText )

			# dGMP to dGDP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 0.75 ), yArrow = c(yNT+2.5*sNT, yNT+2.5*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*hNT + 0.75, xNT + 3*hNT - 0.75 ), yArrow = c(yNT+2.5*sNT, yNT+2.5*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*hNT, xNT + 3*hNT), yArrow = c(yNT+ 1.5*sNT + dAA, yNT+2.5*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*hNT, xNT + 2*hNT), yArrow = c(yNT+ 1.5*sNT + dAA, yNT+2.5*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 +hNT + 0.75, xNT + 2*hNT - 0.75 ), yArrow = c(yNT+ 1.5*sNT, yNT+ 1.5*sNT),  dirArrow = 'rev', abrevArrow = FALSE, 
									xSpark = NULL , ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
			# ........................................................................................................

			# GDP to GTP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +2*hNT + 0.75, xNT + 3*hNT - 0.75 ), yArrow = c(yNT+ 1.5*sNT, yNT+ 1.5*sNT),  dirArrow = 'rev', abrevArrow = FALSE, 
									xSpark = NULL , ySpark = NULL, fluxNames = c(''), fluxSigns = c( 1 ), maskFlag = FALSE)
			# ........................................................................................................

			grid.text("dTMP", x = unit(xNT + hNT, "native"), y = unit(yNT - sNT  , "native"), gp = gpText )
			grid.text("dTDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT - sNT  , "native"), gp = gpText )
			grid.text("dTTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT - sNT  , "native"), gp = gpText )

			# dTMP to dTDP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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 + hNT, "native"), y = unit(yNT - 2*sNT  , "native"), gp = gpText )
			grid.text("dUDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT - 2*sNT   , "native"), gp = gpText )
			grid.text("dUTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT - 2*sNT   , "native"), gp = gpText )

			# dUMP to dTMP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +1*hNT , xNT + 1*hNT ), yArrow = c(yNT-2*sNT + dAA, yNT-1*sNT - dAA),  dirArrow = 'rev', abrevArrow = FALSE, 
									xSpark = (xNT + 1*hNT + 1.5) , ySpark = 'C', fluxNames = c('cTHYA'), fluxSigns = c( 1 ), maskFlag = FALSE)
			# ........................................................................................................

			# dUMP to dUDP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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 + hNT, "native"), y = unit(yNT - 3*sNT  , "native"), gp = gpText )
			grid.text("UDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT - 3*sNT   , "native"), gp = gpText )
			grid.text("UTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT - 3*sNT   , "native"), gp = gpText )

			# UTP to dUTP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +3*hNT , xNT + 3*hNT ), 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*hNT , xNT + 2*hNT ), 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 +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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*hNT , xNT + 3*hNT ), 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 , xNT +hNT - 0.75 ), yArrow = c(yNT-1*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 + hNT, "native"), y = unit(yNT - 4*sNT  , "native"), gp = gpText )
			grid.text("CDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT - 4*sNT   , "native"), gp = gpText )
			grid.text("CTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT - 4*sNT   , "native"), gp = gpText )

			# CMP to CDP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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 + hNT, "native"), y = unit(yNT - 5*sNT  , "native"), gp = gpText )
			grid.text("dCDP", x = unit(xNT + 2*hNT, "native"), y = unit(yNT - 5*sNT   , "native"), gp = gpText )
			grid.text("dCTP", x = unit(xNT + 3*hNT, "native"), y = unit(yNT - 5*sNT   , "native"), gp = gpText )

			# dCMP to dCDP
			# ........................................................................................................
			addFluxArwAndSpark(xArrow = c(xNT +hNT + 0.75, xNT + 2*hNT - 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*hNT + 0.75, xNT + 3*hNT - 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*hNT , xNT + 3*hNT ), 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*hNT , xNT + 2*hNT ), 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.5
		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 -0.25
		yHostBottom <- yViralBox + 0.5
		xHostLeft <- (xBioBox-wBioBox/2) - 1.45
		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")  )



		# 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 + 2.5*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)
		# ........................................................................................................




		# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

		# 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('cHISD','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','cPRSAR','vR_MRNA_GP10A','vR_GENOME','cRFAL','bBIOMASS')
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',"figure4b_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.25,1,0.25))
layout( layoutMat )

for(iPlotFlux in 1:nRepFlux){
	par( mar= (c(2, 2, 0, 0)+0.1), xpd = NA, cex=1)
	
	idxFileTagToPlot <- which( fileTag == fileTagToPlot )
	# should the unit conversions occur in here? or be passed?
	xValuesSpark <- hostList[[idxFileTagToPlot]][['t']]*60
	yValuesSpark <- hostList[[idxFileTagToPlot]][[repFluxes[iPlotFlux]]]
		
	idxEnd <- which.min( abs( xValuesSpark - 20 ) )
	xValuesSpark <- xValuesSpark[1:idxEnd]
	yValuesSpark <- yValuesSpark[1:idxEnd]
	yRangeSpark <- max(yValuesSpark) - min(yValuesSpark)
		
	plot( x=xValuesSpark,  y=yValuesSpark, col = colsClusters[ fluxClusters[ repFluxes[iPlotFlux] ] ], type='l', xlab = '', ylab = '', axes = FALSE,ylim = c(min(yValuesSpark),(max(yValuesSpark)+yRangeSpark*0.2 )) )
	
	yScaleSpark <- c(min(yValuesSpark),max(yValuesSpark))
	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()

# 
# hAll <- 0.75
# wAll <- 6.9
# # repFluxes <- c('bBIOMASS','cACNAR','cALABR','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# repFluxes <- c('bBIOMASS','cRFAL','cPRSAR','vR_MRNA_GP10A','cHISD','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# 
# # 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("figure4b_18cm_width.eps", width = (wAll+0.1), height = (hAll+0.5), horizontal = FALSE, onefile = FALSE, paper = "special", pointsize = 7)
# 
# 
# # # figure viewport
# # pushViewport( viewport(width=unit(7.5,"inches"),height=unit(8,"inches"), name = 'figureViewport'))
# # # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 
# # plotting viewport
# pushViewport( viewport(width=unit((wAll),"inches"),height=unit((hAll),"inches"), name = 'plotViewport'))
# # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# # 
# # hAll <- 7
# # wAll <- unit(1,"inches")
# # repFluxes <- c('bBIOMASS','cACNAR','cALABR','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# xSpacer <- 0.17
# 
# nRepFlux <- length(repFluxes)
# wEachPlot <- ((wAll-xSpacer*nRepFlux)/nRepFlux)
# for(iPlotFlux in 1:nRepFlux){
# 	
# 	xPlot <- (wEachPlot)*(iPlotFlux-1) + (xSpacer)*(iPlotFlux)
# 	yPlot <- 0.1 # hEachPlot*(nRepFlux-iPlotFlux)+0.25
# 	
# 	idxFileTagToPlot <- which( fileTag == fileTagToPlot )
# 	# should the unit conversions occur in here? or be passed?
# 	xValuesSpark <- hostList[[idxFileTagToPlot]][['t']]*60
# 	yValuesSpark <- hostList[[idxFileTagToPlot]][[repFluxes[iPlotFlux]]]
# 		
# 	idxEnd <- which.min( abs( xValuesSpark - 20 ) )
# 	xValuesSpark <- xValuesSpark[1:idxEnd]
# 	yValuesSpark <- yValuesSpark[1:idxEnd]
# 		
# 	# this is the "inital" value where the dotted line will be placed, with values above in green and below in red
# 	oSpark <- yValuesSpark[2]
# 	
# 	# 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)
# 	# xScaleSpark <- c(xValuesSpark[1], 20*1.05)
# 	yRangeSpark <- max(yValuesSpark)-min(yValuesSpark)
# 	zeroThreshRange <- 1e-12
# 	sparkON <- TRUE
# 	if ( abs(yRangeSpark) > zeroThreshRange ){
# 		yScaleSpark <- c( min(yValuesSpark)-0.1*yRangeSpark, max(yValuesSpark)+0.1*yRangeSpark )
# 	}
# 	else {
# 		yScaleSpark <- c( (oSpark - 1/2), (oSpark + 1/2) )
# 		yRangeSpark <- 1
# 	}
# 	
# 	pushViewport( viewport(width=unit((wEachPlot),"inches"), height=unit(hAll,"inches"), name = 'plotFluxViewport',
# 		xscale = xScaleSpark, yscale = yScaleSpark, just = c( 'left',"bottom"), y=unit(yPlot,"inches"),x=unit(xPlot,"inches") ) )
# 	# grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 		
# 	grid.lines( x=unit(xValuesSpark,'native'),  y=unit(yValuesSpark,'native'), gp = gpar(col = colsClusters[ fluxClusters[ repFluxes[iPlotFlux] ] ]))
# 	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) ]
# 	}
# 	# atTicksVals <- atTicksOrig
# 	# atTicksOrig <- as.character( atTicksOrig )
# 	# atTicksOrig[2:(length(atTicksOrig)-1)] <- ' '
# 	grid.text( as.character( c(atTicksOrig[1],atTicksOrig[length(atTicksOrig)]) ), x = unit( c(-5,-5) ,'native') , 
# 				y = unit(c(atTicksOrig[1],atTicksOrig[length(atTicksOrig)]),'native'), rot = 90)
# 	grid.yaxis(at = atTicksOrig, label = FALSE)
# 				
# 	# grid.text(repFluxes[iPlotFlux], x = unit(xScaleSpark[2],'native'), y = unit(yScaleSpark[2],'native') , just = c('right','centre'), rot = 90,gp = gpar( cex = 0.7 ) )
# 	# if(iPlotFlux == nRepFlux) 
# 	grid.xaxis(at = c(0,5,10,15,20),label = c('0', ' ', '10',' ','20'))
# 	popViewport()
# 	grid.text(repFluxes[iPlotFlux], x = unit((xPlot+wEachPlot/2),"inches"), y = unit((hAll+yPlot+0.1),'inches') , just = c('centre','centre') )
# 	
# 	
# 	
# }



# 
# 
# # Plot Ref Sparks
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# 
# hAll <- 7
# wAll <- 1
# # repFluxes <- c('bBIOMASS','cACNAR','cALABR','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# repFluxes <- c('bBIOMASS','cRFAL','cHISD','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# 
# # open graphics device
# # postscript(file = paste("testFluxPlotterREpresentativeFluxes",fileTagToPlot,sep=''),horizontal = FALSE, paper = "letter", family = "Courier")
# # pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# pdf(file='figure4b.pdf', height=(hAll+1), width=(wAll+1), onefile=TRUE, family='Courier')
# 
# # # figure viewport
# # pushViewport( viewport(width=unit(7.5,"inches"),height=unit(8,"inches"), name = 'figureViewport'))
# # # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 
# # plotting viewport
# pushViewport( viewport(width=unit((wAll+0.5),"inches"),height=unit((hAll+0.5),"inches"), name = 'plotViewport'))
# # grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# # 
# # hAll <- 7
# # wAll <- unit(1,"inches")
# # repFluxes <- c('bBIOMASS','cACNAR','cALABR','vR_PROTEIN_GP10A','cNDK7R','vR_ECGENDEG','vR_GENOME')
# 
# nRepFlux <- length(repFluxes)
# hEachPlot <- (hAll/nRepFlux)
# for(iPlotFlux in 1:nRepFlux){
# 	
# 	yPlot <- hEachPlot*(nRepFlux-iPlotFlux)+0.25
# 	
# 	idxFileTagToPlot <- which( fileTag == fileTagToPlot )
# 	# should the unit conversions occur in here? or be passed?
# 	xValuesSpark <- hostList[[idxFileTagToPlot]][['t']]*60
# 	yValuesSpark <- hostList[[idxFileTagToPlot]][[repFluxes[iPlotFlux]]]
# 		
# 	# this is the "inital" value where the dotted line will be placed, with values above in green and below in red
# 	oSpark <- yValuesSpark[2]
# 	
# 	# 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)
# 	zeroThreshRange <- 1e-12
# 	sparkON <- TRUE
# 	if ( abs(yRangeSpark) > zeroThreshRange ){
# 		yScaleSpark <- c( min(yValuesSpark)-0.1*yRangeSpark, max(yValuesSpark)+0.1*yRangeSpark )
# 	}
# 	else {
# 		yScaleSpark <- c( (oSpark - 1/2), (oSpark + 1/2) )
# 		yRangeSpark <- 1
# 	}
# 	
# 	pushViewport( viewport(width=unit(wAll,"inches"), height=unit(hEachPlot,"inches"), name = 'plotFluxViewport',
# 		xscale = xScaleSpark, yscale = yScaleSpark, just = c( 'right',"bottom"), y=unit(yPlot,"inches"),x=unit(wAll+0.5,"inches") ) )
# 	# grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 		
# 	grid.lines( x=unit(xValuesSpark,'native'),  y=unit(yValuesSpark,'native'), gp = gpar(col = colsClusters[ fluxClusters[ repFluxes[iPlotFlux] ] ]))
# 	grid.yaxis(gp = gpar( cex = 0.7 ))
# 	grid.text(repFluxes[iPlotFlux], x = unit(xScaleSpark[2],'native'), y = unit(yScaleSpark[2],'native') , just = c('right','centre'), rot = 90,gp = gpar( cex = 0.7 ) )
# 	if(iPlotFlux == nRepFlux) grid.xaxis(gp = gpar( cex = 0.7 ))
# 	popViewport()
# }
# 
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -



# 
# # Plot Heatmap
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# 
# clusterOutput <- clusterFluxes( hostAll ) # input isn't actually used? look at this later
# 
# fluxClusters <- clusterOutput[[3]]
# # make color index cluster vector( or use the one genrated above for consistancy although that is only evaluated for plot type three currently)
# # ........................................................................................................
# # color index translation initialization
# colIdxTrans <- rep( 0, max(fluxClusters) )
# # check if the number of flux clusters exceeded the number of defined colors
# print(max( fluxClusters ))
# colsClusters <- colsClustersOrig
# if( length(colsClustersOrig) < max(fluxClusters) ){
# 	nRepCols <- ceiling( max(fluxClusters)/length(colsClustersOrig) ) 
# 	colsClusters <- rep(colsClustersOrig, nRepCols)
# } 
# 
# print(length( colsClusters ))
# # ........................................................................................................
# 
# # sort out and asign clusters to non-varying fluxes and zero fluxes
# # ........................................................................................................
# idxFileTagToPlot <- which( fileTag == fileTagToPlot )
# fluxAllNames <- names(hostAll)
# nonClusteredFluxNames <- fluxAllNames[!fluxAllNames %in% names( fluxClusters ) ]
# nonClusteredFluxesForZeroTest <- unlist(lapply( abs(hostAll[nonClusteredFluxNames]), max))
# zeroFluxNames <- names(nonClusteredFluxesForZeroTest[ nonClusteredFluxesForZeroTest < zeroThresh ])
# constantFluxNames <- names(nonClusteredFluxesForZeroTest[ abs(nonClusteredFluxesForZeroTest) >= zeroThresh ])
# # print(constantFluxNames)
# namesNonZeroFluxes <- c( constantFluxNames, names( fluxClusters ) )
# zeroFluxClusters <- rep( 1, length(zeroFluxNames) )
# names( zeroFluxClusters ) <- zeroFluxNames
# constantFluxClusters <- rep( 2, length(constantFluxNames) )
# names( constantFluxClusters ) <- constantFluxNames
# fluxClusters <- c( (fluxClusters+2), constantFluxClusters, zeroFluxClusters )
# # print( fluxClusters )
# colZeroFlux <- 'white'
# colsClusters <- c( colZeroFlux, colConstFlux,  colsClusters )
# print( colsClusters )
# # ........................................................................................................
# 
# 
# # find all non zero in any condition fluxes to plot
# # ........................................................................................................
# 
# namesNonZeroFluxesStripTag <- sub( '_[[:alnum:]]$','' , namesNonZeroFluxes )
# # print( namesNonZeroFluxesStripTag )
# fluxListToPlot <- unique( namesNonZeroFluxesStripTag )
# print(length(fluxListToPlot))
# classFile = '20120307_1001a_Ecoli_EB_T7_37Growth_EB__basicGlucoseAerobic_10s_VM2MDAHB_PL_RM.txt'			
# # sort into order for plotting & strip out the exchange fluxes
# classTable <- read.table(classFile, sep='\t', header = TRUE)
# classTable <- as.matrix(classTable)
# classTable <- rbind( classTable, colnames(classTable))
# rownames(classTable) <- c('metClass','metSubClass','fluxName')
# print(dim(classTable))
# logicalExchange <- classTable['metClass',fluxListToPlot] == 'Exchange(Model)'
# fluxesWithoutExchange <- fluxListToPlot[!logicalExchange]
# labelsToPlotNoExchange <- classTable[,fluxesWithoutExchange]
# print(dim(labelsToPlotNoExchange))
# reordering <- order(labelsToPlotNoExchange['metClass',],labelsToPlotNoExchange['metSubClass',],labelsToPlotNoExchange['fluxName',])
# labelsToPlotSorted <- labelsToPlotNoExchange[,reordering]
# # ........................................................................................................
# 
# print('vR_GENOME_t')
# print(fluxClusters['vR_GENOME_t'])
#   # print(hostAll['vR_GENOME_t'])
# 
# # construct heatmap array
# # ........................................................................................................
# 
# nFluxToPlot <- dim(labelsToPlotSorted)[2]
# heatMap <- matrix(0,nSim,nFluxToPlot)
# print(length(hostAll[[1]]))
# nPts <- length(hostAll[[1]])
# heatMapAlt <- matrix(0,nSim*nPts,nFluxToPlot)
# for( iFlux in 1:nFluxToPlot ){
# 	for( iSim in 1:nSim){
# 		thisFluxName <- paste( labelsToPlotSorted['fluxName',iFlux], fileTag[iSim], sep = '')
# 		heatMap[iSim,iFlux] <- fluxClusters[ thisFluxName ]
# 		# print('dim assign')
# 		# print( hostAll[[ thisFluxName ]])
# 		# print('spots')
# 		# print( ((iSim-1)*nPts+1):(iSim*nPts) )
# 		# print( iFlux)
# 		valsAdjusted <- (hostAll[[ thisFluxName ]] - hostAll[[ thisFluxName ]][2])
# 		maxValue <- max( abs( valsAdjusted ))
# 		if( maxValue > 1e-10){
# 			heatMapAlt[ ((iSim-1)*nPts+1):(iSim*nPts),iFlux] <- valsAdjusted/maxValue
# 		}
# 		else{
# 			heatMapAlt[ ((iSim-1)*nPts+1):(iSim*nPts),iFlux] <- valsAdjusted
# 		}
# 		
# 	}
# }
# 
# nScale <- 11
# # colScaleAlt <- grey(1:nScale/nScale)
# colScaleAlt <- brewer.pal(nScale,"RdBu")
# b <- 1-(1-nScale)*min(heatMapAlt)/(min(heatMapAlt)-max(heatMapAlt))
# m <- (1-nScale)/(min(heatMapAlt)-max(heatMapAlt))
# heatMapAlt <- round(  heatMapAlt*m+b )
# 
# # ........................................................................................................
# # 
# fluxesToPlotSorted <- labelsToPlotSorted
# condLabels <- fileTag
# colScale <- colsClusters
# 
# # function to construct the heatmap
# library(grid)
# # assume for now that the only inputs are the heatmap matrix and the labels/met
# nCol <-3
# wTotal <- 5
# hTotal <- 7
# hOffset <- 0.1
# vOffset <- 0.1
# wRect <- 0.25
# labelSpace <- 0.2
# 	
# nCond <- dim(heatMap)[1]
# nFluxTotal <- dim(fluxesToPlotSorted)[2]
# wCol <- wTotal/nCol
# 
# 
# # split the heatmap into 
# listClass <- unique(fluxesToPlotSorted['metClass',])
# nClass <- length(listClass)
# nFluxSplitEven <- round(nFluxTotal/nCol)
# heatMapSplit <- list()
# heatMapAltSplit <- list()
# labelsSplit <- list()
# nFluxInCol <- matrix(0,1,nCol)
# idxStart <- 1
# for( iSplit in 1:nCol){
# 	if( iSplit == nCol ){
# 		idxEnd <- nFluxTotal
# 	}
# 	else{
# 		idxEnd <- match(fluxesToPlotSorted['metClass',nFluxSplitEven*iSplit],fluxesToPlotSorted['metClass',])-1
# 	}
# 	heatMapSplit[iSplit] <- list( heatMap[,idxStart:idxEnd] )
# 	heatMapAltSplit[iSplit] <- list( heatMapAlt[,idxStart:idxEnd] )
# 	labelsSplit[iSplit] <- list( fluxesToPlotSorted[,idxStart:idxEnd] )
# 	nFluxInCol[iSplit] <- idxEnd - idxStart + 1
# 	# prep for next
# 	idxStart <- idxEnd+1
# }
# 
# hRect <- (hTotal - 3*vOffset)/max(nFluxInCol)
# 

# 
# 
# # open graphics device
# # postscript(file = "heatmapFigure",horizontal = FALSE, paper = "letter", family = "Courier")
# # pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# pdf(file='heatmapClust.pdf', height=(hTotal+0.5), width=(wTotal+0.5), onefile=TRUE, family='Courier')
# 
# # figure viewport
# pushViewport( viewport(width=unit(wTotal,"inches"),height=unit(hTotal,"inches"), name = 'figureViewport'))
# grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 
# # loop through plotting the columns
# for( iCol  in 1:nCol){
# 	
# 	vectRectBottoms <- (hTotal-vOffset*2) - (1:nFluxInCol[iCol])*hRect
# 	# vectRectHeights <- matrix(hRect,1,nFluxInCol[iCol])
# 	# loop through conditions, plotting colored rectangles
# 	
# 	for( iCond in 1:nCond){
# 		rectRight <- wCol*iCol-hOffset-wRect*(iCond-1)
# 		rectLeft <- rectRight - wRect
# 		values <- heatMapSplit[[iCol]][iCond,]
# 		# idxCScale <- round(  values*m+b )
# 		grid.rect(x=unit(rectLeft,'inches'),y=unit(vectRectBottoms,'inches'),width=unit(wRect,'inches'),height=unit(hRect,'inches'),
# 					gp = gpar(fill=colScale[ heatMapSplit[[iCol]][iCond,] ], lwd = 0.5 ),just=c('left','bottom'))		
# 		grid.text(condLabels[iCond],x=unit(rectLeft+wRect/2,'inches'), y=unit((hTotal-vOffset*1.5) ,'inches'),just=c('center','bottom') )
# 	}
# 	
# 	grid.text( labelsSplit[[iCol]]['fluxName',] , x = unit((rectLeft - 0.01),'inches') , y = unit(vectRectBottoms,'inches'), gp = gpar(cex = 0.2 ), just=c('right','bottom'))
# 	
# 	# loop through the labels
# 	class <- unique(labelsSplit[[iCol]]['metClass',])
# 	print(class)
# 	nClass <- length(class)
# 	for( iClass in 1:nClass){
# 		xClassLine <- rectLeft - labelSpace*2
# 		
# 		if( iClass == 1 ){
# 			yTop <- (hTotal-vOffset*2)
# 			yBottom <- (hTotal-vOffset*2) - hRect*(match( class[iClass+1], labelsSplit[[iCol]]['metClass',] ) - 1)
# 		}
# 		else{
# 			if(iClass == nClass){
# 				yTop <- (hTotal-vOffset*2) - hRect*(match( class[iClass], labelsSplit[[iCol]]['metClass',] )-1)
# 				yBottom <- (hTotal-vOffset*2) - hRect*(nFluxInCol[iCol]) 
# 			}
# 			else{
# 				yTop <- (hTotal-vOffset*2) - hRect*(match( class[iClass], labelsSplit[[iCol]]['metClass',] )-1)
# 				yBottom <- (hTotal-vOffset*2) - hRect*(match( class[iClass+1], labelsSplit[[iCol]]['metClass',] ) - 1)
# 			}
# 		}
# 		
# 		xPoints <- c(xClassLine,xClassLine)
# 		arwHead <- arrow(angle = 45, length = unit(0.05, "inches"), ends = "both", type = "open")
# 		# print('plotting call')
# 		# print( (yTop - yBottom)/hRect )
# 		if( (yTop - yBottom)/hRect < 1.5 ){
# 			xPoints <- c(xClassLine-0.05,xClassLine+0.05)
# 			yTop <- yTop - hRect/2
# 			yBottom <- yTop
# 			arwHead <- NULL
# 		}
# 		grid.lines(x = unit(xPoints,"inches"), y = unit(c(yTop,yBottom),"inches"), arrow = arwHead, 
# 					gp = gpar( lwd = 1, col = 'grey10', lty = 1 ) )
# 		grid.text( gsub(' ' , '\n',class[iClass]), x = unit(xClassLine-labelSpace/4,"inches") , y = unit((yTop+yBottom)/2,"inches"),
# 		 			gp = gpar( cex = 0.5, lineheight = 1), rot = 90 , just = c('center','bottom') )
# 		
# 		# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# 			
# 			yTopClass <- yTop
# 			
# 			# loop through the labels
# 			vectSubClass <- labelsSplit[[iCol]]['metSubClass', ( labelsSplit[[iCol]]['metClass',] == class[iClass] ) ]
# 			nInThisClass <- length( which( labelsSplit[[iCol]]['metClass',] == class[iClass] ) )
# 			subClass <- unique( vectSubClass  ) # need to get this so only this class
# 			nSubClass <- length(subClass)
# 			
# 			# if more than 1
# 			if( nSubClass > 1){
# 				
# 				for( iSubClass in 1:nSubClass){
# 					xSubClassLine <- rectLeft - labelSpace/2
# 
# 					if( iSubClass == 1 ){
# 						yTop <- yTopClass
# 						yBottom <- yTopClass - hRect*(match( subClass[iSubClass+1], vectSubClass ) - 1)
# 					}
# 					else{
# 						if(iSubClass == nSubClass){
# 							yTop <- yTopClass - hRect*(match( subClass[iSubClass], vectSubClass )-1)
# 							yBottom <- yTopClass - hRect*(nInThisClass) 
# 						}
# 						else{
# 							yTop <- yTopClass - hRect*(match( subClass[iSubClass], vectSubClass )-1)
# 							yBottom <- yTopClass - hRect*(match( subClass[iSubClass+1], vectSubClass ) - 1)
# 						}
# 					}
# 
# 					xPoints <- c(xSubClassLine,xSubClassLine)
# 					arwHead <- arrow(angle = 45, length = unit(0.05, "inches"), ends = "both", type = "open")
# 					# print('plotting call')
# 					# print( (yTop - yBottom)/hRect )
# 					if( (yTop - yBottom)/hRect < 2 ){
# 						xPoints <- c(xSubClassLine-0.05,xSubClassLine+0.05)
# 						yTop <- yTop - hRect/2
# 						yBottom <- yTop
# 						arwHead <- NULL
# 					}
# 					grid.lines(x = unit(xPoints,"inches"), y = unit(c(yTop,yBottom),"inches"), arrow = arwHead, 
# 								gp = gpar( lwd = 1, col = 'grey10', lty = 1 ) )
# 					grid.text( gsub(' ' , '\n', subClass[iSubClass]), x = unit(xSubClassLine-labelSpace/4,"inches") , y = unit((yTop+yBottom)/2,"inches"), gp = gpar( cex = 0.3), rot = 90, just = c('center','bottom') )
# 				
# 				}
# 			} # if nSubClass
# 			
# 			
# 		# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# 
# 	}
# }
# 
# 
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# 
# print('alt heatmap plotting')
# 
# # open graphics device
# # postscript(file = "heatmapFigureAlt",horizontal = FALSE, paper = "letter", family = "Courier")
# # pdf(file = "testFluxPlotterPrototypePdfOut2", paper = "letter", family = "Courier")
# pdf(file='heatmapFluxHeat.pdf', height=(hTotal+0.5), width=(wTotal+0.5), onefile=TRUE, family='Courier')
# 
# 
# # figure viewport
# pushViewport( viewport(width=unit(wTotal,"inches"),height=unit(hTotal,"inches"), name = 'figureViewport'))
# grid.rect(gp=gpar(lty="solid", col = "gray80")) # temp for layout
# 
# wSmallRect <- wRect/nPts
# 
# # loop through plotting the columns
# for( iCol  in 1:nCol){
# 	
# 	vectRectBottoms <- (hTotal-vOffset*2) - (1:nFluxInCol[iCol])*hRect
# 	vectRectBottomsMatrix <- matrix(vectRectBottoms, nrow = nFluxInCol[iCol], ncol = nPts)
# 	# vectRectHeights <- matrix(hRect,1,nFluxInCol[iCol])
# 	# loop through conditions, plotting colored rectangles
# 	
# 	for( iCond in 1:nCond){
# 		rectRight <- wCol*iCol-hOffset-wRect*(iCond-1)
# 		rectLeft <- rectRight - wRect
# 		rectSmallLefts <- rectLeft + (0:(nPts-1))*wSmallRect
# 		rectSmallLeftsMatrix <- matrix(rectSmallLefts, nrow = nFluxInCol[iCol], ncol = nPts, byrow = TRUE)
# 		values <- heatMapSplit[[iCol]][iCond,]
# 		# idxCScale <- round(  values*m+b )
# 		# print(dim(heatMapSplit[[iCol]]))
# 		# print( ((iCond-1)*nPts+1):(iCond*nPts) )
# 		# print( colScaleAlt[ t(heatMapAltSplit[[iCol]][((iCond-1)*nPts+1):(iCond*nPts), ])] )
# 		grid.rect(x=unit(rectSmallLeftsMatrix,'inches'),y=unit(vectRectBottomsMatrix,'inches'),width=unit(wSmallRect,'inches'),height=unit(hRect,'inches'),
# 					gp = gpar(fill=colScaleAlt[ t(heatMapAltSplit[[iCol]][((iCond-1)*nPts+1):(iCond*nPts), ])] , col = NA),just=c('left','bottom'))		
# 		grid.text(condLabels[iCond],x=unit(rectLeft+wRect/2,'inches'), y=unit((hTotal-vOffset*1.5) ,'inches'),just=c('center','bottom') )
# 		grid.lines(x=unit(c(rectLeft,rectLeft),'inches'), y = unit(c(((hTotal-vOffset*2) - (nFluxInCol[iCol])*hRect),(hTotal-vOffset*2)),'inches') )
# 	
# 	}
# 	
# 	grid.text( labelsSplit[[iCol]]['fluxName',] , x = unit((rectLeft - 0.01),'inches') , y = unit(vectRectBottoms,'inches'), gp = gpar(cex = 0.2 ), just=c('right','bottom'))
# 	
# 	# loop through the labels
# 	class <- unique(labelsSplit[[iCol]]['metClass',])
# 	# print(class)
# 	nClass <- length(class)
# 	for( iClass in 1:nClass){
# 		xClassLine <- rectLeft - labelSpace*2
# 		
# 		if( iClass == 1 ){
# 			yTop <- (hTotal-vOffset*2)
# 			yBottom <- (hTotal-vOffset*2) - hRect*(match( class[iClass+1], labelsSplit[[iCol]]['metClass',] ) - 1)
# 		}
# 		else{
# 			if(iClass == nClass){
# 				yTop <- (hTotal-vOffset*2) - hRect*(match( class[iClass], labelsSplit[[iCol]]['metClass',] )-1)
# 				yBottom <- (hTotal-vOffset*2) - hRect*(nFluxInCol[iCol]) 
# 			}
# 			else{
# 				yTop <- (hTotal-vOffset*2) - hRect*(match( class[iClass], labelsSplit[[iCol]]['metClass',] )-1)
# 				yBottom <- (hTotal-vOffset*2) - hRect*(match( class[iClass+1], labelsSplit[[iCol]]['metClass',] ) - 1)
# 			}
# 		}
# 		
# 		xPoints <- c(xClassLine,xClassLine)
# 		arwHead <- arrow(angle = 45, length = unit(0.05, "inches"), ends = "both", type = "open")
# 		# print('plotting call')
# 		# print( (yTop - yBottom)/hRect )
# 		if( (yTop - yBottom)/hRect < 1.5 ){
# 			xPoints <- c(xClassLine-0.05,xClassLine+0.05)
# 			yTop <- yTop - hRect/2
# 			yBottom <- yTop
# 			arwHead <- NULL
# 		}
# 		grid.lines(x = unit(xPoints,"inches"), y = unit(c(yTop,yBottom),"inches"), arrow = arwHead, 
# 					gp = gpar( lwd = 1, col = 'grey10', lty = 1 ) )
# 		grid.text( gsub(' ' , '\n',class[iClass]), x = unit(xClassLine-labelSpace/4,"inches") , y = unit((yTop+yBottom)/2,"inches"),
# 		 			gp = gpar( cex = 0.5, lineheight = 1), rot = 90 , just = c('center','bottom') )
# 		
# 		# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# 			
# 			yTopClass <- yTop
# 			
# 			# loop through the labels
# 			vectSubClass <- labelsSplit[[iCol]]['metSubClass', ( labelsSplit[[iCol]]['metClass',] == class[iClass] ) ]
# 			nInThisClass <- length( which( labelsSplit[[iCol]]['metClass',] == class[iClass] ) )
# 			subClass <- unique( vectSubClass  ) # need to get this so only this class
# 			nSubClass <- length(subClass)
# 			
# 			# if more than 1
# 			if( nSubClass > 1){
# 				
# 				for( iSubClass in 1:nSubClass){
# 					xSubClassLine <- rectLeft - labelSpace/2
# 
# 					if( iSubClass == 1 ){
# 						yTop <- yTopClass
# 						yBottom <- yTopClass - hRect*(match( subClass[iSubClass+1], vectSubClass ) - 1)
# 					}
# 					else{
# 						if(iSubClass == nSubClass){
# 							yTop <- yTopClass - hRect*(match( subClass[iSubClass], vectSubClass )-1)
# 							yBottom <- yTopClass - hRect*(nInThisClass) 
# 						}
# 						else{
# 							yTop <- yTopClass - hRect*(match( subClass[iSubClass], vectSubClass )-1)
# 							yBottom <- yTopClass - hRect*(match( subClass[iSubClass+1], vectSubClass ) - 1)
# 						}
# 					}
# 
# 					xPoints <- c(xSubClassLine,xSubClassLine)
# 					arwHead <- arrow(angle = 45, length = unit(0.05, "inches"), ends = "both", type = "open")
# 					print('plotting call')
# 					print( (yTop - yBottom)/hRect )
# 					if( (yTop - yBottom)/hRect < 2 ){
# 						xPoints <- c(xSubClassLine-0.05,xSubClassLine+0.05)
# 						yTop <- yTop - hRect/2
# 						yBottom <- yTop
# 						arwHead <- NULL
# 					}
# 					grid.lines(x = unit(xPoints,"inches"), y = unit(c(yTop,yBottom),"inches"), arrow = arwHead, 
# 								gp = gpar( lwd = 1, col = 'grey10', lty = 1 ) )
# 					grid.text( gsub(' ' , '\n', subClass[iSubClass]), x = unit(xSubClassLine-labelSpace/4,"inches") , y = unit((yTop+yBottom)/2,"inches"), gp = gpar( cex = 0.3), rot = 90, just = c('center','bottom') )
# 				
# 				}
# 			} # if nSubClass
# 			
# 			
# 		# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
# 
# 	}
# }