structure Sim_{{group.name}} =
struct

fun putStrLn out str = 
    (TextIO.output (out, str);
     TextIO.output (out, "\n"))
    
fun putStr out str = 
    (TextIO.output (out, str))
    
    
fun showBoolean b = (if b then "1" else "0")
                    
                    
fun showReal n = 
    let open StringCvt
	open Real
    in
	(if n < 0.0 then "-" else "") ^ (fmt (FIX (SOME 12)) (abs n))
    end


fun timing (action) = 
    let
        val timer = Timer.startCPUTimer ()
        val result = action ()
        val times = Timer.checkCPUTimer timer
    in
        (result, Time.+ (#usr times, #sys times))
    end
                             

exception Index
exception Shape
fun dimVals [m,n] = (m,n) | dimVals _ = raise Shape

fun printProjectionSummary S k =
    List.app
        (fn (W) =>
            let
                val (m,n) = dimVals (SparseMatrix.shape W)
            in
                Loop.app (0, n,
                          fn (i) => 
                             let
                                 val sl = SparseMatrix.slice (W,k,i)
                                 val sln = SparseMatrix.sliceFoldi
                                               (fn (j,x,n) => n+1)
                                               0 sl
                                 val slsum = SparseMatrix.sliceFoldi
                                                 (fn (j,x,ax) => Real.+(ax,x))
                                                 0.0 sl
                             in
                                 putStrLn TextIO.stdOut
                                          ("column " ^ (Int.toString i) ^ 
                                           ": n = " ^ (Int.toString sln) ^
                                           ": mean = " ^ (Real.toString (Real./(slsum, (Real.fromInt sln)))))
                             end)
            end)
        S



fun start (tmax, N, S, D, DQ, Pn, initial_vector, frun, fspikes, finfo, out) =

let
    val sub = Unsafe.Real64Array.sub
    val isub = Unsafe.IntArray.sub
    val update = Unsafe.Real64Array.update

        
    fun netrun (DQ,t,state_vector) =
        let 
            val t_i = case {{group.name}}.TEQ.findMin DQ of
                          SOME (t,_) => t
                        | NONE => t+{{group.name}}.h

            val (I,DQ') = {{group.name}}.TEQ.nextEventsFold 
                                        (fn (t,_) => Real.<=(t,t_i),
                                         fn (t,(i,port,w),I) => 
                                            let 
                                                val im = IntMap.find (I, i)
                                                val im = case im of 
                                                             SOME m => IntMap.insert (m,port,(t,w))
                                                           | NONE => IntMap.singleton (port,(t,w))
                                            in
                                                IntMap.insert (I,i,im)
                                            end,
                                         IntMap.empty,
                                         DQ)
            
            val (state_vector_i, spikes_i) = frun (t_i,I) state_vector
            val (spike_i, log_spike_i) = fspikes spikes_i
                
            val _   = finfo (state_vector_i, out)

            val DQ'' = 
                List.foldl
                    (fn ((i,t,nv),dq) => 
                        (#2(ListPair.foldl
                                (fn (del,W,(port,dq)) =>
                                    let
                                        val sl = SparseMatrix.slice (W,1,i)
                                    in
                                        (port+1,
                                         SparseMatrix.sliceFoldi 
                                             (fn (j,x,dq) => 
                                                 let 
                                                     val tev = Real.+ (t,del)
                                                 in
                                                     {{group.name}}.TEQ.addEvent ((tev, (j,port,x)), dq)
                                                 end)
                                             dq sl)
                                    end)
                                (0,dq)
                                (D,S))
                    ))
                    DQ' spike_i


            val _ = 
                if not (List.null log_spike_i)
                then (putStr out ((showReal t_i) ^ " ");
                      TensorFile.intListLineWrite out (List.map (fn (i,_,n) => (i+1)) log_spike_i))
                else (putStrLn out ("# " ^ (showReal t_i)))
                         
                         
        in
            if t_i  > tmax
            then (putStrLn out "# All done!"; state_vector_i)
            else netrun (DQ'',t_i,state_vector_i)
        end
in
    netrun (DQ,0.0,initial_vector)
end

fun main (name,args) =
    let
        open {{group.name}}
        fun finfo (_,out) = ()
    in
        (let
            val     _ = putStrLn TextIO.stdOut ("starting fprojection...")
            val (S,t) = timing fprojection
            val     _ = putStrLn TextIO.stdOut ("fprojection took " ^ (Time.toString t) ^ " s")
            val out   = TextIO.openOut (label ^ ".dat")

{% for pop in dict (group.populations) %}
{% if group.statesample > 0 %}

            val _ = ({{pop.name}}_state_out := TextIO.openOut ("{{pop.name}}_state.dat"))

{% endif %}
{% if group.extsample > 0 %}

            val _ = ({{pop.name}}_ext_out := TextIO.openOut ("{{pop.name}}_ext.dat"))

{% endif %}
{% endfor %}

        in
            List.app (fn (s) => putStrLn out ("# " ^ s))
                     ([
                         label

                     ]);
            let
                val _     = putStrLn TextIO.stdOut ("starting simulation...")
                val (_,t) = timing (fn () => start ({{duration}}, N, S, D, DQ, Pn, initial, frun, fspikes, finfo, out))
            in
                putStrLn TextIO.stdOut ("simulation took " ^ (Time.toString t) ^ " s")
            end;
            
            TextIO.flushOut (out);
            TextIO.closeOut (out);

{% for pop in dict (group.populations) %}
{% if group.statesample > 0 %}

            TextIO.flushOut (!{{pop.name}}_state_out); 
            TextIO.closeOut (!{{pop.name}}_state_out);

{% endif %}
{% if group.extsample > 0 %}

            TextIO.flushOut (!{{pop.name}}_ext_out); 
            TextIO.closeOut (!{{pop.name}}_ext_out);

{% endif %}
{% endfor %}

           ()
        end)
    end
    

end

val _ = let val name = CommandLine.name()
	    val args = CommandLine.arguments()
	    val env  = Posix.ProcEnv.environ()
	in
	    Sim_{{group.name}}.main (name, args)
	end