/home/mark/model/software/ScrumPy/ScrumPy/Kinetic/CGen.py

Preamble = """
/*
Automatically generated c code from ScrumPy
Not recomended for human consumption !
*/
#include<math.h>
#include<stdlib.h>
#include <ScampiModelBase.h>

"""

MetNames = "MetNames"
RateNames= "RateNames"
ParamNames = "ParamNames"

MetVals = "MetVals"
DiffVals = "DiffVals"
RateVals = "RateVals"
ParamVals = "ParamVals"

DFA_Name = "DiffFunArray"
RFA_Name =  "RateFunArray"
CFA_Name = "ConsFunArray"

DiffFunArray =    "static double  (*  "+DFA_Name +"[])() "
RateFunArray =   "static double  (*  "+RFA_Name +"[])() "
ConsFunArray =  "static double  (*"  +CFA_Name + "[])() "


FuncPre = "Func_"
FuncPost = "(void){ return "


##def InitMD(md):
##    """ pre: md is a model descriptor
##      post: md can be used with all other functions in this module
##    """
##    cons = md.DepMets.keys()  # put dependendent metabolites at the end of the sm
##    cons.sort()
##    for con in cons:
##        md.sm.MakeLastRow(md.DepMets[con][0])
##

def TypeValMap(md):
    """ pre: md is a model descriptor
      post : return a dictionary mapping ids to MetVals, ParamVals or RateVals as appropriate
    """
    tvm = {}
    for met in md.sm.rnames:
        tvm[met] = MetVals
    for reac in md.sm.cnames:
        tvm[reac] = RateVals
    for param in md.Params:
        tvm[param] = ParamVals
    return tvm


       
def Str2CFun(Str, tm):
    """ pre: tm = TypeValMap
       post: returns str mapping identifiers to array values
    """
  
    for char in ["*", "/", "+", "-", "(", ")", ","]:
        Str = Str.replace(char, " "+char + " ")

    Str = Str.split()
    rv = ""

    for tok in Str:
        if tm.has_key(tok):
            tok = tm[tok] + "[" + tok + "]"
    
        rv += tok                       # no, leave it as it is

    rv += " ; } ;\n"
    
    return rv


def FuncArray(Name, funcs):
    
    rv  = "\n" + Name + "={"
    if len(funcs) !=0:
        for func in funcs[:-1]:
            rv += func + ","
        rv  += funcs[-1]
    return rv + " } ; \n"




def Quote(string):
    return '"' + string + '"'

def VecDecls(md):
    nMets = str(len(md.sm))
    nRates = str(len(md.sm.cnames))
    nParams = str(len(md.Params))
    rv =""
    for vec,n  in (MetVals, nMets), (DiffVals, nMets), (RateVals,nRates), (ParamVals,nParams):
        rv += 'double ' + vec+'[' + n + '] ;\n'
 
    return rv

def Enums(md):
    rv = "\n"
    #cons = md.ConsDic.keys()
    #cons.sort()
    enums = [md.sm.rnames, md.sm.cnames, md.Params]
    #if len(cons) >0:
    #    enums.append(cons)
    for enum in enums :
        rv += "enum { "
        for i in enum[:-1]:
            rv += i+", "
        rv += enum[-1] + " } ;\n"
    
    return rv

def NameArrays(md):
    rv = ""
    mets = md.sm.rnames
    rates = md.sm.cnames

    for Ars in (MetNames,mets),(RateNames,rates),(ParamNames,md.Params):
        rv += "const char *"+ Ars[0] + "[]={"
        for name in Ars[1][:-1]:
            rv += Quote(name)+','
        rv += Quote(Ars[1][-1])+ "};\n\n"
    return rv

def DiffEqns(md):
    
    funcs = []
    rv = ""
    diffdic = md.sm.Copy(float).ToDict()
    for met in md.sm.rnames:                  # musn't use diffdic.keys() - maintain order !
        func = FuncPre + met
        rv += "double " + func + FuncPost
        funcs.append(func)
        for reac,coeff in diffdic[met]:
            rv += "+" + str(coeff) + "*" + RateVals +"[" + reac +"]"
        rv += ";}\n"
        
    return rv + FuncArray(DiffFunArray, funcs)

def RateEqns(md):
    rv = ""
    funcs = []
    tm = TypeValMap(md)
    for reac in md.sm.cnames:
        func = FuncPre + reac
        funcs.append(func)
        rv +=  "double " + func + FuncPost
        rv += Str2CFun(md.KinDic[reac], tm)

    return rv + FuncArray(RateFunArray, funcs)
        

def ConsEqns(md):
    
    funcs = []
    rv = ""
    cons = md.ConsDic.keys()

    for con in cons:
        func = FuncPre + "CONS_"+con
        funcs.append(func)
        func += FuncPost
        rv += "double " + func + "("+ParamVals+"[" +md.conpard[con] +"]-(" 
        for name,val in md.ConsDic[con]:
            if val ==1:
                rv += "+" + MetVals + "[" + name + "]"
            else:
                rv += "+" + "(" + str(float(val)) + " * " + MetVals + "[" + name + "])"

        rv += " ) ); } \n\n"
        #rv += " ) / " + str(float(depcoeff)) + "); } \n\n"

    return rv + FuncArray(ConsFunArray, funcs)

def Struct(md):
    name = md.Model.ModelName
    structname = "Actual_" + name
    rv = "ScampiModel " + structname + "={\n"
    rv += Quote(name)+",\n"
    rv += str(len(md.sm.cnames)) +",\n"
    
    for s in RateNames, RFA_Name, RateVals:
        rv += s + ",\n"
        
    for v in len(md.sm), len(md.ConsDic), len(md.sm) -len(md.ConsDic):
        rv += str(v) + ",\n"
        
    for s in MetNames, DFA_Name, CFA_Name, DiffVals,MetVals:
        rv += s + ",\n"

    lp = str(len(md.Params))
    for s in lp, ParamNames, ParamVals:
        rv += s + ",\n"

    rv += "&" + name +"Time,\n0,\n0\n } ;\n"
    rv += "ScampiModel_ptr " + name + " =&" + structname + " ;\n"

    return rv