salome.kernel 9.14.0.post6__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/kernel/salome_notebook.py

@@ -0,0 +1,183 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+#  File   : salome_notebook.py
+#  Author : Roman NIKOLAEV, Open CASCADE S.A.S.
+#  Module : SALOME
+#  $Header:
+#
+"""
+Module salome_notebook gives access to Salome Notebook.
+"""
+
+from salome.kernel import salome
+
+class PseudoStudyForNoteBook:
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        pass
+
+    def GetVariableNames(self):
+        return list(self.kwargs.keys())
+
+    def IsVariable(self, variableName):
+        return variableName in self.kwargs
+
+    def IsReal(self, variableName):
+        val = self.kwargs[variableName]
+        try:
+            float(val)
+            return True
+        except Exception:
+            pass
+        return False
+
+    IsInteger = IsReal
+    IsBoolean = IsReal
+
+    def IsString(self, variableName):
+        return not self.IsReal(variableName)
+
+    def GetString(self, variableName):
+        return self.kwargs[variableName]
+
+    def GetReal(self, variableName):
+        return float(self.kwargs[variableName])
+
+    GetInteger = GetReal
+    GetBoolean = GetReal
+
+    pass
+
+class NoteBook:
+
+    def __init__(self, theIsEnablePublish=True):
+        if theIsEnablePublish:
+            self.myStudy = salome.myStudy
+        else:
+            self.myStudy = PseudoStudyForNoteBook()
+
+    def set(self, variableName, variable):
+        """
+        Create (or modify) variable with name "variableName"
+        and value equal "theValue".
+        """
+        if isinstance(variable, float):
+            self.myStudy.SetReal(variableName, variable)
+
+        elif isinstance(variable, int):
+            self.myStudy.SetInteger(variableName, variable)
+
+        elif isinstance(variable, bool):
+            self.myStudy.SetBoolean(variableName, variable)
+
+        elif isinstance(variable, str):
+            self.myStudy.SetString(variableName, variable)
+
+    def get(self, variableName):
+        """
+        Return value of the variable with name "variableName".
+        """
+        aResult = None
+        if self.myStudy.IsVariable(variableName):
+
+            if self.myStudy.IsReal(variableName):
+                aResult = self.myStudy.GetReal(variableName)
+
+            elif self.myStudy.IsInteger(variableName):
+                aResult = self.myStudy.GetInteger(variableName)
+
+            elif self.myStudy.IsBoolean(variableName):
+                aResult = self.myStudy.GetBoolean(variableName)
+
+            elif self.myStudy.IsString(variableName):
+                aResult = self.myStudy.GetString(variableName)
+                aResult_orig = aResult
+                list_of_variables = self.myStudy.GetVariableNames()
+                list_of_variables.remove(variableName)
+                # --
+                # To avoid the smallest strings to be replaced first,
+                # the list is sorted by decreasing lengths
+                # --
+                list_of_variables.sort(key=str.__len__)
+                list_of_variables.reverse()
+                for name in list_of_variables:
+                    if aResult.find(name) >= 0:
+                        val = self.get(name)
+                        aResult = aResult.replace(name, "%s" % (val))
+                        pass
+                    pass
+                try:
+                    aResult = eval(aResult)
+                except Exception as e:
+                    msg = str(e)
+                    msg += "\n"
+                    msg += "A problem occurs while parsing "
+                    msg += "the variable %s " % (variableName.__repr__())
+                    msg += "with value %s ..." % (aResult_orig.__repr__())
+                    msg += "\n"
+                    msg += "Please, check your notebook !"
+                    raise Exception(msg)
+                pass
+
+        return aResult
+
+    def isVariable(self, variableName):
+        """
+        Return true if variable with name "variableName"
+        exists in the study, otherwise return false.
+        """
+        return self.myStudy.IsVariable(variableName)
+
+    def setAs(self, variableName, typ):
+        value = self.get(variableName)
+        value = float(typ(value))
+        self.myStudy.SetStringAsDouble(variableName, value)
+        return
+
+    def setAsReal(self, variableName):
+        self.setAs(variableName, float)
+        return
+
+    def setAsInteger(self, variableName):
+        self.setAs(variableName, int)
+        return
+
+    def setAsBool(self, variableName):
+        self.setAs(variableName, bool)
+        return
+
+    def check(self):
+        for variableName in self.myStudy.GetVariableNames():
+            self.get(variableName)
+            pass
+        return
+
+    pass
+
+
+def checkThisNoteBook(**kwargs):
+    note_book = NoteBook(False)
+    note_book.check()
+    return
+
+
+notebook = NoteBook()

salome/kernel/salome_psutil.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+'''
+SALOME utilities for process management.
+'''
+
+import os
+import psutil
+
+
+def getNumberOfCPUCores(): # pragma pylint: disable=invalid-name
+    '''
+    Get number of CPU cores in the calculation node.
+    :return Number of cores
+    '''
+    return psutil.cpu_count(logical=True)
+
+
+def loadOfCPUCores(script=None): # pragma pylint: disable=invalid-name
+    '''
+    Get a load of each CPU core in the calculation node.
+
+    A script to compute loads can be customized via `script` parameter.
+    In that case, the script must either set `cpu_loads` variable (which
+    should be of list type), or specify `getCPULoads()` function returning
+    list as result. In both cases, the list's size must be equal to the value
+    returning by method `getNumberOfCPUCores()`, and each value in this list
+    must be in range [0, 1], otherwise exception is raised.
+
+    If `script` is not specified, default implementation is used.
+
+    :param script Custom script to calculate loads
+    :return List that contains loads of each CPU core.
+    '''
+    if not script:
+        return [x/100 for x in psutil.cpu_percent(interval=None, percpu=True)]
+    cpu_loads, loc = None, {}
+    exec(script, globals(), loc) # pragma pylint: disable=exec-used
+    cpu_loads = loc['getCPULoads']() if 'getCPULoads' in loc else loc.get('cpu_loads')
+    if cpu_loads is None:
+        raise ValueError('Bad script. Specify `getCPULoads` function or `cpu_loads` variable')
+    if not isinstance(cpu_loads, (list, tuple)):
+        raise TypeError('Bad script. Result must be list or tuple.')
+    size = getNumberOfCPUCores()
+    if len(cpu_loads) != size:
+        raise ValueError('Bad script. Result is of incorrect length (must be {})'.format(size))
+    values = [i for i in cpu_loads if 0 <= i <= 1]
+    if len(values) != size:
+        raise ValueError('Bad script. Values are not in [0, 1] range')
+    return [i for i in cpu_loads]
+
+
+def getTotalPhysicalMemory(): # pragma pylint: disable=invalid-name
+    '''
+    Get total physical memory of the calculation node.
+    :return Size of physical memory, in megabytes.
+    '''
+    return int(psutil.virtual_memory().total/1024/1024)
+
+
+def getTotalPhysicalMemoryInUse(): # pragma pylint: disable=invalid-name
+    '''
+    Get used physical memory of the calculation node.
+    :return Size of used physical memory, in megabytes.
+    '''
+    return int(psutil.virtual_memory().used/1024/1024)
+
+
+def getTotalPhysicalMemoryInUseByMe(): # pragma pylint: disable=invalid-name
+    '''
+    Get physical memory occupied by the current process.
+    :return Size of physical memory, used by current process, in megabytes.
+    '''
+    process = psutil.Process(os.getpid())
+    memory_in_mb = int(process.memory_info().rss/1024/1024)
+    return memory_in_mb

salome/kernel/salome_pynode.py

@@ -0,0 +1,74 @@
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+#  File   : salome_pynode.py
+#  Author : Christian CAREMOLI, EDF
+#  Module : SALOME
+#  $Header$
+#
+"""
+ When imported this module adds to CORBA proxy (from PyNode type) automatic pickle and unpickle
+ of arguments and results when calling execute method. It also converts the SALOME exception into a standard python
+ exception
+"""
+import omniORB
+import pickle
+from . import SALOME
+from . import Engines
+
+class SmartPyNode(Engines._objref_PyNode):
+  def __init__(self):
+    Engines._objref_PyNode.__init__(self)
+
+  def execute(self,functionName,*args,**kws):
+    try:
+      args=pickle.dumps((args,kws),-1)
+      results=Engines._objref_PyNode.execute(self,functionName,args)
+      x=pickle.loads(results)
+      return x
+    except SALOME.SALOME_Exception as e:
+      raise ValueError(e.details.text)
+
+  def __getattr__(self,name):
+    """ a trick to be able to call directly a remote method by its name : no need to use execute"""
+    if name[0]== '_':
+      raise AttributeError(name)
+    def afunc(*args,**kws):
+      return self.execute(name,*args,**kws)
+    return afunc
+
+class SmartPyScriptNode(Engines._objref_PyScriptNode):
+  def __init__(self):
+    Engines._objref_PyScriptNode.__init__(self)
+
+  def execute(self,outargsname,*args,**kws):
+    #the tuple args are ignored
+    try:
+      args=pickle.dumps(((),kws),-1)
+      results=Engines._objref_PyScriptNode.execute(self,outargsname,args)
+      x=pickle.loads(results)
+      return x
+    except SALOME.SALOME_Exception as e:
+      raise ValueError(e.details.text)
+
+#Register the new proxy for PyNode
+omniORB.registerObjref(Engines._objref_PyNode._NP_RepositoryId, SmartPyNode)
+#Register the new proxy for PyScriptNode
+omniORB.registerObjref(Engines._objref_PyScriptNode._NP_RepositoryId, SmartPyScriptNode)
+

salome/kernel/salome_study.py

@@ -0,0 +1,347 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+#  File   : salome_study.py
+#  Author : Paul RASCLE, EDF
+#  Module : SALOME
+#  $Header$
+#
+from . import salome_kernel_utils
+from . import SALOMEDS
+from . import salome_iapp
+from .launchConfigureParser import verbose
+
+myStudy = None
+myStudyName = None
+
+#--------------------------------------------------------------------------
+
+def DumpComponent(SO, Builder,offset):
+  global myStudy
+  it = myStudy.NewChildIterator(SO)
+  while it.More():
+    CSO = it.Value()
+    a=offset*"--" + ">" + CSO.GetID()
+    find,AtName = Builder.FindAttribute(CSO, "AttributeName")
+    if find:
+      a=a+":"+AtName.Value()
+    find,AtIOR = Builder.FindAttribute(CSO, "AttributeIOR")
+    if find:
+      a=a+":"+AtIOR.Value()
+    find,RefSO = CSO.ReferencedObject()
+    if find:
+      a=a+":"+RefSO.GetID()
+    print(a)
+    DumpComponent(CSO, Builder,offset+2)
+    it.Next()
+
+#--------------------------------------------------------------------------
+
+def DumpStudy():
+    """
+    Dump a study, given the ior
+    """
+    global myStudy
+    itcomp = myStudy.NewComponentIterator()
+    Builder = myStudy.NewBuilder()
+    while itcomp.More():
+      SC = itcomp.Value()
+      name = SC.ComponentDataType()
+      print("-> ComponentDataType is " + name)
+      DumpComponent(SC,Builder, 1)
+      itcomp.Next()
+
+#--------------------------------------------------------------------------
+
+def IDToObject(id):
+    global myStudy
+    myObj = None
+    mySO = myStudy.FindObjectID(id);
+    if mySO is not None:
+        ok, anAttr = mySO.FindAttribute("AttributeIOR")
+        if ok:
+            AtIOR = anAttr._narrow(SALOMEDS.AttributeIOR)
+            if AtIOR.Value() != "":
+                myObj = orb.string_to_object(AtIOR.Value())
+    return myObj
+
+def ObjectToSObject(obj):
+    global myStudy
+    mySO = None
+    if obj is not None:
+        ior =  orb.object_to_string(obj)
+        if ior != "":
+            mySO = myStudy.FindObjectIOR(ior)
+    return mySO
+
+def ObjectToID(obj):
+    mySO = ObjectToSObject(obj)
+    if mySO:
+        return mySO.GetID()
+    return ""
+
+def IDToSObject(id):
+    global myStudy
+    mySO = myStudy.FindObjectID(id);
+    return mySO
+
+    #--------------------------------------------------------------------------
+
+def generateName(prefix = None):
+    import random;
+    int = random.randint(1,1000);
+    if prefix is None:
+        return "Study" + str(int)
+    else :
+        return prefix + str(int)
+
+    #--------------------------------------------------------------------------
+
+def PersistentPresentation(theSO, theWithID):
+    global myStudy
+    # put the sobject's content (with subchildren) to the string
+    aResult = ""
+    attrs = theSO.GetAllAttributes()
+    aLen = len(attrs)
+    anUncopied = 0
+    for a in range(0,aLen):
+        attr = attrs[a]
+        if isinstance(attr,SALOMEDS._objref_AttributeTreeNode):
+            anUncopied += 1
+        elif isinstance(attr,SALOMEDS._objref_AttributeTarget):
+            anUncopied += 1
+        elif isinstance(attr,SALOMEDS._objref_AttributeReal) or \
+             isinstance(attr,SALOMEDS._objref_AttributeInteger) or \
+             isinstance(attr,SALOMEDS._objref_AttributeName) or \
+             isinstance(attr,SALOMEDS._objref_AttributeComment) or \
+             isinstance(attr,SALOMEDS._objref_AttributePersistentRef) or \
+             isinstance(attr,SALOMEDS._objref_AttributeLocalID) or \
+             isinstance(attr,SALOMEDS._objref_AttributeUserID):
+            aResult += " attribute value: " + str(attr.Value())
+        elif isinstance(attr,SALOMEDS._objref_AttributeIOR):
+            aResult += " attribute: IOR"
+        elif isinstance(attr,SALOMEDS._objref_AttributeSequenceOfReal) or \
+             isinstance(attr,SALOMEDS._objref_AttributeSequenceOfInteger):
+            aResult += " Sequence: " + str(attr.CorbaSequence())
+        elif isinstance(attr,SALOMEDS._objref_AttributeDrawable):
+            aResult += " Drawable: " + str(attr.IsDrawable())
+        elif isinstance(attr,SALOMEDS._objref_AttributeSelectable):
+            aResult += " Selectable: " + str(attr.IsSelectable())
+        elif isinstance(attr,SALOMEDS._objref_AttributeExpandable):
+            aResult += " Expandable: " + str(attr.IsExpandable())
+        elif isinstance(attr,SALOMEDS._objref_AttributeOpened):
+            aResult += " Opened: " + str(attr.IsOpened())
+        elif isinstance(attr,SALOMEDS._objref_AttributeTextColor):
+            aResult += " TextColor: " + str(attr.TextColor())
+        elif isinstance(attr,SALOMEDS._objref_AttributeTextHighlightColor):
+            aResult += " TextHighlightColor: " + str(attr.TextHighlightColor())
+        elif isinstance(attr,SALOMEDS._objref_AttributePixMap):
+            aResult += " PixMap: " + str(attr.GetPixMap())
+        elif isinstance(attr,SALOMEDS._objref_AttributeTableOfInteger) or \
+             isinstance(attr,SALOMEDS._objref_AttributeTableOfReal):
+            aResult += " Table with title: " + attr.GetTitle()
+        elif isinstance(attr,SALOMEDS._objref_AttributePythonObject):
+            aResult += " PythonObject: " + attr.GetObject()
+
+    if theWithID:
+        aResult = "sobject: " + theSO.GetID() + " nbattrs: " + str(aLen - anUncopied) + aResult + '\n'
+    else:
+        aResult = " nbattrs: " + str(aLen - anUncopied) + aResult + '\n'
+    anIter = myStudy.NewChildIterator(theSO)
+    while anIter.More():
+        aResult += PersistentPresentation(anIter.Value(), theWithID)
+        anIter.Next()
+    return aResult
+
+    #--------------------------------------------------------------------------
+
+def GetTree(theSO):
+    # returns the document list tree (as list)
+    global myStudy
+    aResult = [theSO.GetID()]
+    anIter = myStudy.NewChildIterator(theSO)
+    while anIter.More():
+        aResult += GetTree(anIter.Value())
+        anIter.Next()
+    return aResult
+
+    #--------------------------------------------------------------------------
+
+def CheckCopyPaste(theSO, theInfo ,theComponentPaste):
+    global myStudy
+
+    aRoot = theSO
+    while aRoot.GetID() != "0:":
+        aRoot = aRoot.GetFather()
+    aTree = GetTree(aRoot)
+    aStudyPersist = PersistentPresentation(aRoot, 1)
+
+    if not myStudy.CanCopy(theSO):
+        raise RuntimeError("<CanCopy> for "+theInfo+" returns false")
+    
+    if not myStudy.Copy(theSO):
+        raise RuntimeError("<Copy> for "+theInfo+" returns false")
+
+    
+    if not myStudy.CanPaste(theSO):
+        raise RuntimeError("<CanPaste> for "+theInfo+" returns false")
+
+    # check: before paste study is not changed check
+    if aStudyPersist != PersistentPresentation(aRoot, 1):
+        raise RuntimeError("Study is changed before Paste calling for "+theInfo)
+    
+    aSObj = theSO
+    if theComponentPaste:
+        aSObj = theSO.GetFatherComponent()
+        theInfo = theInfo + "(paste for component)"
+    if myStudy.Paste(aSObj) == None:
+        raise RuntimeError("<Paste> for "+theInfo+" returns None object")
+    aNewTree = GetTree(aRoot)
+    aLen = len(aTree)
+    for a in range(0,aLen):
+        if aTree[a] != aNewTree[a]:
+            return myStudy.FindObjectID(aNewTree[a])
+        
+    if aLen < len(aNewTree):
+        return myStudy.FindObjectID(aNewTree[aLen])
+    
+    raise RuntimeError("After Copy calling the tree is not changed")
+    
+    #--------------------------------------------------------------------------
+
+def GetComponentVersion(theComponent, all_versions = False):
+    # returns the document list tree (as list)
+    global myStudy
+    props = myStudy.GetProperties()
+    stored_components = props.GetStoredComponents()
+    version = "no component data" # vsr: better raise an exception in this case?
+    if theComponent in stored_components:
+      if all_versions:
+        version = props.GetComponentVersions(theComponent)
+        for i in range(len(version)):
+          if not version[i]: version[i] = "unknown"
+          pass
+        pass
+      else:
+        version = props.GetComponentVersion(theComponent)
+        if not version: version = "unknown"
+        pass
+      pass
+    return version
+    
+    #--------------------------------------------------------------------------
+
+def FindFileInDataDir(filename):
+    import os
+    datadir = os.getenv("DATA_DIR")
+    if datadir is not None:
+        import string
+        dirs = string.split(datadir, ":")
+        for dir in dirs:
+            file = dir + "/" + filename
+            if os.path.exists(file):
+                return file;
+    datadir = os.getenv("KERNEL_ROOT_DIR") + "/examples/"
+    file = datadir + filename
+    if os.path.exists(file):
+        return file;
+
+    return None
+
+    #--------------------------------------------------------------------------
+
+def openStudy(theStudyPath):
+    global myStudy, myStudyName
+    myStudy.Open(theStudyPath)
+    myStudyName = myStudy._get_Name()
+
+    #--------------------------------------------------------------------------
+
+def salome_study_init_without_session(theStudyPath=None):
+    """
+    Performs only once study creation or connection.
+    optional argument : theStudyPath
+        None        : attach to the currently active single study;
+                      create new empty study if there is active study
+        <URL> (str) : open study with the given file name
+    """
+    global myStudy, myStudyName
+    global orb, lcc, naming_service, cm
+
+    if not myStudy:
+        import CORBA
+        orb = CORBA.ORB_init([''])
+
+        # get Study reference
+        from . import KernelDS
+        myStudy = KernelDS.myStudy()
+        pass
+
+    import types
+    if theStudyPath and isinstance(theStudyPath, (str, bytes)):
+        if isinstance(theStudyPath, bytes):
+            theStudyPath = str(theStudyPath, 'UTF8')
+        openStudy(theStudyPath)
+    else:
+        myStudy.Init()
+
+    myStudyName = myStudy._get_Name()
+
+    return myStudy, myStudyName
+
+    #--------------------------------------------------------------------------
+
+def salome_study_init(theStudyPath=None):
+    """
+    Performs only once study creation or connection.
+    optional argument : theStudyPath
+        None        : attach to the currently active single study;
+                      create new empty study if there is active study
+        <URL> (str) : open study with the given file name
+    """
+    global myStudy, myStudyName
+    global orb, lcc, naming_service, cm
+
+    if not myStudy:
+        orb, lcc, naming_service, cm, _, _, _ = salome_kernel_utils.salome_kernel_init()
+
+        # get Study reference
+        obj = naming_service.Resolve('/Study')
+        myStudy = obj._narrow(SALOMEDS.Study)
+        pass
+
+    import types
+    if theStudyPath and isinstance(theStudyPath, (str, bytes)):
+        if isinstance(theStudyPath, bytes):
+            theStudyPath = str(theStudyPath, 'UTF8')
+        openStudy(theStudyPath)
+    else:
+        myStudy.Init()
+
+    myStudyName = myStudy._get_Name()
+
+    return myStudy, myStudyName
+
+def salome_study_close():
+  global myStudy, myStudyName
+  myStudy, myStudyName = None, None