mload.py

# mload.py ---
#
# Filename: mload.py
# Description:
# Author: Subhasis
# Maintainer:HarshaRani
# Created: Fri Feb  8 09:38:40 2013 (+0530)
# Version:
# Last-Updated: Wed Oct 5 15:16:35 2017 (+0530)
#           By: HarshaRani
#     Update #: 213
# URL:
# Keywords:
# Compatibility:
#
#

# Commentary:
#
# Utility to load models and detect filetype.
#
#

# Change log:
#
#
#
#
# This program 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 3, or
# (at your option) any later version.
#
# This program 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 this program; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street, Fifth
# Floor, Boston, MA 02110-1301, USA.
#
#

# Code:
'''
Oct 5 : check is made for kkit model
        -- Atleast one compartment should exists
        -- Atleast 2 pool should exists
Oct 4 : clean up for python3
'''
import moose
from moose import neuroml
import mtypes
from mexception import FileLoadError
import posixpath
from os.path import basename
from os.path import splitext
from PyQt4 import QtGui, QtCore, Qt
from plugins.setsolver import *
from moose.SBML import *
from plugins.kkitOrdinateUtil import *
import moose._moose as moose
import moose.utils as mutils
def loadGenCsp(target,filename,solver="gsl"):
    target = target.replace(" ", "")
    path = '/'+target
    #Moving the model under /modelname/model and graphs under /model/graphs.
    #This is passed while loading-time which will be easy for setting the stoich path
    mpath = '/'+target+'/'+"model"
    if moose.exists(mpath):
        moose.delete(mpath)
    modelpath1 = moose.Neutral('%s' %(target))
    modelpath = moose.Neutral('%s/%s' %(modelpath1.path,"model"))
    model = mutils.loadModel(filename, modelpath.path,solver)
    
    if not moose.exists(modelpath1.path+'/data'):
        graphspath = moose.Neutral('%s/%s' %(modelpath1.path,"data"))
    dataPath = moose.element(modelpath1.path+'/data')
    i =0
    nGraphs = moose.wildcardFind(modelpath.path+'/graphs/##[TYPE=Table2]')
    for graphs in nGraphs:
        if not moose.exists(dataPath.path+'/graph_'+str(i)):
            graphspath = moose.Neutral('%s/%s' %(dataPath.path,"graph_"+str(i)))
        else:
            graphspath = moose.element(dataPath.path+'/graph_'+str(i))
        moose.move(graphs.path,graphspath)

    if len(nGraphs) > 0:
        i = i+1
    
    for moregraphs in moose.wildcardFind(modelpath.path+'/moregraphs/##[TYPE=Table2]'):
        if not moose.exists(dataPath.path+'/graph_'+str(i)):
            graphspath = moose.Neutral('%s/%s' %(dataPath.path,"graph_"+str(i)))
        else:
            graphspath = moose.element(dataPath.path+'/graph_'+str(i))
        moose.move(moregraphs.path,graphspath)
    if moose.exists(modelpath.path+'/info'):
        AnnotatorOld =  moose.element(modelpath.path+'/info')
        AnnotatorNew = moose.Annotator(modelpath1.path+'/info')
        AnnotatorNew.runtime = AnnotatorOld.runtime
        AnnotatorNew.solver = AnnotatorOld.solver
        moose.delete(AnnotatorOld)
    moose.delete(modelpath.path+'/graphs')
    moose.delete(modelpath.path+'/moregraphs')
    return(modelpath1,modelpath1.path)

def loadFile(filename, target, solver="gsl", merge=True):
    """Try to load a model from specified `filename` under the element
    `target`.

    if `merge` is True, the contents are just loaded at target. If
    false, everything is deleted from the parent of target unless the
    parent is root.

    Returns
    -------
    a dict containing at least these three entries:

    modeltype: type of the loaded model.

    subtype: subtype of the loaded model, None if no specific subtype

    modelroot: root element of the model, None if could not be located - as is the case with Python scripts
    """
    loaderror = ""
    num = 1
    libsfound = True
    model = '/'
    newTarget = target
    while moose.exists(newTarget):
        newTarget = target + "-" + str(num)
        num = num + 1
    target = newTarget
    istext = True
    with open(filename, 'rb') as infile:
        istext = mtypes.istextfile(infile)
    if not istext:
        print ('Cannot handle any binary formats yet')
        return None
    # parent, child = posixpath.split(target)
    # p = moose.Neutral(parent)
    # if not merge and p.path != '/':
    #     for ch in p.children:
    #         moose.delete(ch)
    try:
        modeltype = mtypes.getType(filename)
        subtype = mtypes.getSubtype(filename, modeltype)
    except KeyError:
        raise FileLoadError('Do not know how to handle this filetype: %s' % (filename))
    pwe = moose.getCwe()
    #self.statusBar.showMessage('Loading model, please wait')
    # app = QtGui.qApp
    # app.setOverrideCursor(QtGui.QCursor(Qt.Qt.BusyCursor)) #shows a hourglass - or a busy/working arrow
    if modeltype == 'genesis':
        if subtype == 'kkit' or subtype == 'prototype':
            model,modelpath = loadGenCsp(target,filename,solver)
            xcord,ycord = [],[]
            if moose.exists(moose.element(modelpath).path):
                process = True
                compt = len(moose.wildcardFind(modelpath+'/##[ISA=CubeMesh]'))
                if not compt:
                    loaderror = "Model has no compartment, atleast one compartment should exist to display the widget"
                    process = False
                else:
                    p = len(moose.wildcardFind(modelpath+'/##[ISA=PoolBase]'))
                    if p < 2:
                        loaderror = "Model has no pool, atleast two pool should exist to display the widget"
                        process = False
            if process:
                if moose.exists(moose.element(modelpath).path):
                    mObj = moose.wildcardFind(moose.element(modelpath).path+'/##[ISA=PoolBase]'+','+
                                              moose.element(modelpath).path+'/##[ISA=ReacBase]'+','+
                                              moose.element(modelpath).path+'/##[ISA=EnzBase]'+','+
                                              moose.element(modelpath).path+'/##[ISA=StimulusTable]')
                    for p in mObj:
                        if not isinstance(moose.element(p.parent),moose.CplxEnzBase):
                            xcord.append(moose.element(p.path+'/info').x)
                            ycord.append(moose.element(p.path+'/info').y)
                    recalculatecoordinatesforKkit(mObj,xcord,ycord)

                    for ememb in moose.wildcardFind(moose.element(modelpath).path+'/##[ISA=EnzBase]'):
                        objInfo = ememb.path+'/info'
                        #Enzyme's textcolor (from kkit) will be bgcolor (in moose)
                        if moose.exists(objInfo):
                            bgcolor = moose.element(objInfo).color
                            moose.element(objInfo).color = moose.element(objInfo).textColor
                            moose.element(objInfo).textColor = bgcolor
                    moose.Annotator(moose.element(modelpath).path+'/info').modeltype = "kkit"
                else:
                    print (" path doesn't exists")
                #moose.le(modelpath)
        else:
            print ('Only kkit and prototype files can be loaded.')
        
    elif modeltype == 'cspace':
            model,modelpath = loadGenCsp(target,filename)
            
            if moose.exists(modelpath):
                moose.Annotator((moose.element(modelpath).path+'/info')).modeltype = "cspace"
            addSolver(modelpath,'gsl')

    elif modeltype == 'xml':
        if subtype == 'neuroml':
            popdict, projdict = neuroml.loadNeuroML_L123(filename)
            # Circus to get the container of populations from loaded neuroml
            for popinfo in popdict.values():
                for cell in popinfo[1].values():
                    solver = moose.HSolve(cell.path + "/hsolve")
                    solver.target = cell.path
                    # model = cell.parent
                    # break
                # break


            # Moving model to a new location under the model name
            # model name is the filename without extension

            model   = moose.Neutral("/" + splitext(basename(filename))[0])
            element = moose.Neutral(model.path + "/model")
            if(moose.exists("/cells"))  : moose.move("/cells"  , element.path)
            if(moose.exists("/elec"))   : moose.move("/elec"   , model.path)
            if(moose.exists("/library")): moose.move("/library", model.path)

            # moose.move("cells/", cell.path)
        elif subtype == 'sbml':
            foundLibSBML_ = False
            try:
                import libsbml
                foundLibSBML_ = True
            except ImportError:
                pass
            if foundLibSBML_:
                if target != '/':
                    if moose.exists(target):
                        moose.delete(target)
                model,loaderror = mooseReadSBML(filename,target)
                if moose.exists(moose.element(model).path):
                    moose.Annotator(moose.element(model).path+'/info').modeltype = "sbml"
                addSolver(target,'gsl')
            libsfound = foundLibSBML_
    else:
        raise FileLoadError('Do not know how to handle this filetype: %s' % (filename))
    moose.setCwe(pwe) # The MOOSE loadModel changes the current working element to newly loaded model. We revert that behaviour

    # TODO: check with Aditya how to specify the target for
    # neuroml reader
    # app.restoreOverrideCursor()
    return {'modeltype': modeltype,
            'subtype': subtype,
            'model': model,
            'foundlib' : libsfound,
            'loaderror' : loaderror}


#
# mload.py ends here