/home/mark/model/software/ScrumPy/ScrumPy/Model.py

"""

ScrumPy -- Metabolic Modelling with Python

Copyright Mark Poolman 1995 - 2002

 This file is part of ScrumPy.

    ScrumPy is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    ScrumPy is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with ScrumPy; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""


"""
ScrumPy - a package of modules for doing Structural and Kinetic metabolic modelling
and related activities
"""

import os,sys,random                                     #system imports




                                                          # ScrumPy imports
from BasicInfo import Location, HeaderPath, Version, Banner

from Util import Seq, File,Types,Set,ErrRep
from Parser import  Parser, SBML
from Data import DataSets

from Structural.Model import Model as StruMod                              # import structural components

import Kinetic
from Kinetic.Model import Param,  Conc,  Vel,  dMet
from Kinetic.Model import Model as KinMod

ToolBox="Tools"
# A place for the user to keep common modules related to the model.
# See model.__init__()

gui = None

def Init(TheGui):
    global gui
    gui  = Kinetic.Model.gui = TheGui
    print "\n", Banner     # hello, punters


def GetPath(FileName):

    path = os.sep.join(FileName.split(os.sep)[:-1])

    if path =="" or path == ".":
        path = "./"

    elif not (path[0] == "/"):
        path = "./"+ path

    return path + os.sep


class Model(StruMod, KinMod):

    FileName = "No File"
    DefaultOptDic = {
        "ElType"         : Types.ArbRat,       # default options for directives
        "AutoExtern"     : False,          # parser can change these
        "AutoDuplicateR" : False,
        "PolymerCheck"   : "None",
        "UseKinetics"    : True, # self.WithKin  # according to input
        "DeQuote"        : False
    }


    def __init__(self, FName=None, AskUser=True, WithKin=True,ExtOnly=False, Child=False, Path=None):

        self.Parent = None
        self.HasParent=Child  # bool, i.e. if we are a child,  we must have a parent, unkown  at this point
        self.Children=[]
        self.WithKin = WithKin

        FName = self.GetFileName(FName, AskUser)
        if FName==None:
            gui.ErrorMsg("No input file !\nModel not usable")
        else:

            if Child:
                FName = Path+FName
            else:
                Path = GetPath(FName)
                sys.path.append(os.sep.join((Path,  ToolBox)))

            self.Path = Path # ie childen get path from parent, parent works it out for themself - Parser.Parser.Include

            if not os.path.exists(FName):
                open(FName,"w") # if it doesn't exist create it

            if SBML.LooksLikeSBML(FName):            # if it's sbml,  convert into ScrumPy and read that.
                spyf = SBML.SFNameToSpy(FName)   # name of the ScrumPy file
                errs = SBML.SBML2Spy(FName, spyf)
                if len(errs)>0:
                    ErrRep("ScrumPy: Errors in sbml file\nProceed with caution")
                FName = spyf

            self.FileName = FName
            self.ReadFile() # otherwise treat as a ScrumPy text file
            #self.Edit()

        self.DynMons = []       # static and dynamic monitors,
        self.StatMons = []      # Added elsewhere
        self.Edit()


    def __repr__(self):
        return "ScrumPy.Model from "+self.FileName

    def GetFileName(self, FName, AskUser):
        if AskUser and FName==None:
            FName = gui.LoadFileName()
            if FName ==():          # no file name supplied
                self.WithKin=False  # so we can't use Kinetics
                gui.InfoMsg("Supply name of a model file to be created")
                FName = gui.SaveFileName() # try and open a new one

                if FName ==():
                    FName = None

        return FName


    def Raise(self, x=""):
        raise x

    def Usable(self):

        return self.WithKin and self.ParsedOK and KinMod.Usable(self)



    def Destroy(self):
        StruMod.Destroy(self)
        if self.Usable():
            KinMod.Destroy(self)

    def AddDynMonitor(self, mon=None, *args, **kwargs):
        if mon != None:
            self.DynMons.append(mon)
        else:
            mon = Kinetic.Model.Monitor(self,  *args, **kwargs)
            mon.SetPlotX("Time")
            self.DynMons.append(mon)
            return mon


    def AddStatMonitor(self,mon=None,  *args,  **kwargs):
        if mon != None:
            self.StatMons.append(mon)
        else:
            mon = Kinetic.Model.Monitor(self, *args,  **kwargs)
            self.StatMons.append(mon)
            return mon



    def TellDynMons(self, Tincr, NSteps):
        for mon in self.DynMons:
            try: mon.NewSim(Tincr, NSteps)
            except: pass  # we don't mind if mon doesn't have NewSim

    def UpdateDynMons(self):
        for mon in self.DynMons:
            mon.Update()


    def UpdateStatMons(self):
        for mon in self.StatMons:
            mon.Update()

    def Unregister(self, mon):
        if mon in self.StatMons:
            del self.StatMons[self.StatMons.index(mon)]

        if mon in self.DynMons:
            del self.DynMons[self.DynMons.index(mon)]

    def resetMons(self):

        if self.WithKin:

            if not self.Usable():  # if the c compilation has failed using mons will segfault
                for m in self.DynMons + self.StatMons:
                    self.Unregister(m)
                    try: m.destroy()
                    except: pass  # m may not have a destroy method, it's up to them

            else:
                bad = []
                for m in self.DynMons + self.StatMons:
                    try:
                        m.Reset()
                    except:
                        bad.append(m)
                for b in bad:
                    self.Unregister(b)
                    try: b.destroy()
                    except: pass

    def destroyMons(self):
        for m in self.DynMons + self.StatMons:
            m.destroy()

        m.StatMons = []
        m.DynMons = []

    def Randomise(self, lorel=0.5, hirel=0.5, *args, **kwargs):

        for name,  val in self.ModelDesc.InitDic.items():
            self[name] = val * ( 1+random.uniform(-lorel, hirel))

        self.InitCSums()
        self.Eval()
        self.ResetInteg()



    def Simulate(self,TimeStep=None, NSteps=1,  MonData=None, MonFuncs=[]):

        self.TellDynMons(TimeStep, NSteps)

        if TimeStep:
            self.SetTincr(TimeStep)

        for n in range(NSteps):
            self.Sim(self,1)
            self.UpdateDynMons()
            for f in MonFuncs:
                f(self)

        self.UpdateStatMons()

        #self.LastTime = self["Time"]


    def FindSS(self,*args,**kwargs):
        KinMod.FindSS(self,*args,**kwargs)
        self.UpdateStatMons()





    def ReadFile(self):
        self.ModelName =  os.path.split(self.FileName)[1].split(".")[0]
        Input = open(self.FileName).read()

        ModelDesc = self.ModelDesc = Parser.ModelDescriptor()
        ModelDesc.FileName = self.FileName
        ModelDesc.Model = self

        ModelDesc.OptDic = dict(self.DefaultOptDic)

        Parser.Parse(Input,ModelDesc,Model)
        chdic={}
        self.LinkChildren(chdic)


        self.ParsedOK = len(self.ModelDesc.ErrList) ==0
        if not self.ParsedOK:
            self.ReportParseErrors()  # will set edit to highlight correct line
            self.WithKin=False       # failed to build, so we can't have inited kinetics
        else:
            if not self.HasParent:  # if we have a parent, leave  it all to them
                self.MergeChildren()
                if len(self.ModelDesc.ErrList) >0:
                    self.ReportParseErrors() # problem with one or more children
                else:
                    self.ModelDesc.PolymerCheck()
                    self.ReportWarnings()
                    self.BuildStructural()
                    self.WithKin = ModelDesc.OptDic["UseKinetics"]
                    if ModelDesc.OptDic["UseKinetics"]:
                        ModelDesc.sm = self.sm   # do we need this ??
                        if len(self.sm) ==0:
                            self.WithKin = ModelDesc.OptDic["UseKinetics"] = False
                        else:
                            KinMod.__init__(self) # don't try to init an empty model






    def MergeChildren(self):

        descendents =  self.GetDescendents()

        for mod in descendents:
            if not mod.ParsedOK:
                self.ModelDesc.ErrList.append((
                    "Errors in included model  ",
                    -1,
                    mod.FileName,
                    ""))


        if len(self.ModelDesc.ErrList) == 0:
            for mod in descendents:
                self.ModelDesc.Merge(mod.ModelDesc)






    def OldLinkChildren(self,seen=[]):

        self.Children = self.ModelDesc.Children

        for ch in self.Children:
            if ch in seen:
                sys.stderr.write("!\n! Multiple inclusion of  " + ch.FileName + " - ignoring  !\n!")
            else:
                ch.Parent = self
                seen.append(ch)
                ch.LinkChildren(seen)



    def LinkChildren(self,seen):

        self.Children = self.ModelDesc.Children

        for ch in self.Children:
            if seen.has_key(ch):
               seen[ch] += 1
            else:
                ch.Parent = self
                seen[ch]=1
                ch.LinkChildren(seen)



    def GetDescendents(self):
        """ pre: self.LinkChildren()
           post: return a list of all models included in self (excluding self) """

        rv = []
        for ch in self.Children:
            rv.append(ch)
            rv+= ch.GetDescendents()
        return rv


    def Edit(self, LineNo=None):

        if not self.HasParent:  # if we are a child let our parent take care of us
            if not hasattr(self, "EdWin"):
                self.EdWin = gui.EdWin(Model=self, Root=gui.root) # TODO: more checking on state of ed, tk vs wx etc.

            if gui.UIType == "wx":
                self.EdWin.OpenFile(self.FileName)
                for c in self.GetDescendents():
                    self.EdWin.OpenFile(c.FileName)

            else:    # ie old tk/idle interface
                if LineNo:
                    self.EdWin.gotoline(LineNo)
                for c in self.GetDescendents():
                    if hasattr(c, "EdWin"):
                        c.EdWin.close()
                    c.EdWin = gui.EdWin(c, Root=gui.root)





    def CheckXs(self, MetList, ExtList):
        rems = []
        for x in ExtList[:]:
            if not x in MetList:
                ExtList.remove(x)
                rems.append(x)
        if len(rems) >0:
            gui.WarnMsg("Metabolites declared external, but not used:" + str(rems))


    def Include(self, ModelFiles): # update ourself with any included models

        NotIncl = []  # models that were included but are no longer


        for mod in self.Included:
            if mod.FileName in ModelFiles:     # reload the models that we have seen before
                mod.Parent = None                    # make it independent from oursef first
                mod.Reload()                             # reload it
                mod.Parent = self                       # then reattach it
                ModelFiles.remove(mod.FileName)
            else:
                NotIncl.append(mod)               # these were included but are no more

        for mod in NotIncl:                           # destroy the models that we are no longer using
            self.Included.remove(mod)
            mod.EdWin._close()
            del mod

        for mfile in ModelFiles:                  # (try to) load models that haven't been previously included
            try:
                mod = Model(mfile)
                mod.Parent = self
                self.Included.append(mod)
            except:
                gui.WarnMsg("Couldn't include "+mfile+"(wrong filename ?)")


        for mod in self.Included:            # finally merge the included models with ourself
            self.MergeWith(mod)





    def MergeWith(self, mod):

        clash = {}

        def MergeMtx(m1, m2, clash):

            for col in m2.cnames:
                if col in m1.cnames:
                    clash[col] = 1
                else:
                    for row in m2.rnames:
                        el = m2[row,col]
                        if el != 0:
                            m1.NewEl(row,col,el)

        MergeMtx(self.sm, mod.sm, clash)
        MergeMtx(self.smexterns, mod.smexterns,clash)

        self.sm.Externs = self.smexterns.Externs = Set.Union(self.sm.Externs, mod.sm.Externs)
        if len(clash)>0:
            gui.WarnMsg("The following reactions were duplicated in included model "+mod.FileName+":" +str(clash.keys()) +":ignoring them")



    def Reload(self):

        if self.Parent != None:  # if we have been included by something else they must reload
            self.Parent.Reload() # and will reload us later
        else:
            if gui.UIType == "wx":
                self.EdWin.SaveFile()
                self.EdWin.CloseFile()

            else:
                try:
                    self.EdWin.wakeup()   # Throws an exception if user closed window via GUI
                    self.EdWin.SaveFile()
                except:
                    pass

                for ch in self.Children:
                    try:
                        ch.EdWin.SaveFile()
                        ch.EdWin.close()
                    except:
                        pass # usr may have closed the window !



            self.Destroy()
            self.ReadFile()
            self.Edit()
            self.resetMons()


    def ReportParseErrors(self,MaxRep=10):

        ErrList = self.ModelDesc.ErrList

        gui.ErrorMsg("Errors reading "+self.FileName+"\nFirst was " + ErrList[0][0] +"\nat or before line no. " + str(ErrList[0][1])+
                     '\nat or before: "'+ ErrList[0][2]+'"')
        for Err in ErrList[:MaxRep]:
            print Err[0], " at line ", Err[1],  '"', Err[2], '"'
        lerr = len(ErrList)
        if lerr > MaxRep:
                print "A further ", MaxRep - lerr, " errors not reported"
        #self.Edit(ErrList[0][1])


    def ReportWarnings(self):
        msg = self.ModelDesc.WarningsAsStr()
        print msg
        if msg !="":
            gui.WarnMsg(msg)




    def PostParseErrChk(self, FunList, IniDic, ErrList,OptDic):

        for fun in FunList:
            name,line = fun[0],fun[1]
            if name in self.sm.cnames:
                ErrList.append((" reaction used as function", line,name, None))
            if name in self.sm.rnames:
                ErrList.append((" metabolite used as function", line,name, None))
            else:
                if name in IniDic.keys():
                    ErrList.append((" parameter used as function", line,name, None))

        if len(self.sm.rows) == 0 and len(OptDic["Include"]) ==0:
            ErrList.append((" no internal metabolites ", -1, "", None))

    def ReportLastError(self):
        print "ReportLastError",self.ModelName +" : " +self.ErrorMsg()
        gui.ErrorMsg(self.ModelName +" : " +self.ErrorMsg())


    def AddReactions(self, *args, **kwargs):

        print "ScrumPy.Model.AddReactions() due for removal"

        if self.WithKin:
            raise exceptions.AtributeError, "can't add reactions to kinetic models (yet)"
        StruMod.AddReactions(self, *args,**kwargs)





    def SaveSBML(self,fname=None):
        SBML.Spy2SBML(self,fname)