##
## Timing the spinal cord development with neural progenitor cells losing their proliferative capacity: a theoretical analysis.
## Manon Azais, Eric Agius, Stephane Blanco, Angie Molina, Fabienne Pituello, Jean-Marc Tregan, Anaïs Vallet and Jacques Gautrais1*
## Neural Development 2019
##

## All data and codes are contained in this file.
## The code was executed using Terminal under MacOSX 10.11.6, R version 3.5.2 (2018-12-20) -- "Eggshell Igloo", with:
## [Code]$ R CMD BATCH --vanilla DataAndCode.R
## and produces all figures.
##


rm(list=ls())

#### where to put figures
RepOut="./"

whatToDo = c("fig1","fig25","clones")

## ####################### data Saade ######################### 

Saade = list(
    MOD = data.frame(
        time = c(60,70,75,80,90),
        pp = c(82 ,37  ,7  ,0  ,0),
        pn = c(18 ,56 ,53 ,56 ,42),
        nn = c(0  ,7 ,40 ,44 ,58),
        IcPP = c(4,9,6,0,0)*1.96,
        IcPN = c(4,6,7,3,6)*1.96,
        IcNN = c(0,4,5,3,6)*1.96),

    PNWT = data.frame(
        time = c(50,60,72,84,96,108,120,132),
        P = c(12,27,75.4,70.8,39.8,20.5,11.7,9.4),
        N = c(0.0,0.0,31,87.7,156.2,190.6,212.3,215.2),
        PIC = c(3.5,6.4,11.1,8.8,10.5,7.0,4.1,3.5)*1.96,
        NIC = c(0.0,0.0,8.8,12.9,19.8,21.6,12.3,18.7)*1.96)
);

  
  
## Pituello Data (Ventral zone)
Pituello24h = 60;
Pituello48h = Pituello24h+24;
PituelloMoD = (Pituello24h+Pituello48h)/2;
Pituello = list(
    
    MODWT = data.frame(
        time = rep(PituelloMoD,3),
        MoD  = c(29.3,58,12.7),
        IC = c(1.3,2,1.1)*1.96),

    PNWT = data.frame(
        time = c(Pituello24h,Pituello48h),
        P = c(83.5,38.4),
        N = c(16.5,61.6),
        PIC = c(1.1,1.5)*1.96,
        NIC = c(1.1,1.5)*1.96),

    MODGOF = data.frame(
        time = rep(PituelloMoD,3),
        MoD  = c(6.9,52.3,40.7),
        IC = c(2.5,2.8,2.7)*1.96),

    PNGOF = data.frame(
        time = c(Pituello24h,Pituello48h),
        P = c(83.6,23.5),
        N = c(16.4,76.5),
        PIC = c(1.1,0.9)*1.96,
        NIC = c(1.1,0.9)*1.96),
  
     MODCDK = data.frame(
        time = rep(PituelloMoD,3),
        MoD  = c(16.6,70.7,12.7),
        IC = c(1.2,1.4,1.1)*1.96),
   
     PNCDK = data.frame(
        time = c(Pituello24h,Pituello48h),
        P = c(92,34.1),
        N = c(8,65.9),
        PIC = c(1.1,2.5)*1.96,
        NIC = c(1.1,2.5)*1.96)
);


## ################## accessory functions

## open graphics windows
## should be adapted for execution under RStudio / Linux
openGraphics = function(inwidth, inheight) { quartz(w=inwidth,h=inheight); }


plotCI = function (x, y, uiw,col=par("col"), pch=1,cex=1,type='b',cex.lab=1,wdth=1, lwd=par("lwd"),add=TRUE)
{
    ui = y + uiw;
    li = y - uiw;
    li = pmax(li,0);
    ## gap =1 ; smidge = par("fin")[1] * 0.01
    ## arrows(x , li, x, pmax(y-gap,li), col=col, lwd=lwd, angle=90, length=smidge, code=1)
    ## arrows(x , ui, x, pmin(y+gap,ui), col=col, lwd=lwd, angle=90, length=smidge, code=1)
    if (length(col)==1) col = rep(col,length(x))
    points(x, y, col = col, cex=cex, pch=pch)
    for (p in 1:length(x))
        {
            lines(c(x[p],x[p]),c(li[p],ui[p]),col=col[p],lwd=lwd)
            lines(c(x[p]-wdth,x[p]+wdth),c(li[p],li[p]),col=col[p],lwd=lwd)
            lines(c(x[p]-wdth,x[p]+wdth),c(ui[p],ui[p]),col=col[p],lwd=lwd)
        }
    invisible(list(x = x, y = y))
}

################################################################################
#############################  ############################# 
################################################################################




### PN model, Figures 1-5
maxpp = 1;maxnn = 0.8;
alphapp = function(t,tau) { return( (1 - tanh( (t-tau)/sigmapp) )*(maxpp/2)) }  
alphann = function(t,tau) { return( (1 + tanh( (t-tau)/sigmann) )*(maxnn/2) ) }
alphapn = function(t,taupp,taunn) { return(1-alphann(t,taunn)-alphapp(t,taupp)) }

## MoDs  WT
## fit tanh parameters from Saade data
alphapptst = function(t,te,sigma) { return( 0.5 - tanh( (t-te)/sigma)*(maxpp/2)) }
squareErrorPP = function(parms) {  return(sum(  (Saade$MOD$pp/100 -  alphapptst(Saade$MOD$time,parms[1],parms[2]) )**2     )) }
paramspp = optim(par=c(67,7), squareErrorPP, method="L-BFGS-B", lower=0)
WTTauPP = paramspp$par[1] ; sigmapp = paramspp$par[2] ;
cat("Params PP : ",WTTauPP," ",sigmapp,"\n");

alphanntst = function(t,te,sigma) { return( (1+tanh( (t-te)/sigma ) )*(maxnn/2) ) }  
squareErrorNN = function(parms) { return(sum(  (Saade$MOD$nn/100 -  alphanntst(Saade$MOD$time,parms[1],parms[2]) )**2     )) }
paramsnn = optim(par=c(77,17), squareErrorNN, method="L-BFGS-B", lower=0)
WTTauNN = paramsnn$par[1] ; sigmann = paramsnn$par[2] ;
cat("Params NN : ",WTTauNN," ",sigmann,"\n");

squareErrorPP = sum((Saade$MOD$pp/100 -  alphapp(Saade$MOD$time,WTTauPP) )**2);
cat("sq error PP = ",squareErrorPP,"\n"); 
squareErrorNN = sum((Saade$MOD$nn/100 -  alphann(Saade$MOD$time,WTTauNN) )**2);
cat("sq error NN = ",squareErrorNN,"\n"); 
squareErrorPN = sum((Saade$MOD$pn/100 -  alphapn(Saade$MOD$time,WTTauPP,WTTauNN) )**2);
cat("sq error PN = ",squareErrorPN,"\n");
cat("======\n");



## time parameters 
dt = 0.01;
startAtOne = 44;
eta=1/12;
cat("Tc=",1/eta,", start = ",startAtOne,", maxnn=",maxnn,"\n");

## Parameters
GOFTauPP = WTTauPP -8 
GOFTauNN = WTTauNN -8
CDKTauPP = WTTauPP -2 
CDKTauNN = WTTauNN +4
LOFTauPP = WTTauPP +2.5 ;
LOFTauNN = WTTauNN +7 ;

## compute time series  
PNTimeSeries = function(tauPP,tauNN)
    {
        temps = seq(startAtOne,140,dt);
        nit = length(temps)

        ## Variables 
        gamma = rep(0,nit);
        P = rep(0,nit) ; N = rep(0,nit) ;
        P[1] = 1 ; N[1] = 0 ; gamma[1]=alphapp(temps[1],tauPP) - alphann(temps[1],tauNN)
        for(t in 2:nit)
            {
                gamma[t] = alphapp(temps[t-1],tauPP) - alphann(temps[t-1],tauNN);                
                P[t] = P[t-1] + eta*dt*P[t-1]* gamma[t];
                N[t] = N[t-1] + eta*dt*P[t-1]* (1.0-gamma[t]);
            }
        keeptmps = seq(1,length(temps),100)
        return (list(P=P[keeptmps],N=N[keeptmps],Gamma=gamma[keeptmps], Time=temps[keeptmps],
                     PP=alphapp(temps,tauPP)[keeptmps],
                     NN=alphann(temps,tauNN)[keeptmps]))
    }

P.Analityque = function(t,start,taupp,taunn)
{
    t0 = taupp - start ; t1 = taunn - start ; ts = t - start        
    p1 =   (cosh( (ts-t0)/sigmapp ) / cosh(-t0/sigmapp))^(sigmapp/2)  * (cosh( (ts-t1)/sigmann ) / cosh(-t1/sigmann) )^((maxnn/2)*sigmann)
    p2 =  (((1/2) - (maxnn/2) ) * ts)  - log(p1)    
    return(exp(eta * p2))
}
gamma.analytique = function(t,taupp,taunn)
    {
        return( alphapp(t,taupp) - alphann(t,taunn) )
    }


if("fig1" %in% whatToDo)
{
    WTdata = PNTimeSeries(WTTauPP,WTTauNN);
    GOFdata = PNTimeSeries(GOFTauPP,GOFTauNN);
    CDKdata = PNTimeSeries(CDKTauPP,CDKTauNN);

    cat("WT\n");
    cat("Max progens: ",max(WTdata$P),"\n");
    cat(" at time: ",WTdata$Time[which(abs(WTdata$P-max(WTdata$P))<0.0000001)][1],"\n");
    cat("GoF\n");
    cat("Max progens: ",max(GOFdata$P),"\n");
    cat(" at time: ",GOFdata$Time[which(abs(GOFdata$P-max(GOFdata$P))<0.0000001)][1],"\n");
    
    ## #### Figure 1 #####
    openGraphics(inwidth=8,inheight=10);
    par(las=1, family="Helvetica", mar=c(5,5,4,1), mfrow=c(3,2), tcl=0.4);

    ##  MOD fits
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,1),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp/100,uiw=Saade$MOD$IcPP/100,type='b',pch=15,col='black',wdth=2)
    plotCI(Saade$MOD$time,Saade$MOD$pn/100,uiw=Saade$MOD$IcPN/100,type='b',pch=15,col='blue',wdth=2)
    plotCI(Saade$MOD$time,Saade$MOD$nn/100,uiw=Saade$MOD$IcNN/100,type='b',pch=15,col='red',wdth=2)
    plotCI(Pituello$MODWT$time,Pituello$MODWT$MoD/100,uiw=Pituello$MODWT$IC/100,col=c('black','blue','red'),pch=16,add=TRUE,cex=2,wdth=2)

    curve(alphapp(x,WTTauPP),40,140, ylim=c(0,1), col="black",add=TRUE,lwd=2);
    curve(alphann(x,WTTauNN),40,140,add=TRUE,col='red',lwd=2);
    curve(alphapn(x,WTTauPP,WTTauNN),40,140,add=TRUE,col='blue',lwd=2)
    legend(x=100,y=0.6,legend=c(expression(alpha[pp](t)),expression(alpha[pn](t)),expression(alpha[nn](t))),col=c("black","blue","red"),lwd=c(2,2,2),cex=1)

    text(30,1.2,"a - CTL",cex=2,xpd=NA, adj=0)

    ## Progenitors / neurons with Saade data
    plot(WTdata$Time,WTdata$P,type='l',ylim = c(0,250/12),xlim=c(40,140),xlab="",ylab="Number of cells",cex.lab=1.3,col='black',lwd=3)
    lines(WTdata$Time,WTdata$N,col='red',lwd=3)
    plotCI(Saade$PN$time,Saade$PN$P/12,uiw=Saade$PN$PIC/12,pch=15,col="black",add=TRUE);
    plotCI(Saade$PN$time,Saade$PN$N/12,uiw=Saade$PN$NIC/12,pch=15,col="red",add=TRUE);
    curve(P.Analityque(x,startAtOne,WTTauPP,WTTauNN),40,140,add=TRUE,col="green")

    legend(x=40,y=20,legend=c(expression(P(t)),expression(N(t))),col=c("black","red"),lwd=c(2,2),cex=1)

    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(WTdata$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = WTdata$P+WTdata$N;
    plotCI(Pituello$PNWT$time,Pituello$PNWT$P*total[indices]/100,uiw=Pituello$PNWT$PIC,col='black',pch=16,add=TRUE,cex=2)
    plotCI(Pituello$PNWT$time,Pituello$PNWT$N*total[indices]/100,uiw=Pituello$PNWT$NIC,col='red',pch=16,add=TRUE,cex=2)
        
    text(29,300/12,"b",cex=2,xpd=NA)


    ## MoD GOF
    curve(alphapp(x,WTTauPP),40,140, ylim=c(0,1), col="black",xlab="",ylab="Mode of Division",cex.lab=1.2,lwd=1);
    curve(alphann(x,WTTauNN),50,140,add=TRUE,col='red',lwd=1);
    curve(alphapn(x,WTTauPP,WTTauNN),40,140,add=TRUE,col='blue',lwd=1)

    curve(alphapp(x,GOFTauPP),40,140, col="black",add=TRUE,lwd=3);
    curve(alphann(x,GOFTauNN),40,140, col='red',  add=TRUE,lwd=3);
    curve(alphapn(x,GOFTauPP,GOFTauNN),40,140,col='blue',add=TRUE,lwd=3)

    plotCI(Pituello$MODGOF$time,Pituello$MODGOF$MoD/100,uiw=Pituello$MODGOF$IC/100,pch=16,cex=2,col=c("black","blue","red"),add=TRUE)
    text(30,1.2,"c - GoF",cex=2,xpd=NA, adj=0)

    ## P/N
    plot(WTdata$Time,WTdata$P,type='l',ylim = c(0,250/12),xlim=c(40,140),xlab="",ylab="Number of cells",cex.lab=1.3,col='black',lwd=1)
    lines(WTdata$Time,WTdata$N,col='red',lwd=1)
    lines(GOFdata$Time,GOFdata$P,col='black',lwd=3)
    lines(GOFdata$Time,GOFdata$N,col='red',lwd=3)
    curve(P.Analityque(x,startAtOne,GOFTauPP,GOFTauNN),40,140,add=TRUE,col="green")

    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(GOFdata$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = GOFdata$P+GOFdata$N;
    plotCI(Pituello$PNGOF$time,Pituello$PNGOF$P*total[indices]/100,uiw=Pituello$PNGOF$PIC,col='black',pch=16,cex=2,add=TRUE)
    plotCI(Pituello$PNGOF$time,Pituello$PNGOF$N*total[indices]/100,uiw=Pituello$PNGOF$NIC,col='red',pch=16,cex=2,add=TRUE)
        
    text(29,300/12,"d",cex=2,xpd=NA)


    ## MoD deltaCKD
    curve(alphapp(x,WTTauPP),40,140, ylim=c(0,1), col="black",xlab="Time (hpf)",ylab="Mode of Division",cex.lab=1.2,lwd=1);
    curve(alphann(x,WTTauNN),50,140,add=TRUE,col='red',lwd=1);
    curve(alphapn(x,WTTauPP,WTTauNN),40,140,add=TRUE,col='blue',lwd=1)

    curve(alphapp(x,CDKTauPP),40,140, col="black",add=TRUE,lwd=3);
    curve(alphann(x,CDKTauNN),40,140, col='red',  add=TRUE,lwd=3);
    curve(alphapn(x,CDKTauPP,CDKTauNN),40,140,col='blue',add=TRUE,lwd=3)

    plotCI(Pituello$MODCDK$time,Pituello$MODCDK$MoD/100,uiw=Pituello$MODCDK$IC/100,pch=16,cex=2,col=c("black","blue","red"),add=TRUE)
    text(30,1.2,expression("e - GoF-"*Delta*"CDK"),cex=2,xpd=NA, adj=0)

    ## P/N
    plot(WTdata$Time,WTdata$P,type='l',ylim = c(0,250/12),xlim=c(40,140),xlab="Time(hpf)",ylab="Number of cells",cex.lab=1.3,col='black',lwd=1)
    lines(WTdata$Time,WTdata$N,col='red',lwd=1)
    lines(CDKdata$Time,CDKdata$P,col='black',lwd=3)
    lines(CDKdata$Time,CDKdata$N,col='red',lwd=3)
    curve(P.Analityque(x,startAtOne,CDKTauPP,CDKTauNN),40,140,add=TRUE,col="green")

    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(CDKdata$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = CDKdata$P+CDKdata$N;
    plotCI(Pituello$PNCDK$time,Pituello$PNCDK$P*total[indices]/100,uiw=Pituello$PNCDK$PIC,col='black',pch=16,cex=2,add=TRUE)
    plotCI(Pituello$PNCDK$time,Pituello$PNCDK$N*total[indices]/100,uiw=Pituello$PNCDK$NIC,col='red',pch=16,cex=2,add=TRUE)

    text(29,300/12,"f",cex=2,xpd=NA)
    dev.copy2pdf(file=paste(RepOut,"Figure1.pdf",sep=""))  
}

##########
## FIGS 2 to 5

graphicScenario = function(WT,GOF,CDK,WTPN,GOFPN,CDKPN,name, showNdetails=FALSE)
    {
        openGraphics(inwidth=8,inheight=10);
        par(las=1, family="Helvetica", mar=c(5,5,4,1), mfrow=c(3,2), tcl=0.4);

        keeptps = seq(1,length(WT$Time),100); # to make graphics lighter

        ## WT MoD          
        plot(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")        
        lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=3, col='blue');
        legend(x=100,y=0.6,legend=c(expression(gamma[G](t)),expression(gamma[A](t))),col=c("green","blue"),lwd=c(2,2),cex=1)
        text(-15+startAtOne,1.2,"a - CTL",cex=2,xpd=NA, adj=0)
        ## WT Pops 
        plot(WT$Time[keeptps]+startAtOne,WT$G2[keeptps],type='l',xlab="",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
        lines(WT$Time[keeptps]+startAtOne,WT$A2[keeptps],col='blue',type='l',lwd=3)
        lines(WT$Time[keeptps]+startAtOne,WT$N[keeptps],col='red',type='l',lwd=3)    
        lines(WT$Time[keeptps]+startAtOne,WT$G2[keeptps]+WT$A2[keeptps],lwd=3, col="black")
        legend(x=40,y=20,legend=c(expression(G(t)),expression(A(t)),expression(N(t)),expression(P(t))),col=c("green","blue","red","black"),lwd=c(2,2,2,2),cex=1)

        if (showNdetails)
            {
                lines(WT$Time[keeptps]+startAtOne,WT$Nfrom1[keeptps],col=colNfrom1,type='l',lwd=2, lty=2)    
                lines(WT$Time[keeptps]+startAtOne,WT$Nfrom2[keeptps],col=colNfrom2,type='l',lwd=2, lty=2)    
            }

        plotCI(Saade$PN$time,Saade$PN$P/12,uiw=Saade$PN$PIC/12,pch=15,cex=0.8,col="black",add=TRUE);
        plotCI(Saade$PN$time,Saade$PN$N/12,uiw=Saade$PN$NIC/12,pch=15,cex=0.8,col="red",add=TRUE);
        indices = rep(NA,2);
        for (ind in 1:2) indices[ind] = which(abs(WTPN$Time-Pituello$PNWT$time[ind])<dt)[1];
        total = WTPN$P+WTPN$N;
        plotCI(Pituello$PNWT$time,Pituello$PNWT$P*total[indices]/100,uiw=Pituello$PNWT$PIC,col='black',pch=16,add=TRUE,cex=2)
        plotCI(Pituello$PNWT$time,Pituello$PNWT$N*total[indices]/100,uiw=Pituello$PNWT$NIC,col='red',pch=16,add=TRUE,cex=2)
        text(-15+startAtOne,25,"b",cex=2,xpd=NA)

        

        ## GOF MoD          
        plot(GOF$Time[keeptps]+startAtOne,1-GOF$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")
        lines(GOF$Time[keeptps]+startAtOne,1-GOF$aan[keeptps], lwd=3, col='blue');
        if (TRUE)
            {
                lines(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], lwd=1, col="green");
                lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=1, col="blue");
            }
        text(-15+startAtOne,1.2,"c - GoF",cex=2,xpd=NA, adj=0)
        ## GOF Pops 
        plot(GOF$Time[keeptps]+startAtOne,GOF$G2[keeptps],type='l',xlab="",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
        lines(GOF$Time[keeptps]+startAtOne,GOF$A2[keeptps],col='blue',type='l',lwd=3)
        lines(GOF$Time[keeptps]+startAtOne,GOF$N[keeptps],col='red',type='l',lwd=3)    
        lines(GOF$Time[keeptps]+startAtOne,GOF$G2[keeptps]+GOF$A2[keeptps],lwd=3, col="black")
        if (showNdetails)
            {
                lines(GOF$Time[keeptps]+startAtOne,GOF$Nfrom1[keeptps],col=colNfrom1,type='l',lwd=2, lty=2)    
                lines(GOF$Time[keeptps]+startAtOne,GOF$Nfrom2[keeptps],col=colNfrom2,type='l',lwd=2, lty=2)    
            }
        indices = rep(NA,2);
        for (ind in 1:2) indices[ind] = which(abs(GOFPN$Time-Pituello$PNWT$time[ind])<dt)[1];
        total = GOFPN$P+GOFPN$N;
        plotCI(Pituello$PNGOF$time,Pituello$PNGOF$P*total[indices]/100,uiw=Pituello$PNGOF$PIC,col='black',pch=16,cex=2,add=TRUE)
        plotCI(Pituello$PNGOF$time,Pituello$PNGOF$N*total[indices]/100,uiw=Pituello$PNGOF$NIC,col='red',pch=16,cex=2,add=TRUE)
        text(-15+startAtOne,25,"d",cex=2,xpd=NA)

        
        ## CDK MoD          
        plot(CDK$Time[keeptps]+startAtOne,1-CDK$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="Time (hpf)",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")
        lines(CDK$Time[keeptps]+startAtOne,1-CDK$aan[keeptps], lwd=3, col='blue');
        if (TRUE)
            {
                lines(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], lwd=1, col="green");
                lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=1, col="blue");
            }
        text(-15+startAtOne,1.2,expression("e - GoF-"*Delta*"CDK"),cex=2,xpd=NA, adj=0)
        ## CDK Pops 
        plot(CDK$Time[keeptps]+startAtOne,CDK$G2[keeptps],type='l',xlab="Time (hpf)",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
        lines(CDK$Time[keeptps]+startAtOne,CDK$A2[keeptps],col='blue',type='l',lwd=3)
        lines(CDK$Time[keeptps]+startAtOne,CDK$N[keeptps],col='red',type='l',lwd=3)    
        lines(CDK$Time[keeptps]+startAtOne,CDK$G2[keeptps]+CDK$A2[keeptps],lwd=3, col="black")
        if (showNdetails)
            {
                lines(CDK$Time[keeptps]+startAtOne,CDK$Nfrom1[keeptps],col=colNfrom1,type='l',lwd=2, lty=2)    
                lines(CDK$Time[keeptps]+startAtOne,CDK$Nfrom2[keeptps],col=colNfrom2,type='l',lwd=2, lty=2)    
            }
        indices = rep(NA,2);
        for (ind in 1:2) indices[ind] = which(abs(CDKPN$Time-Pituello$PNWT$time[ind])<dt)[1];
        total = CDKPN$P+CDKPN$N;
        plotCI(Pituello$PNCDK$time,Pituello$PNCDK$P*total[indices]/100,uiw=Pituello$PNCDK$PIC,col='black',pch=16,cex=2,add=TRUE)
        plotCI(Pituello$PNCDK$time,Pituello$PNCDK$N*total[indices]/100,uiw=Pituello$PNCDK$NIC,col='red',pch=16,cex=2,add=TRUE)
        
        text(-15+startAtOne,25,"f",cex=2,xpd=NA)

        dev.copy2pdf(file=name)
        
    }
 



if("fig25" %in% whatToDo) 
{
    ## PN model
    WTPN = PNTimeSeries(WTTauPP,WTTauNN);
    GOFPN = PNTimeSeries(GOFTauPP,GOFTauNN)
    CDKPN = PNTimeSeries(CDKTauPP,CDKTauNN)


    ## # Parametres
    G0 = 1.
    t0 = 0; tf = 96;
    dt = 0.01

    cat("\n #### GAA ####### \n");
    maxggg = 1;
    gggtst = function(t,te,sigma) { return( (1 - tanh( (t-te)/sigma) )*(maxggg/2)) }
    gtst = function(time,ggg)
        {
            gts = rep(NA,length(time));
            gts[1]=1; for (i in 2:length(time)) gts[i]=gts[i-1] + (2*ggg[i-1] -1)*eta*gts[i-1]*dt
            return(gts)
        }
    ggtst = function(te,sigma,time)
        {
            ggg = gggtst(time,te,sigma);
            gt = gtst(time,ggg)
            return(gt)
        }
    squareErrorggg = function(parms,time, alphapp, Ps)
        {
            nnt = ggtst(parms[1],parms[2],time)
            ## lines(time,nnt, col="red");
            return(sum( (nnt - alphapp*Ps)**2 ))
        }
    
    maxann = 1;
    anntst = function(t,te,sigma) { return( (1+tanh( (t-te)/sigma ) )*(maxann/2) ) }
    atst = function(time,ann,nns,Gs,gaa)
        {
            aan = 1-ann
            ats = rep(NA,length(time));
            ats[1]=0; for (i in 2:length(time)) ats[i]=ats[i-1] + (2*gaa[i-1]*Gs[i-1] + (aan[i-1]-1)*ats[i-1])*eta*dt
            return(ats)
        }
    nntst = function(te,sigma,time,nns,Gs,gaa)
        {
            ann = anntst(time,te,sigma);
            at = atst(time,ann,nns,Gs,gaa)
            return(ann*at/(at+Gs))
        }
    squareErrorNN = function(parms,time,nns,Gs,gaa)
        {
            nnt = nntst(parms[1],parms[2],time,nns,Gs,gaa)
            ## lines(time,nnt, col="red");
            return(sum( (nns - nnt)**2 ))
        }
    
    timeSeries = function(from,to,dt,G0,tauPP, tauNN)
        {
            time = seq(from,to,dt);
            alphapps = alphapp(time,tauPP);
            alphanns = alphann(time,tauNN);
            Ps = P.Analityque(time,0,tauPP, tauNN);
            ## ggg, gaa
            paramsggg = optim(par=c(tauPP,sigmapp), fn=squareErrorggg, gr = NULL,time,alphapps,Ps, method="Nelder-Mead")
            cat("ggg : ",paramsggg$par[1],", ",paramsggg$par[2],"\n");
            cat(" pp = ",tauPP,",",sigmapp,"\n");
            ggg = gggtst(time,paramsggg$par[1],paramsggg$par[2]);            
            gaa = 1-ggg

            ## ggg analytical from P, alphapp, eta
            apprime = c(diff(alphapps),NA)/dt;
            paprime = c(diff(Ps),NA)/dt;
            ggganalytic = 0.5* (  (1/eta)* (apprime*Ps + paprime*alphapps) / (alphapps*Ps)  +1   )

            ## G(t)
            Gs = G0 * exp( head(c(0,cumsum((ggg)*eta*dt)),-1) );
            Gs2 = rep(NA,length(time));
            Gs2[1]=1; for (i in 2:length(time)) Gs2[i]=Gs2[i-1] + (2*ggg[i-1]-1)*eta*Gs2[i-1]*dt
            ## ann, aan
            paramsann = optim(par=c(tauNN,sigmann),fn=squareErrorNN, gr = NULL,time,alphanns,Gs2,gaa, method="Nelder-Mead")
            cat("ann : ",paramsann$par[1],", ",paramsann$par[2],"\n");
            cat(" tauNN = ",tauNN,",",sigmann,"\n");
            ann = anntst(time,paramsann$par[1],paramsann$par[2]);            
            aan = 1-ann
            ## A(t), N(t)
            As2 = rep(NA,length(time));Ns2 = rep(NA,length(time));
            As2[1]=0; for (i in 2:length(time)) As2[i]=As2[i-1] + (2*gaa[i-1]*Gs2[i-1] + (aan[i-1]-1)*As2[i-1])*eta*dt
            Ns2[1]=0; for (i in 2:length(time)) Ns2[i]=Ns2[i-1] + ((2*ann[i-1] + aan[i-1])*As2[i-1])*eta*dt

            NfromAAN = cumsum(aan*As2*eta*dt);
            NfromANN = cumsum(2*ann*As2*eta*dt);
            return(list(Time=time,
                        pp=alphapps,nn=alphanns,ggg=ggg,asym=gaa,aan=aan,ann=ann,ggganalytic=ggganalytic,
                        P=Ps,G=Gs,
                        G2=Gs2,A2=As2,N=Ns2, Nfrom1 = NfromAAN, Nfrom2 = NfromANN,taug=paramsggg$par[1],sigmag=paramsggg$par[2],taua=paramsann$par[1],sigmaa=paramsann$par[2]))

        }
    
    ## compute them

    WTGAA = timeSeries(t0,tf,dt,G0,WTTauPP - startAtOne, WTTauNN - startAtOne)
    GOFGAA = timeSeries(t0,tf,dt,G0,GOFTauPP - startAtOne, GOFTauNN - startAtOne)
    CDKGAA = timeSeries(t0,tf,dt,G0,CDKTauPP - startAtOne, CDKTauNN - startAtOne)

    colNfrom1 = "orange";
    colNfrom2 = "red";
    graphicScenario(WTGAA,GOFGAA,CDKGAA,WTPN,GOFPN,CDKPN, name=paste(RepOut,"Figure3.pdf",sep=''),showNdetails=FALSE);

    ## superposition of fitted ggg and analytical ggg
    openGraphics(inwidth=5,inheight=10)
    par(las=1, family="Helvetica", mar=c(5,5,4,1), mfrow=c(3,1), tcl=0.4, cex.lab=2);
    
    plot(WTGAA$Time+startAtOne, 1-WTGAA$ggg, type="l", lwd=3, xlab="", ylab=expression(gamma[g]), ylim=c(0,2.5), main=expression("CTL"))
    lines(WTGAA$Time+startAtOne, 1-WTGAA$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(WTGAN$taug+startAtOne))/WTGAN$sigmag)),0,200, col="red",add=TRUE)

    plot(GOFGAA$Time+startAtOne, 1-GOFGAA$ggg, type="l", lwd=3, xlab="", ylab=expression(gamma[g]), ylim=c(0,2.5), main=expression("GoF"))
    lines(GOFGAA$Time+startAtOne, 1-GOFGAA$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(GOFGAN$taug+startAtOne))/GOFGAN$sigmag)),0,200, col="red",add=TRUE)
    
    plot(CDKGAA$Time+startAtOne, 1-CDKGAA$ggg, type="l", lwd=3, xlab="Time (hpf)", ylab=expression(gamma[g]), ylim=c(0,2.5), main=expression("GoF-"*Delta*"CDK"))
    lines(CDKGAA$Time+startAtOne, 1-CDKGAA$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(CDKGAN$taug+startAtOne))/CDKGAN$sigmag)),0,200, col="red",add=TRUE)

    dev.copy2pdf(file=paste(RepOut,"FigureS4.pdf",sep=''))




    cat("\n#### GAN ####### \n")
    maxggg = 1;
    gggtst = function(t,te,sigma) { return( (1 - tanh( (t-te)/sigma) )*(maxggg/2)) }
    gtst = function(time,ggg)
        {
            gts = rep(NA,length(time));
            gts[1]=1; for (i in 2:length(time)) gts[i]=gts[i-1] + (2*ggg[i-1] -1)*eta*gts[i-1]*dt
            return(gts)
        }
    ggtst = function(te,sigma,time)
        {
            ggg = gggtst(time,te,sigma);
            gt = gtst(time,ggg)
            return(gt*ggg)
        }
    squareErrorggg = function(parms,time, alphapp, Ps)
        {
            nnt = ggtst(parms[1],parms[2],time)
            ## lines(time,nnt, col="red");
            return(sum( (nnt - alphapp*Ps)**2 ))
        }
    
    
    maxann = 1.0;
    anntst = function(t,te,sigma,maxann) { return( (1+tanh( (t-te)/sigma ) )*(maxann/2) ) }
    atst = function(time,ann,nns,Gs,gan)
        {
            aan = 1-ann
            ats = rep(NA,length(time));
            ats[1]=0; for (i in 2:length(time)) ats[i]=ats[i-1] + (gan[i-1]*Gs[i-1] + (aan[i-1]-1)*ats[i-1])*eta*dt
            return(ats)
        }
    nntst = function(te,sigma,time,nns,Gs,gan)
        {
            ann = anntst(time,te,sigma,maxnn);
            at = atst(time,ann,nns,Gs,gan)
            return(ann*at/(at+Gs))
        }
    squareErrorNN = function(parms,time,nns,Gs,gan)
        {
            nnt = nntst(parms[1],parms[2],time,nns,Gs,gan)
            ## lines(time,nnt, col="red");
            return(sum( (nns - nnt)**2 ))
        }
    timeSeries = function(from,to,dt,G0,tauPP, tauNN, force=0)
        {
            time = seq(from,to,dt);
            alphapps = alphapp(time,tauPP);
            alphanns = alphann(time,tauNN);
            Ps = P.Analityque(time,0,tauPP, tauNN);
            
            ## ggg and gan / numerical as the others
            paramsggg = optim(par=c(tauPP,sigmapp), fn=squareErrorggg, gr = NULL,time,alphapps,Ps, method="Nelder-Mead")
            cat("ggg : ",paramsggg$par[1],", ",paramsggg$par[2],"\n");
            cat(" pp = ",tauPP,",",sigmapp,"\n");
            ggg = gggtst(time,paramsggg$par[1],paramsggg$par[2]);            

            ## ggg and gan / analytical from P, alphapp, eta
            numerator = alphapps * Ps * exp(eta*time);
            intdenom = head(c(0,cumsum(numerator*dt)),-1);
            ggganalytic = (numerator /(G0 + 2*eta*intdenom) )    
            gan = 1-ggganalytic;

            ## G(t)
            Gs = G0 * exp( head(c(0,cumsum((2*ggg - 1)*eta*dt)),-1) );
            Gs2 = rep(NA,length(time));
            Gs2[1]=1; for (i in 2:length(time)) Gs2[i]=Gs2[i-1] + (2*ggg[i-1] -1)*eta*Gs2[i-1]*dt
            
            ## ann, aan
            paramsann = optim(par=c(tauNN,sigmann),fn=squareErrorNN, gr = NULL,time,alphanns,Gs2,gan, method="Nelder-Mead")
            cat("ann : ",paramsann$par[1],", ",paramsann$par[2],"\n");
            cat(" tauNN = ",tauNN,",",sigmann,"\n");
            ann = anntst(time,paramsann$par[1],paramsann$par[2],maxann);

            if (force)
                {
                    ann = 1-ggg;
                }

            
            aan = 1-ann
            ## A(t), N(t)
            As2 = rep(NA,length(time));Ns2 = rep(NA,length(time));
            As2[1]=0; for (i in 2:length(time)) As2[i]=As2[i-1] + (gan[i-1]*Gs2[i-1] + (aan[i-1]-1)*As2[i-1])*eta*dt
            Ns2[1]=0; for (i in 2:length(time)) Ns2[i]=Ns2[i-1] + (gan[i-1]*Gs2[i-1] + (2*ann[i-1] + aan[i-1])*As2[i-1])*eta*dt
            NfromG = cumsum(gan*Gs2*eta*dt);
            NfromA = cumsum((2*ann + aan)*As2*eta*dt);
            return(list(Time=time,
                        pp=alphapps,nn=alphanns,ggg=ggg,asym=gan,aan=aan,ann=ann,ggganalytic=ggganalytic,
                        P=Ps,G=Gs,
                        G2=Gs2,A2=As2,N=Ns2, Nfrom1 = NfromG, Nfrom2 = NfromA,taug=paramsggg$par[1],sigmag=paramsggg$par[2],taua=paramsann$par[1],sigmaa=paramsann$par[2]))
        }
    ## compute them
    WTGAN = timeSeries(t0,tf,dt,G0,WTTauPP - startAtOne, WTTauNN - startAtOne, force=0)
    GOFGAN = timeSeries(t0,tf,dt,G0,GOFTauPP - startAtOne, GOFTauNN - startAtOne, force=0)
    CDKGAN = timeSeries(t0,tf,dt,G0,CDKTauPP - startAtOne, CDKTauNN - startAtOne, force=0)

    colNfrom1 = "green";
    colNfrom2 = "blue";
    graphicScenario(WTGAN,GOFGAN,CDKGAN,WTPN,GOFPN,CDKPN, name=paste(RepOut,"Figure2.pdf",sep=''),showNdetails=FALSE);


    ## superposition of fitted ggg and analytical ggg
    openGraphics(inwidth=5,inheight=10)
    par(las=1, family="Helvetica", mar=c(5,5,4,1), mfrow=c(3,1), tcl=0.4, cex.lab=2);
    
    plot(WTGAN$Time+startAtOne, 1-WTGAN$ggg, type="l", lwd=3, xlab="", ylab=expression(gamma[g]), ylim=c(0,1), main=expression("CTL"))
    lines(WTGAN$Time+startAtOne, 1-WTGAN$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(WTGAN$taug+startAtOne))/WTGAN$sigmag)),0,200, col="red",add=TRUE)

    plot(GOFGAN$Time+startAtOne, 1-GOFGAN$ggg, type="l", lwd=3, xlab="", ylab=expression(gamma[g]), ylim=c(0,1), main=expression("GoF"))
    lines(GOFGAN$Time+startAtOne, 1-GOFGAN$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(GOFGAN$taug+startAtOne))/GOFGAN$sigmag)),0,200, col="red",add=TRUE)
    
    plot(CDKGAN$Time+startAtOne, 1-CDKGAN$ggg, type="l", lwd=3, xlab="Time (hpf)", ylab=expression(gamma[g]), ylim=c(0,1), main=expression("GoF-"*Delta*"CDK"))
    lines(CDKGAN$Time+startAtOne, 1-CDKGAN$ggganalytic, col="green", lwd=2)
##    curve(0.5*(1+tanh( (x-(CDKGAN$taug+startAtOne))/CDKGAN$sigmag)),0,200, col="red",add=TRUE)

    dev.copy2pdf(file=paste(RepOut,"FigureS3.pdf",sep=''))
    






    

    ## fit back to data MoD
    openGraphics(inwidth=10,inheight=10);
    par(las=1, family="Helvetica", mar=c(5,5,2,1), mfcol=c(3,3), tcl=0.4);
    keeptps = seq(1,length(WTGAN$Time),100); # to make it lighter

    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    ## plotCI(Pituello$MODWT$time,Pituello$MODWT$MoD,uiw=Pituello$MODWT$IC,col=c('black','blue','red'),pch=16,add=TRUE,cex=2)
    curve(alphapp(x,WTTauPP)*100,40,140, ylim=c(0,1), col="black",add=TRUE,lwd=2);
    curve(alphann(x,WTTauNN)*100,40,140,add=TRUE,col='red',lwd=2);
    curve(alphapn(x,WTTauPP,WTTauNN)*100,40,140,add=TRUE,col='blue',lwd=2)
    text(30,112,"a - PN CTL",cex=1.5,xpd=NA, adj=0)

    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODGOF$time,Pituello$MODGOF$MoD,uiw=Pituello$MODGOF$IC,col=c('black','blue','red'),pch=16,cex=2)
    curve(alphapp(x,GOFTauPP)*100,40,140, ylim=c(0,1), col="black",add=TRUE,lwd=2);
    curve(alphann(x,GOFTauNN)*100,40,140,add=TRUE,col='red',lwd=2);
    curve(alphapn(x,GOFTauPP,GOFTauNN)*100,40,140,add=TRUE,col='blue',lwd=2)
    text(30,112,"b - PN GoF",cex=1.5,xpd=NA, adj=0)

    plot(NA,type="n",xlab="Time (hpf)",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODCDK$time,Pituello$MODCDK$MoD,uiw=Pituello$MODCDK$IC,col=c('black','blue','red'),pch=16,cex=2)
    curve(alphapp(x,CDKTauPP)*100,40,140, ylim=c(0,1), col="black",add=TRUE,lwd=2);
    curve(alphann(x,CDKTauNN)*100,40,140,add=TRUE,col='red',lwd=2);
    curve(alphapn(x,CDKTauPP,CDKTauNN)*100,40,140,add=TRUE,col='blue',lwd=2)
    text(30,112,expression("c - PN GoF-"*Delta*"CDK"),cex=1.5,xpd=NA, adj=0)


    scenario = WTGAN;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    ## plotCI(Pituello$MODWT$time,Pituello$MODWT$MoD,uiw=Pituello$MODWT$IC,col=c('black','blue','red'),pch=16,add=TRUE,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,"d - GAN CTL",cex=1.5,xpd=NA, adj=0)

    scenario = GOFGAN;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODGOF$time,Pituello$MODGOF$MoD,uiw=Pituello$MODGOF$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,"e - GAN GoF",cex=1.5,xpd=NA, adj=0)

    scenario = CDKGAN;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="Time (hpf)",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODCDK$time,Pituello$MODCDK$MoD,uiw=Pituello$MODCDK$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,expression("f - GAN GoF-"*Delta*"CDK"),cex=1.5,xpd=NA, adj=0)
    
    scenario = WTGAA;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2) + scenario$asym*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    ## plotCI(Pituello$MODWT$time,Pituello$MODWT$MoD,uiw=Pituello$MODWT$IC,col=c('black','blue','red'),pch=16,add=TRUE,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,"g - GAA CTL",cex=1.5,xpd=NA, adj=0)

    scenario = GOFGAA;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2) + scenario$asym*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODGOF$time,Pituello$MODGOF$MoD,uiw=Pituello$MODGOF$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,"h - GAA GoF",cex=1.5,xpd=NA, adj=0)

    scenario = CDKGAA;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2) + scenario$asym*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="Time (hpf)",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODCDK$time,Pituello$MODCDK$MoD,uiw=Pituello$MODCDK$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,112,expression("i - GAA GoF-"*Delta*"CDK"),cex=1.5,xpd=NA, adj=0)
    
    dev.copy2pdf(file=paste(RepOut,"Figure4.pdf",sep=''))















    

    ## Scenario GANa : GAN forcing ann to 1
    
    ## test scenario with A -> N,N only, i.e. with probability 1

    anntst = function(t,te,sigma,maxann) { return( rep(1, length(t)) ) }
    
    timeSeries = function(from,to,dt,G0,tauPP, tauNN)
        {
            time = seq(from,to,dt);
            alphapps = alphapp(time,tauPP);
            alphanns = alphann(time,tauNN);
            Ps = P.Analityque(time,0,tauPP, tauNN);
            
            ## ggg and gan / numerical as the others
            paramsggg = optim(par=c(tauPP,sigmapp), fn=squareErrorggg, gr = NULL,time,alphapps,Ps, method="Nelder-Mead")
            cat("ggg : ",paramsggg$par[1],", ",paramsggg$par[2],"\n");
            cat(" pp = ",tauPP,",",sigmapp,"\n");
            ggg = gggtst(time,paramsggg$par[1],paramsggg$par[2]);            

            ## ggg and gan / analytical from P, alphapp, eta
            numerator = alphapps * Ps * exp(eta*time);
            intdenom = head(c(0,cumsum(numerator*dt)),-1);
            ggganalytic = (numerator /(G0 + 2*eta*intdenom) )    
            gan = 1-ggganalytic;

            ## G(t)
            Gs = G0 * exp( head(c(0,cumsum((2*ggg - 1)*eta*dt)),-1) );
            Gs2 = rep(NA,length(time));
            Gs2[1]=1; for (i in 2:length(time)) Gs2[i]=Gs2[i-1] + (2*ggg[i-1] -1)*eta*Gs2[i-1]*dt
            
            ## ann, aan
            ann = anntst(time,paramsann$par[1],paramsann$par[2],maxann);            
            aan = 1-ann
            ## A(t), N(t)
            As2 = rep(NA,length(time));Ns2 = rep(NA,length(time));
            As2[1]=0; for (i in 2:length(time)) As2[i]=As2[i-1] + (gan[i-1]*Gs2[i-1] + (aan[i-1]-1)*As2[i-1])*eta*dt
            Ns2[1]=0; for (i in 2:length(time)) Ns2[i]=Ns2[i-1] + (gan[i-1]*Gs2[i-1] + (2*ann[i-1] + aan[i-1])*As2[i-1])*eta*dt
            NfromG = cumsum(gan*Gs2*eta*dt);
            NfromA = cumsum((2*ann + aan)*As2*eta*dt);
            return(list(Time=time,
                        pp=alphapps,nn=alphanns,ggg=ggg,asym=gan,aan=aan,ann=ann,ggganalytic=ggganalytic,
                        P=Ps,G=Gs,
                        G2=Gs2,A2=As2,N=Ns2, Nfrom1 = NfromG, Nfrom2 = NfromA,taug=paramsggg$par[1],sigmag=paramsggg$par[2]))
        }
    ## compute them
    WTGANa = timeSeries(t0,tf,dt,G0,WTTauPP - startAtOne, WTTauNN - startAtOne)
    GOFGANa = timeSeries(t0,tf,dt,G0,GOFTauPP - startAtOne, GOFTauNN - startAtOne)
    CDKGANa = timeSeries(t0,tf,dt,G0,CDKTauPP - startAtOne, CDKTauNN - startAtOne)



    openGraphics(inwidth=10,inheight=10);
    par(las=1, family="Helvetica", mar=c(5,5,4,1), mfrow=c(3,3), tcl=0.4);

 
    colNfrom1 = "green";
    colNfrom2 = "blue";
    ## graphicScenario(WTGANa,GOFGANa,CDKGANa,WTPN,GOFPN,CDKPN, name=paste(RepOut,"FigureS2.pdf",sep=''),showNdetails=FALSE);


    WT  = WTGANa;
    GOF = GOFGANa;
    CDK = CDKGANa;
    keeptps = seq(1,length(WT$Time),100); # to make graphics lighter
    
    ## WT MoD          
    plot(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")        
    lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=3, col='blue');
    legend(x=100,y=0.6,legend=c(expression(gamma[G](t)),expression(gamma[A](t))),col=c("green","blue"),lwd=c(2,2),cex=1)
    text(-15+startAtOne,1.2,"a - CTL",cex=2,xpd=NA, adj=0)
    ## WT Pops 
    plot(WT$Time[keeptps]+startAtOne,WT$G2[keeptps],type='l',xlab="",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
    lines(WT$Time[keeptps]+startAtOne,WT$A2[keeptps],col='blue',type='l',lwd=3)
    lines(WT$Time[keeptps]+startAtOne,WT$N[keeptps],col='red',type='l',lwd=3)    
    lines(WT$Time[keeptps]+startAtOne,WT$G2[keeptps]+WT$A2[keeptps],lwd=3, col="black")
    legend(x=40,y=20,legend=c(expression(G(t)),expression(A(t)),expression(N(t)),expression(P(t))),col=c("green","blue","red","black"),lwd=c(2,2,2,2),cex=1)

    plotCI(Saade$PN$time,Saade$PN$P/12,uiw=Saade$PN$PIC/12,pch=15,cex=0.8,col="black",add=TRUE);
    plotCI(Saade$PN$time,Saade$PN$N/12,uiw=Saade$PN$NIC/12,pch=15,cex=0.8,col="red",add=TRUE);
    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(WTPN$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = WTPN$P+WTPN$N;
    plotCI(Pituello$PNWT$time,Pituello$PNWT$P*total[indices]/100,uiw=Pituello$PNWT$PIC,col='black',pch=16,add=TRUE,cex=2)
    plotCI(Pituello$PNWT$time,Pituello$PNWT$N*total[indices]/100,uiw=Pituello$PNWT$NIC,col='red',pch=16,add=TRUE,cex=2)
    text(-15+startAtOne,25,"b",cex=2,xpd=NA)

    scenario = WTGANa;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    ## plotCI(Pituello$MODWT$time,Pituello$MODWT$MoD,uiw=Pituello$MODWT$IC,col=c('black','blue','red'),pch=16,add=TRUE,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,118,"c",cex=2,xpd=NA, adj=0)

    
        

    ## GOF MoD          
    plot(GOF$Time[keeptps]+startAtOne,1-GOF$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")
    lines(GOF$Time[keeptps]+startAtOne,1-GOF$aan[keeptps], lwd=3, col='blue');
    if (TRUE)
        {
            lines(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], lwd=1, col="green");
            lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=1, col="blue");
        }
    text(-15+startAtOne,1.2,"d - GoF",cex=2,xpd=NA, adj=0)
    ## GOF Pops 
    plot(GOF$Time[keeptps]+startAtOne,GOF$G2[keeptps],type='l',xlab="",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
    lines(GOF$Time[keeptps]+startAtOne,GOF$A2[keeptps],col='blue',type='l',lwd=3)
    lines(GOF$Time[keeptps]+startAtOne,GOF$N[keeptps],col='red',type='l',lwd=3)    
    lines(GOF$Time[keeptps]+startAtOne,GOF$G2[keeptps]+GOF$A2[keeptps],lwd=3, col="black")
    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(GOFPN$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = GOFPN$P+GOFPN$N;
    plotCI(Pituello$PNGOF$time,Pituello$PNGOF$P*total[indices]/100,uiw=Pituello$PNGOF$PIC,col='black',pch=16,cex=2,add=TRUE)
    plotCI(Pituello$PNGOF$time,Pituello$PNGOF$N*total[indices]/100,uiw=Pituello$PNGOF$NIC,col='red',pch=16,cex=2,add=TRUE)
    text(-15+startAtOne,25,"e",cex=2,xpd=NA)

    scenario = GOFGANa;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODGOF$time,Pituello$MODGOF$MoD,uiw=Pituello$MODGOF$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,118,"f",cex=2,xpd=NA, adj=0)



    
    ## CDK MoD          
    plot(CDK$Time[keeptps]+startAtOne,1-CDK$ggg[keeptps], type='l',ylim=c(0,1),xlim=c(40,140), xlab="Time (hpf)",ylab='Mode of Division',lwd=3,cex.lab=1.3,col="green")
    lines(CDK$Time[keeptps]+startAtOne,1-CDK$aan[keeptps], lwd=3, col='blue');
    if (TRUE)
        {
            lines(WT$Time[keeptps]+startAtOne,1-WT$ggg[keeptps], lwd=1, col="green");
            lines(WT$Time[keeptps]+startAtOne,1-WT$aan[keeptps], lwd=1, col="blue");
        }
    text(-15+startAtOne,1.2,expression("g - GoF-"*Delta*"CDK"),cex=2,xpd=NA, adj=0)
    ## CDK Pops 
    plot(CDK$Time[keeptps]+startAtOne,CDK$G2[keeptps],type='l',xlab="Time (hpf)",ylab="Number of cells",ylim = c(0,250/12),xlim=c(40,140),col='green',lwd=3,cex.lab=1.3);
    lines(CDK$Time[keeptps]+startAtOne,CDK$A2[keeptps],col='blue',type='l',lwd=3)
    lines(CDK$Time[keeptps]+startAtOne,CDK$N[keeptps],col='red',type='l',lwd=3)    
    lines(CDK$Time[keeptps]+startAtOne,CDK$G2[keeptps]+CDK$A2[keeptps],lwd=3, col="black")
    indices = rep(NA,2);
    for (ind in 1:2) indices[ind] = which(abs(CDKPN$Time-Pituello$PNWT$time[ind])<dt)[1];
    total = CDKPN$P+CDKPN$N;
    plotCI(Pituello$PNCDK$time,Pituello$PNCDK$P*total[indices]/100,uiw=Pituello$PNCDK$PIC,col='black',pch=16,cex=2,add=TRUE)
    plotCI(Pituello$PNCDK$time,Pituello$PNCDK$N*total[indices]/100,uiw=Pituello$PNCDK$NIC,col='red',pch=16,cex=2,add=TRUE)
    
    text(-15+startAtOne,25,"h",cex=2,xpd=NA)
    
    scenario = CDKGANa;
    scenario$pp = scenario$ggg*scenario$G2/(scenario$G2+scenario$A2);
    scenario$nn = scenario$ann*scenario$A2/(scenario$G2+scenario$A2);
    scenario$pn = scenario$asym*scenario$G2/(scenario$G2+scenario$A2) + scenario$aan*scenario$A2/(scenario$G2+scenario$A2);
    scenario$gamma = scenario$pp - scenario$nn;
        
    plot(NA,type="n",xlab="Time(hpf)",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Pituello$MODCDK$time,Pituello$MODCDK$MoD,uiw=Pituello$MODCDK$IC,col=c('black','blue','red'),pch=16,cex=2)
    lines(scenario$Time[keeptps]+startAtOne, scenario$pp[keeptps]*100,lwd=2, col="black");
    lines(scenario$Time[keeptps]+startAtOne, scenario$nn[keeptps]*100,lwd=2, col="red");
    lines(scenario$Time[keeptps]+startAtOne, scenario$pn[keeptps]*100,lwd=2, col="blue");
    text(30,118,"i",cex=2,xpd=NA, adj=0)

    
    dev.copy2pdf(file=paste(RepOut,"FigureS1.pdf",sep=''))







    ## Fig. 5 and S2

    temps = seq(startAtOne,140,dt);
    nit = length(temps);
    keeptmps = seq(1,length(temps),100);

    ## PN MODEL

    pps = 0.5*(1 - tanh( (temps-WTTauPP)/sigmapp));
    nns = 0.4*(1 + tanh( (temps-WTTauNN)/sigmann));

    Ps = rep(0,nit) ; Ns = rep(0,nit) ; gamma = rep(0,nit);
    Ps[1] = 1 ; Ns[1] = 0 ; gamma[1]= pps[1] - nns[1]
    for(t in 2:nit)
        {
            gamma[t] = pps[t-1] - nns[t-1];                
            Ps[t] = Ps[t-1] + eta*dt*Ps[t-1]* gamma[t];
            Ns[t] = Ns[t-1] + eta*dt*Ps[t-1]* (1.0-gamma[t]);
        }
    PplusN = Ps + Ns;
    Psref = Ps; Nsref = Ns;

    ## fitting feedback parameters
    alphappfb = function(t,te,sigma) { return( 0.5*(1 - tanh( (t-te)/sigma))) }
    squareErrorPP = function(parms) {  return(sum(  (pps[keeptmps] -  alphappfb(PplusN[keeptmps],parms[1],parms[2]) )**2     )) }
    paramspp = optim(par=c(3,3), squareErrorPP, method="L-BFGS-B", lower=0)
    print(paramspp);
    fbtaupp = paramspp$par[1] ; fbsigmapp = paramspp$par[2] ;

    alphannfb = function(t,te,sigma) { return( 0.5*(1 + tanh( (t-te)/sigma))) }
    squareErrorNN = function(parms) {  return(sum(  (nns[keeptmps] -  alphannfb(PplusN[keeptmps],parms[1],parms[2]) )**2     )) }
    paramsnn = optim(par=c(11,5), squareErrorNN, method="L-BFGS-B", lower=0)
    print(paramsnn);
    fbtaunn = paramsnn$par[1] ; fbsigmann = paramsnn$par[2] ;

    ## PN TimeSeries with feedback
    Pfb = rep(0,nit) ; Nfb = rep(0,nit) ;
    Pfb[1] = 1 ; Nfb[1] = 0 ;
    ppfbs = rep(0,nit);
    nnfbs = rep(0,nit);
    ppfbs[1] = alphappfb(Pfb[1],fbtaupp,fbsigmapp);
    nnfbs[1] = alphannfb(Pfb[1],fbtaunn,fbsigmann);
    for(t in 2:nit)
        {
            ppfbs[t] = alphappfb(Pfb[t-1]+Nfb[t-1],fbtaupp,fbsigmapp);
            nnfbs[t] = alphannfb(Pfb[t-1]+Nfb[t-1],fbtaunn,fbsigmann);
            gammafb = ppfbs[t] - nnfbs[t]                 
            Pfb[t] = Pfb[t-1] + eta*dt*Pfb[t-1]* gammafb;
            Nfb[t] = Nfb[t-1] + eta*dt*Pfb[t-1]* (1.0-gammafb);
        }


    ## GAN model

    gggs = 0.5* (1 - tanh( (temps-(WTGAN$taug+startAtOne))/WTGAN$sigmag) )
    gans = 1-gggs
    anns = 0.5* (1+tanh( (temps-(WTGAN$taua+startAtOne))/WTGAN$sigmaa ) )
    aans = 1-anns

    Gs = rep(0,nit) ; As = rep(0,nit) ; Ns = rep(0,nit) ;gamma = rep(0,nit);
    Gs[1] = 1 ; As[1]=0; Ns[1] = 0 ;
    for(t in 2:nit)
        {
            Gs[t] = Gs[t-1] + (2*gggs[t-1] -1)*eta*Gs[t-1]*dt
            As[t] = As[t-1] + (gans[t-1]*Gs[t-1] + (aans[t-1]-1)*As[t-1])*eta*dt
            Ns[t] = Ns[t-1] + (gans[t-1]*Gs[t-1] + (2*anns[t-1] + aans[t-1])*As[t-1])*eta*dt
        }
    GplusAplusN = Gs + As + Ns;
    Gsref = Gs ; Asref= As; Nsref = Ns;

    ## fitting feedback parameters
    gggfb = function(t,te,sigma) { return( 0.5*(1 - tanh( (t-te)/sigma))) }
    squareErrorGG = function(parms) {  return(sum(  (gggs[keeptmps] - gggfb(GplusAplusN[keeptmps],parms[1],parms[2]) )**2     )) }
    paramsgg = optim(par=c(3,3), squareErrorGG, method="L-BFGS-B", lower=0)
    print(paramsgg);
    fbtaugg = paramsgg$par[1] ; fbsigmagg = paramsgg$par[2] ;

    annfb = function(t,te,sigma) { return( 0.5*(1 + tanh( (t-te)/sigma))) }
    squareErrorANN = function(parms) {  return(sum(  (anns[keeptmps] -  annfb(GplusAplusN[keeptmps],parms[1],parms[2]) )**2     )) }
    paramsann = optim(par=c(11,5), squareErrorANN, method="L-BFGS-B", lower=0)
    print(paramsann);
    fbtauann = paramsann$par[1] ; fbsigmaann = paramsann$par[2] ;

    ## only one control
    commontau = fbtaugg ; 
    commonsigma = fbsigmagg ;
    ## GAN TimeSeries with feedback
    Gsfb = rep(0,nit) ; Asfb = rep(0,nit) ; Nsfb = rep(0,nit) ;
    Gsfb[1] = 1 ; Asfb[1] = 0 ; Nsfb[1] = 0 ;
    gggsp = rep(0,nit); annsp = rep(0,nit);
    gggsp[1] = gggfb(Gsfb[1]+Asfb[1]+Nsfb[1],commontau,commonsigma)
    annsp[1] = annfb(Gsfb[1]+Asfb[1]+Nsfb[1],commontau,commonsigma);

    for(t in 2:nit)
        {
            gggsp[t] = gggfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            gansp = 1-gggsp[t];
            annsp[t] = annfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            aansp = 1-annsp[t]
            
            Gsfb[t] = Gsfb[t-1] + (2*gggsp[t] -1)*eta*Gsfb[t-1]*dt
            Asfb[t] = Asfb[t-1] + (gansp*Gsfb[t-1] + (aansp-1)*Asfb[t-1])*eta*dt
            Nsfb[t] = Nsfb[t-1] + (gansp*Gsfb[t-1] + (2*annsp[t] + aansp)*Asfb[t-1])*eta*dt
        }
    Gsfbref = Gsfb; Asfbref = Asfb; Nsfbref = Nsfb;
    gggspref = gggsp ; annspref = annsp;







    openGraphics(inwidth=8,inheight=10);
    par(las=1, family="Helvetica", mar=c(5,5,4,1), mfcol=c(3,2), tcl=0.4);

    plot(PplusN[keeptmps],pps[keeptmps],type="l",lwd=1, xlim=c(0,20), ylim=c(0,1),cex.lab=1.3, xlab="P(t)+N(t)", ylab=expression(alpha[pp](t)*","*alpha[nn](t)), main="PN model");
    curve(alphappfb(x,fbtaupp,fbsigmapp), add=TRUE,col="red",lwd=2)
    legend(x=6,y=0.95,legend=c("PN","PN+fb"),col=c("black","red"),lwd=c(2,2),cex=1)
    lines(PplusN[keeptmps],nns[keeptmps],type="l",lwd=1);
    curve(alphannfb(x,fbtaunn,fbsigmann), add=TRUE,col="red",lwd=2)
    text(-2,1.10,"a",cex=2,xpd=NA, adj=0)



    plot(NA,type="n",xlab="",ylab="Mode of division",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    lines(temps,ppfbs*100,lwd=2, col="black")
    lines(temps,nnfbs*100,lwd=2, col="red");
    lines(temps,(1-ppfbs-nnfbs)*100,lwd=2, col="blue");
    text(30,115,"b",cex=2,xpd=NA, adj=0)


    plot(temps[keeptmps],Ps[keeptmps], xlim=c(40,140), ylim=c(0,20), type="l",lwd=2, xlab="Time (hpf)", ylab="Number of cells",cex.lab=1.3);
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Pfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nfb[keeptmps], col="red",lwd=2)
    plotCI(Saade$PN$time,Saade$PN$P/12,uiw=Saade$PN$PIC/12,pch=15,col="black",add=TRUE);
    plotCI(Saade$PN$time,Saade$PN$N/12,uiw=Saade$PN$NIC/12,pch=15,col="red",add=TRUE);
    legend(x=50,y=19,legend=c("PN","PN+fb"),col=c("black","red"),lwd=c(2,2),cex=1)
    text(30,23,"c",cex=2,xpd=NA, adj=0)


    plot(GplusAplusN[keeptmps],1-gggs[keeptmps],type="l",lwd=1, xlim=c(0,20), ylim=c(0,1),cex.lab=1.3, xlab="G(t)+A(t)+N(t)", ylab=expression(gamma[G](t)*","*gamma[A](t)), main="GAN model");
    lines(GplusAplusN[keeptmps],anns[keeptmps],type="l",lwd=1);
    curve(1-gggfb(x,commontau,commonsigma), add=TRUE,col="red", lwd=2)
    legend(x=0,y=0.95,legend=c("GAN","GAN+fb"),col=c("black","red"),lwd=c(2,2),cex=1)
    text(-2,1.10,"d",cex=2,xpd=NA, adj=0)


    ppganr = gggspref*Gsfbref/(Gsfbref+Asfbref);
    nnganr = annspref*Asfbref/(Gsfbref+Asfbref);
    pnganr = (1-gggspref)*Gsfbref/(Gsfbref+Asfbref) + (1-annspref)*Asfbref/(Gsfbref+Asfbref); 
    plot(NA,type="n",xlab="",ylab="",ylim=c(0,100),xlim=c(40,140),cex.lab=1.3)
    plotCI(Saade$MOD$time,Saade$MOD$pp,uiw=Saade$MOD$IcPP,type='b',pch=15,col='black')
    plotCI(Saade$MOD$time,Saade$MOD$pn,uiw=Saade$MOD$IcPN,type='b',pch=15,col='blue')
    plotCI(Saade$MOD$time,Saade$MOD$nn,uiw=Saade$MOD$IcNN,type='b',pch=15,col='red')
    lines(temps, ppganr*100,lwd=2, col="black");
    lines(temps, nnganr*100,lwd=2, col="red");
    lines(temps, pnganr*100,lwd=2, col="blue");
    text(30,115,"e",cex=2,xpd=NA, adj=0)


    plot(temps[keeptmps],Gs[keeptmps]+As[keeptmps], xlim=c(40,140), ylim=c(0,20), type="l",lwd=2, xlab="Time (hpf)",  ylab="",cex.lab=1.3);
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Gsfb[keeptmps]+Asfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nsfb[keeptmps], col="red",lwd=2)
    plotCI(Saade$PN$time,Saade$PN$P/12,uiw=Saade$PN$PIC/12,pch=15,col="black",add=TRUE);
    plotCI(Saade$PN$time,Saade$PN$N/12,uiw=Saade$PN$NIC/12,pch=15,col="red",add=TRUE);
    legend(x=50,y=19,legend=c("GAN","GAN+fb"),col=c("black","red"),lwd=c(2,2,2),cex=1)
    text(30,23,"f",cex=2,xpd=NA, adj=0)


    dev.copy2pdf(file="Figure5.pdf")














    ## with other initial condition


    openGraphics(inwidth=8,inheight=10);
    par(las=1, family="Helvetica", mar=c(5,5,3,1), mfrow=c(3,2), tcl=0.4);



    ## PN
    Ps = rep(0,nit) ; Ns = rep(0,nit) ; gamma = rep(0,nit);
    Ps[1] = 2 ; Ns[1] = 0 ; gamma[1]= pps[1] - nns[1]
    for(t in 2:nit)
        {
            gamma[t] = pps[t-1] - nns[t-1];                
            Ps[t] = Ps[t-1] + eta*dt*Ps[t-1]* gamma[t];
            Ns[t] = Ns[t-1] + eta*dt*Ps[t-1]* (1.0-gamma[t]);
        }
    PplusN = Ps + Ns;

    Pfb = rep(0,nit) ; Nfb = rep(0,nit) ; gammafb = rep(0,nit) ;
    Pfb[1] = 2 ; Nfb[1] = 0 ;
    gammafb[1]=alphappfb(Pfb[1],fbtaupp,fbsigmapp) - alphannfb(Pfb[1],fbtaunn,fbsigmann)
    for(t in 2:nit)
        {
            gammafb[t] = alphappfb(Pfb[t-1]+Nfb[t-1],fbtaupp,fbsigmapp) - alphannfb(Pfb[t-1]+Nfb[t-1],fbtaunn,fbsigmann);                
            Pfb[t] = Pfb[t-1] + eta*dt*Pfb[t-1]* gammafb[t];
            Nfb[t] = Nfb[t-1] + eta*dt*Pfb[t-1]* (1.0-gammafb[t]);
        }
    plot(temps[keeptmps],Psref[keeptmps], ylim=c(0,20), type="l",lwd=1, xlab="", xlim=c(40,140), ylab="Number of cells",cex.lab=1.3, main="PN model");
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Ps[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Pfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nfb[keeptmps], col="red",lwd=2)
    text(30,23,"a",cex=2,xpd=NA, adj=0)

    ## GAN
    Gs = rep(0,nit) ; As = rep(0,nit) ; Ns = rep(0,nit) ;gamma = rep(0,nit);
    Gs[1] = 2 ; As[1]=0; Ns[1] = 0 ;
    for(t in 2:nit)
        {
            Gs[t] = Gs[t-1] + (2*gggs[t-1] -1)*eta*Gs[t-1]*dt
            As[t] = As[t-1] + (gans[t-1]*Gs[t-1] + (aans[t-1]-1)*As[t-1])*eta*dt
            Ns[t] = Ns[t-1] + (gans[t-1]*Gs[t-1] + (2*anns[t-1] + aans[t-1])*As[t-1])*eta*dt
        }
    Gsfb = rep(0,nit) ; Asfb = rep(0,nit) ; Nsfb = rep(0,nit) ;
    Gsfb[1] = 2 ; Asfb[1] = 0 ; Nsfb[1] = 0 ;
    for(t in 2:nit)
        {
            gggsp = gggfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            gansp = 1-gggsp;
            annsp = annfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            aansp = 1-annsp
            
            Gsfb[t] = Gsfb[t-1] + (2*gggsp -1)*eta*Gsfb[t-1]*dt
            Asfb[t] = Asfb[t-1] + (gansp*Gsfb[t-1] + (aansp-1)*Asfb[t-1])*eta*dt
            Nsfb[t] = Nsfb[t-1] + (gansp*Gsfb[t-1] + (2*annsp + aansp)*Asfb[t-1])*eta*dt
        }
    plot(temps[keeptmps],Gsref[keeptmps]+Asref[keeptmps], xlim=c(40,140), ylim=c(0,20), type="l",lwd=1, xlab="",  ylab="",cex.lab=1.3, main="GAN model");
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Gs[keeptmps]+As[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Gsfb[keeptmps]+Asfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nsfb[keeptmps], col="red",lwd=2)
    text(30,23,"d",cex=2,xpd=NA, adj=0)




    ## PN
    Ps = rep(0,nit) ; Ns = rep(0,nit) ; gamma = rep(0,nit);
    Ps[1] = 0.5 ; Ns[1] = 0 ; gamma[1]= pps[1] - nns[1]
    for(t in 2:nit)
        {
            gamma[t] = pps[t-1] - nns[t-1];                
            Ps[t] = Ps[t-1] + eta*dt*Ps[t-1]* gamma[t];
            Ns[t] = Ns[t-1] + eta*dt*Ps[t-1]* (1.0-gamma[t]);
        }
    PplusN = Ps + Ns;

    Pfb = rep(0,nit) ; Nfb = rep(0,nit) ; gammafb = rep(0,nit) ;
    Pfb[1] = 0.5 ; Nfb[1] = 0 ;
    gammafb[1]=alphappfb(Pfb[1],fbtaupp,fbsigmapp) - alphannfb(Pfb[1],fbtaunn,fbsigmann)
    for(t in 2:nit)
        {
            gammafb[t] = alphappfb(Pfb[t-1]+Nfb[t-1],fbtaupp,fbsigmapp) - alphannfb(Pfb[t-1]+Nfb[t-1],fbtaunn,fbsigmann);                
            Pfb[t] = Pfb[t-1] + eta*dt*Pfb[t-1]* gammafb[t];
            Nfb[t] = Nfb[t-1] + eta*dt*Pfb[t-1]* (1.0-gammafb[t]);
        }
    plot(temps[keeptmps],Psref[keeptmps], ylim=c(0,20), type="l",lwd=1, xlab="", xlim=c(40,140), ylab="Number of cells",cex.lab=1.3);
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Ps[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Pfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nfb[keeptmps], col="red",lwd=2)
    legend(x=50,y=19,legend=c("Reference","PN","PN+fb"),col=c("black","black","red"),lwd=c(1,2,2),cex=1)

    text(30,23,"b",cex=2,xpd=NA, adj=0)

    ## GAN
    Gs = rep(0,nit) ; As = rep(0,nit) ; Ns = rep(0,nit) ;gamma = rep(0,nit);
    Gs[1] = 0.5 ; As[1]=0; Ns[1] = 0 ;
    for(t in 2:nit)
        {
            Gs[t] = Gs[t-1] + (2*gggs[t-1] -1)*eta*Gs[t-1]*dt
            As[t] = As[t-1] + (gans[t-1]*Gs[t-1] + (aans[t-1]-1)*As[t-1])*eta*dt
            Ns[t] = Ns[t-1] + (gans[t-1]*Gs[t-1] + (2*anns[t-1] + aans[t-1])*As[t-1])*eta*dt
        }
    Gsfb = rep(0,nit) ; Asfb = rep(0,nit) ; Nsfb = rep(0,nit) ;
    Gsfb[1] = 0.5 ; Asfb[1] = 0 ; Nsfb[1] = 0 ;
    for(t in 2:nit)
        {
            gggsp = gggfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            gansp = 1-gggsp;
            annsp = annfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            aansp = 1-annsp
            
            Gsfb[t] = Gsfb[t-1] + (2*gggsp -1)*eta*Gsfb[t-1]*dt
            Asfb[t] = Asfb[t-1] + (gansp*Gsfb[t-1] + (aansp-1)*Asfb[t-1])*eta*dt
            Nsfb[t] = Nsfb[t-1] + (gansp*Gsfb[t-1] + (2*annsp + aansp)*Asfb[t-1])*eta*dt
        }
    plot(temps[keeptmps],Gsref[keeptmps]+Asref[keeptmps], xlim=c(40,140), ylim=c(0,20), type="l",lwd=1, xlab="",  ylab="",cex.lab=1.3);
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Gs[keeptmps]+As[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Gsfb[keeptmps]+Asfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nsfb[keeptmps], col="red",lwd=2)
    legend(x=50,y=19,legend=c("Reference","GAN","GAN+fb"),col=c("black","black","red"),lwd=c(1,2,2),cex=1)
    text(30,23,"e",cex=2,xpd=NA, adj=0)




    ## PN
    Ps = rep(0,nit) ; Ns = rep(0,nit) ; gamma = rep(0,nit);
    Ps[1] = 1 ; Ns[1] = 0 ; gamma[1]= pps[1] - nns[1]
    for(t in 2:nit)
        {
            gamma[t] = pps[t-1] - nns[t-1];                
            Ps[t] = Ps[t-1] + eta*dt*Ps[t-1]* gamma[t];
            Ns[t] = Ns[t-1] + eta*dt*Ps[t-1]* (1.0-gamma[t]);
            if (t==1000) Ps[t] = Ps[t]/2

        }
    PplusN = Ps + Ns;

    Pfb = rep(0,nit) ; Nfb = rep(0,nit) ; gammafb = rep(0,nit) ;
    Pfb[1] = 1 ; Nfb[1] = 0 ;
    gammafb[1]=alphappfb(Pfb[1],fbtaupp,fbsigmapp) - alphannfb(Pfb[1],fbtaunn,fbsigmann)
    for(t in 2:nit)
        {
            gammafb[t] = alphappfb(Pfb[t-1]+Nfb[t-1],fbtaupp,fbsigmapp) - alphannfb(Pfb[t-1]+Nfb[t-1],fbtaunn,fbsigmann);                
            Pfb[t] = Pfb[t-1] + eta*dt*Pfb[t-1]* gammafb[t];
            Nfb[t] = Nfb[t-1] + eta*dt*Pfb[t-1]* (1.0-gammafb[t]);
            if (t==1000) Pfb[t] = Pfb[t]/2
        }
    plot(temps[keeptmps],Psref[keeptmps], ylim=c(0,20), type="l",lwd=1, xlab="Time (hpf)", xlim=c(40,140), ylab="Number of cells",cex.lab=1.3);
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Ps[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Pfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nfb[keeptmps], col="red",lwd=2)
    text(30,23,"c",cex=2,xpd=NA, adj=0)

    ## GAN
    Gs = rep(0,nit) ; As = rep(0,nit) ; Ns = rep(0,nit) ;gamma = rep(0,nit);
    Gs[1] = 1 ; As[1]=0; Ns[1] = 0 ;
    for(t in 2:nit)
        {
            Gs[t] = Gs[t-1] + (2*gggs[t-1] -1)*eta*Gs[t-1]*dt
            As[t] = As[t-1] + (gans[t-1]*Gs[t-1] + (aans[t-1]-1)*As[t-1])*eta*dt
            Ns[t] = Ns[t-1] + (gans[t-1]*Gs[t-1] + (2*anns[t-1] + aans[t-1])*As[t-1])*eta*dt
            if (t==1000) Gs[t] = Gs[t]/2
        }
    Gsfb = rep(0,nit) ; Asfb = rep(0,nit) ; Nsfb = rep(0,nit) ;
    Gsfb[1] = 1 ; Asfb[1] = 0 ; Nsfb[1] = 0 ;
    for(t in 2:nit)
        {
            gggsp = gggfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            gansp = 1-gggsp;
            annsp = annfb(Gsfb[t-1]+Asfb[t-1]+Nsfb[t-1],commontau,commonsigma);
            aansp = 1-annsp
            
            Gsfb[t] = Gsfb[t-1] + (2*gggsp -1)*eta*Gsfb[t-1]*dt
            Asfb[t] = Asfb[t-1] + (gansp*Gsfb[t-1] + (aansp-1)*Asfb[t-1])*eta*dt
            Nsfb[t] = Nsfb[t-1] + (gansp*Gsfb[t-1] + (2*annsp + aansp)*Asfb[t-1])*eta*dt
            if (t==1000) Gsfb[t] = Gsfb[t]/2
        }
    plot(temps[keeptmps],Gsref[keeptmps]+Asref[keeptmps], xlim=c(40,140), ylim=c(0,20), type="l",lwd=1, xlab="Time (hpf)",  ylab="",cex.lab=1.3);
    lines(temps[keeptmps],Nsref[keeptmps], col="black",lwd=1)
    lines(temps[keeptmps],Gs[keeptmps]+As[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Ns[keeptmps], col="black",lwd=2)
    lines(temps[keeptmps],Gsfb[keeptmps]+Asfb[keeptmps], col="red",lwd=2)
    lines(temps[keeptmps],Nsfb[keeptmps], col="red",lwd=2)
    text(30,23,"f",cex=2,xpd=NA, adj=0)

    dev.copy2pdf(file=paste(RepOut,"FigureS2.pdf",sep=''))
    

    ## OUTPUT ESTIMATES FOR LATEX table.
    
    sink("scenarioparameters.txt")
    cat("GAN\n\n"); 
    cat("$\\tau_{G}$ &", round(WTGAN$taug, digits=1)+startAtOne ,"&", round(GOFGAN$taug, digits=1)+startAtOne ,"&", round(CDKGAN$taug, digits=1)+startAtOne," \\\\\n")
    cat("$\\tau_{A}$ &", round(WTGAN$taua, digits=1)+startAtOne ,"&", round(GOFGAN$taua, digits=1)+startAtOne ,"&", round(CDKGAN$taua, digits=1)+startAtOne," \\\\\n")
    cat("$\\sigma_{G}$ &", round(WTGAN$sigmag, digits=1) ,"&", round(GOFGAN$sigmag, digits=1) ,"&", round(CDKGAN$sigmag, digits=1)," \\\\\n")
    cat("$\\sigma_{A}$ &", round(WTGAN$sigmaa, digits=1) ,"&", round(GOFGAN$sigmaa, digits=1) ,"&", round(CDKGAN$sigmaa, digits=1)," \\\\\n")
    cat("\n\n");

    cat("GANa\n\n"); 
    cat("$\\tau_{G}$ &", round(WTGANa$taug, digits=1)+startAtOne ,"&", round(GOFGANa$taug, digits=1)+startAtOne ,"&", round(CDKGANa$taug, digits=1)+startAtOne," \\\\\n")
    cat("$\\sigma_{G}$ &", round(WTGANa$sigmag, digits=1) ,"&", round(GOFGANa$sigmag, digits=1) ,"&", round(CDKGANa$sigmag, digits=1)," \\\\\n")
    cat("\n\n");

    cat("GAA\n\n"); 
    cat("$\\tau_{G}$ &", round(WTGAA$taug, digits=1)+startAtOne ,"&", round(GOFGAA$taug, digits=1)+startAtOne ,"&", round(CDKGAA$taug, digits=1)+startAtOne," \\\\\n")
    cat("$\\tau_{A}$ &", round(WTGAA$taua, digits=1)+startAtOne ,"&", round(GOFGAA$taua, digits=1)+startAtOne ,"&", round(CDKGAA$taua, digits=1)+startAtOne," \\\\\n")
    cat("$\\sigma_{G}$ &", round(WTGAA$sigmag, digits=1) ,"&", round(GOFGAA$sigmag, digits=1) ,"&", round(CDKGAA$sigmag, digits=1)," \\\\\n")
    cat("$\\sigma_{A}$ &", round(WTGAA$sigmaa, digits=1) ,"&", round(GOFGAA$sigmaa, digits=1) ,"&", round(CDKGAA$sigmaa, digits=1)," \\\\\n")
    cat("\n\n");


    cat("PN+fb\n\n"); 
    cat("$\\kappa_{pp}$ &", round(fbtaupp, digits=1),"\n")
    cat("$\\kappa_{nn}$ &", round(fbtaunn, digits=1),"\n")
    cat("$\\s_{pp}$ &", round(fbsigmapp, digits=1),"\n")
    cat("$\\s_{nn}$ &", round(fbtaunn, digits=1),"\n")
    cat("\n\n");

    cat("GAN+fb\n\n"); 
    cat("$\\kappa_{gan}$ &", round(commontau, digits=1),"\n")
    cat("$\\s_{gan}$ &", round(commonsigma, digits=1),"\n")
    cat("\n\n");
    sink()


}

if ("clones" %in% whatToDo)
    {
        sink("clonesResults.txt")
        ## nb of generations
        gene = 2;

        ## outputs (P,N)
        maxG = 2**gene;
        outputs = matrix(nrow=maxG+1,ncol=maxG+1,data=NA)
        outputsGAN = outputs
        outputsPN = outputs


        cat("GAN\n")
        ## alphas at 68 hpf
        alphaggg = 0.554
        alphaaan = alphaggg

        ## MC direct
        echo=0
        nr = 1000000; ## precision to the third decimal
        outputsGAN[] = 0;
        nullpop = c(0,0,0);
        Ptot = 0; Ntot = 0;
        for (r in 1:nr)
            {
                pop = c(1,0,0);
                if (echo) cat("\n");
                for (gen in 1:gene)
                    {
                        nextpop = nullpop;
                        nextpop[3] = pop[3];
                        if (pop[1]>0)
                            {
                                for (g in 1:pop[1])
                                    {
                                        if (runif(n=1)<alphaggg)
                                            {
                                                nextpop[1] = nextpop[1] +2; if (echo) cat("ggg\n");
                                            }
                                        else
                                            {
                                                nextpop[2] = nextpop[2] +1; if (echo) cat("gan\n");
                                                nextpop[3] = nextpop[3] +1;
                                            }
                                    }
                            }
                        if (echo) print(nextpop);
                        if (pop[2] > 0)
                            {
                                for (a in 1:pop[2])
                                    {
                                        if (runif(n=1)<alphaaan)
                                            {
                                                nextpop[2] = nextpop[2] +1; if (echo) cat("aan\n");
                                                nextpop[3] = nextpop[3] +1;
                                            }
                                        else
                                            {
                                                nextpop[3] = nextpop[3] +2; if (echo)  cat("ann\n");
                                            }
                                    }
                            }
                        if (echo) print(nextpop);
                        pop = nextpop;
                    }
                nP = pop[1] + pop[2];
                nN = pop[3];
                Ptot = Ptot + nP;
                Ntot = Ntot + nN;
                if (nP==1 && nN==1) stop(" 1,1 \n");
                outputsGAN[nP+1,nN+1] = outputsGAN[nP+1,nN+1]+1
            }
        outputsGAN[] = outputsGAN[]/sum(outputsGAN);
        cat("ggg = ",alphaggg,"\n");
        cat("aan = ",alphaaan,"\n\n");
        print(outputsGAN);
        
        Ptot2 = 0; for (p in 1:maxG+1) Ptot2 = Ptot2 + sum(outputsGAN[p,]*(p-1));
        Ntot2 = 0; for (n in 1:maxG+1) Ntot2 = Ntot2 + sum(outputsGAN[,n]*(n-1)); ## ok, same
        cat("Ptot=",Ptot/nr," Ntot=,",Ntot/nr,"\n")
        cat("% P = ",Ptot / (Ptot + Ntot),"\n");
        

        ## PN at same date
        cat("PN\n")
        alphapp = 0.4975;
        alphann = 0.135;
        alphapn = 1-(alphapp+alphann);
        
        outputsPN[] = 0;
        nullpop = c(0,0,0);
        Ptot = 0; Ntot = 0;
        for (r in 1:nr)
            {
                pop = c(1,0,0);
                if (echo) cat("\n");
                for (gen in 1:gene)
                    {
                        nextpop = nullpop;
                        nextpop[3] = pop[3];
                        if (pop[1]>0)
                            {
                                for (g in 1:pop[1])
                                    {
                                        ru = runif(n=1)
                                        if (ru<alphapp)
                                            {
                                                nextpop[1] = nextpop[1] +2; if (echo) cat("pp\n");
                                            }
                                        else 
                                            {
                                                if (ru<alphapp+alphann)
                                                    {
                                                        nextpop[3] = nextpop[3] +2;if (echo) cat("nn\n");
                                                    }
                                                else
                                                    {
                                                        nextpop[1] = nextpop[1] +1; if (echo) cat("pn\n");
                                                        nextpop[3] = nextpop[3] +1;
                                                    }
                                            }
                                        
                                    }
                            }
                        if (echo) print(nextpop);
                        pop = nextpop;
                    }
                nP = pop[1];
                nN = pop[3];
                Ptot = Ptot + nP;
                Ntot = Ntot + nN;
                outputsPN[nP+1,nN+1] = outputsPN[nP+1,nN+1]+1
            }
        outputsPN[] = outputsPN[]/sum(outputsPN);
        cat("\n");
        cat("pp = ",alphapp,"\n");
        cat("nn = ",alphann,"\n\n");
        print(outputsPN);
        
        Ptot2 = 0; for (p in 1:maxG+1) Ptot2 = Ptot2 + sum(outputsPN[p,]*(p-1));
        Ntot2 = 0; for (n in 1:maxG+1) Ntot2 = Ntot2 + sum(outputsPN[,n]*(n-1)); ## ok, same
        cat("Ptot=",Ptot/nr," Ntot=,",Ntot/nr,"\n")
        cat("% P = ",Ptot / (Ptot + Ntot),"\n");
        
        sink()
    }