pydefx 9.14.0__py3-none-any.whl

pydefx/sample.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2019-2024 EDF
+#
+# 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
+#
+import csv
+from enum import Enum
+
+class SampleException(Exception):
+  pass
+
+class PointState(Enum):
+  """
+  Is the point evaluated?
+  """
+  NO    = 1
+  YES   = 2
+  ERROR = 3
+
+class Sample:
+  def __init__(self, input_names, output_names):
+    """
+    input_names  : the names and the order of input variables
+    output_names : the names and the order of output variables
+    """
+    if len(input_names) < 1 :
+      SampleException("A sample should have at least one input variable.")
+    self._input_names  = input_names
+    self._output_names = output_names
+    self._input={}
+    self._output={}   # {output_name:[output_values]}
+    self._messages=[] # list. Possible values in the list:
+                      #        None = point not evaluated,
+                      #          "" = results available, no error
+                      # "any string"= error message for that index.
+
+  def __iter__(self):
+    """
+    Iterator over input points.
+    """
+    return Dico_iter(self._input)
+
+  def inputIterator(self):
+    """
+    Iterate over input points.
+    """
+    return Dico_iter(self._input)
+
+  def setInputValues(self, inputDict):
+    """
+    Set the points to be evaluated.
+    inputDict is a dictionary with:
+      key : name of an input parameter
+      value : list of values for the key.
+    The lists of values should have the same size for all the keys.
+    Exemple :
+      mySample.setInputValues({ "x":[1,2,3], "y":[10,20,30]})
+    """
+    if len(inputDict) != len(self._input_names):
+      raise SampleException("Incorrect number of keys!")
+    size = None
+    for name in self._input_names:
+      if size is None:
+        size = len(inputDict[name])
+      else:
+        if size != len(inputDict[name]):
+          raise SampleException("Inconsistency in input variable sizes!")
+    self._input = inputDict
+    # Fill all results with None
+    self._messages = [ None for i in range(size)]
+    self._output.clear()
+    for name in self._output_names :
+      self._output[name] = [ None for i in range(size)]
+
+  def addResult(self, index, out_values, message):
+    """
+    Set the resut for a point.
+    Parameters :
+      index : index of the point to be set
+      out_values : dictionary with :
+           key : output parameter name
+           value : value to be set for this index
+      message : error message. An empty string means no error. Any other string
+           contains the error message.
+      If the message is not an empty string, out_values is ignored and all the
+      results for this point are set to None as the point is considered to be in
+      error.
+    """
+    if message is None:
+      message = ""
+    if message :
+      # case of error
+      for name in self._output_names :
+        self._output[name][index] = None
+    else:
+      for name in self._output_names :
+        self._output[name][index] = out_values[name]
+      
+    self._messages[index] = message
+
+  def getPointState(self, index):
+    """
+    Computation state of the point number index.
+    Possible states returned :
+      PointState.NO : The results are not available yet for this point.
+                      The point has not been evaluated yet.
+      PointState.ERROR : The point evaluation is finished but it failed.
+                      There are no values for the output parameters, but there
+                      is a message containing the error.
+      PointState.YES : The results are available for this point.
+    """
+    message = self._messages[index]
+    if message is None:
+      return PointState.NO
+    elif message:
+      return PointState.ERROR
+    else:
+      return PointState.YES
+
+  def findFirstId(self, in_values):
+    """
+    Find the index of the first point in the sample which contains exactly the
+    same input values as in in_values.
+    in_values is a dictionary with {name : value} of input variables in one
+    point.
+    """
+    if self._input_names is None or len(self._input_names) == 0 :
+      raise SampleException("List of input variables not defined.")
+    firstName = self._input_names[0]
+    maxSize = len(self._input[firstName])
+    curId = 0
+    foundId = -1
+    for curId in range(maxSize):
+      if self.isValidId(self, curId, in_values) :
+        foundId = curId
+        break
+    return foundId
+
+  def isValidId(self, idToCheck, inputToCheck):
+    """
+    Verify the input values at the idToCheck position are exactly the same as
+    the values in inputToCheck. Return True or False.
+    """
+    ok = True
+    try:
+      for name in self._input_names:
+        if self._input[name][idToCheck] != inputToCheck[name] :
+          ok = False
+          break
+    except:
+      ok = False
+    return ok
+
+  def checkId(self, idToCheck, inputToCheck):
+    """
+    Verify the input values at the idToCheck position are exactly the same as
+    the values in inputToCheck. Raise SampleException if it is not the case.
+    """
+    for name in self._input_names:
+      if not name in self._input:
+        raise SampleException(
+          "Variable name {} expected and not found ".format(name))
+      if self._input[name][idToCheck] != inputToCheck[name] :
+        raise SampleException(
+          "Expected value for variable {} is {} and found {}".format(name,
+                                                  self._input[name][idToCheck],
+                                                  inputToCheck[name]))
+
+  def getInputNames(self):
+    """
+    Return the list of input parameter names.
+    """
+    return self._input_names
+
+  def getOutputNames(self):
+    """
+    Return the list of output parameter names.
+    """
+    return self._output_names
+
+  def progressRate(self):
+    """
+    Return 1.0 - unevaluatedPoints / numberOfPoints
+    """
+    numberOfPoints = len(self._messages)
+    unevaluatedPoints = self._messages.count(None)
+    result = 0.0
+    if(numberOfPoints > 0):
+      result = 1.0 - unevaluatedPoints / numberOfPoints
+    return result
+
+  def getInput(self, name):
+    """
+    Get the list of values for an input parameter.
+    """
+    return self._input[name]
+
+  def getOutput(self, name):
+    """
+    Get the list of values for an output parameter.
+    """
+    return self._output[name]
+
+  def getMessages(self):
+    """
+    Get the list of messages where for any point we can have :
+      None - the point has not been evaluated yet.
+      "" (empty string) - evaluation ok, no error.
+      "any string" - error message.
+    """
+    return self._messages
+
+  def __str__(self):
+    result = ""
+    for name in self._input_names:
+      result += name+","
+    for name in self._output_names:
+      result += name+","
+    result += "messages\n"
+    for i in range(len(self._messages)):
+      for name in self._input_names:
+        result += repr(self._input[name][i]) +","
+      for name in self._output_names:
+        result += repr(self._output[name][i]) +","
+      result += str(self._messages[i])+"\n"
+    return result
+
+class Dico_iter:
+  """
+  >>> si=Dico_iter({"x":[1,2,3], "y":["a","b","c"]})
+  >>> for i in si:
+  >>>   print(i)
+  {'x': 1, 'y': 'a'}
+  {'x': 2, 'y': 'b'}
+  {'x': 3, 'y': 'c'}
+  """
+  def __init__(self, s):
+    self.iters={}
+    for k, v in s.items():
+      self.iters[k] = iter(v)
+
+  def __iter__(self):
+    return self
+
+  def __next__(self):
+    result = {}
+    for k,v in self.iters.items():
+      result[k] = next(v)
+    return result

pydefx/samplecsviterator.py

@@ -0,0 +1,191 @@
+# Copyright (C) 2019-2024 EDF
+#
+# 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
+#
+import csv
+import numbers
+import pickle
+import os
+
+class SampleIterator:
+  """
+  Iterator used to iterate over the input values of a sample, adding an order
+  number. The order number is the id you get as the first parameter of the
+  function addResult.
+  """
+  DATAFILE = "idefixdata.csv"
+  OUTPUTNAMESFILE = "idefixoutputnames.csv"
+  RESULTDIR = "idefixresult" # directory which contains all the result files
+  RESULTFILE = "idefixresult.csv" # main result file - values for every point
+  GLOBALFILE = "idefixglobal"     # global result - one value for the whole simulation
+  ERRORCOLUMN = "idefix_error"
+  IDCOLUMN ="idefix_id"
+  ESCAPE_CHAR = "@"   # prefix a value that needs particular save/load procedure
+  PICK_CHAR = "p"     # @p : csv value saved in another file using pickle
+
+  def __init__(self, directory=None):
+    if directory:
+      datapath = os.path.join(directory, SampleIterator.DATAFILE)
+      outputnamespath = os.path.join(directory, SampleIterator.OUTPUTNAMESFILE)
+      self.result_directory = os.path.join(directory, SampleIterator.RESULTDIR)
+      self.directory = directory
+    else:
+      datapath = SampleIterator.DATAFILE
+      outputnamespath = SampleIterator.OUTPUTNAMESFILE
+      self.result_directory = SampleIterator.RESULTDIR
+      self.directory = None
+    self.result_file = None
+    self.datafile = open(datapath, newline='')
+    self.data     = csv.DictReader(self.datafile, quoting=csv.QUOTE_NONNUMERIC)
+    self.inputnames = self.data.fieldnames
+    self.outputnames = _loadOutputNames(outputnamespath)
+    self.iterNb = -1
+
+  def __next__(self):
+    self.iterNb += 1
+    return self.iterNb, next(self.data)
+
+  def __iter__(self):
+    return self
+
+  def writeHeaders(self):
+    """
+    This function can be called before the first call to addResult in order to
+    write the names of the parameters in the result file.
+    """
+    if self.directory:
+      outputnamespath = os.path.join(self.directory,
+                                     SampleIterator.OUTPUTNAMESFILE)
+    else:
+      outputnamespath = SampleIterator.OUTPUTNAMESFILE
+    os.makedirs(self.result_directory, exist_ok=True)
+    resultpath = os.path.join(self.result_directory, SampleIterator.RESULTFILE)
+    result_columns = [SampleIterator.IDCOLUMN]
+    result_columns.extend(self.inputnames)
+    result_columns.extend(self.outputnames)
+    result_columns.append(SampleIterator.ERRORCOLUMN)
+    self.result_file = open(resultpath, 'w', newline='')
+    self.result_csv = csv.DictWriter( self.result_file,
+                                      fieldnames=result_columns,
+                                      quoting=csv.QUOTE_NONNUMERIC )
+    self.result_csv.writeheader()
+    self.result_file.flush()
+
+  def addResult(self, currentId, currentInput, currentOutput, currentError):
+    """
+    You need to call writeHeaders before the first call of this function.
+    currentId : int value
+    currentInput : dictionary {"input name":value}
+    currentOutput : result returned by _exec.  Can be a tuple, a simple value or
+    None in case of error.
+    currentError : string or None if no error
+    """
+    currentRecord = {}
+    currentRecord[SampleIterator.IDCOLUMN] = currentId
+    for name in self.inputnames:
+      currentRecord[name] = currentInput[name]
+    if currentError is None:
+      if len(self.outputnames) == 1 :
+        outputname = self.outputnames[0]
+        currentRecord[outputname] = _codeOutput(currentOutput,
+                                                currentId,
+                                                outputname,
+                                                self.directory)
+      elif len(self.outputnames) > 1 :
+        outputIter = iter(currentOutput)
+        for name in self.outputnames:
+          currentRecord[name] = _codeOutput(next(outputIter),
+                                            currentId,
+                                            name,
+                                            self.directory)
+    else:
+      for name in self.outputnames:
+        currentRecord[name] = None
+    currentRecord[SampleIterator.ERRORCOLUMN] = currentError
+    self.result_csv.writerow(currentRecord)
+    self.result_file.flush()
+
+  def terminate(self):
+    """
+    Call this function at the end of the simulation in order to close every
+    open files.
+    """
+    if not self.datafile is None:
+      self.datafile.close()
+      self.datafile = None
+    if not self.result_file is None:
+      self.result_file.close()
+      self.result_file = None
+
+# Private functions
+def _loadOutputNames(filepath):
+    outputnames = []
+    with open(filepath, "r") as namesfile:
+      for line in namesfile:
+        line = line.rstrip() # remove whitespaces at the end
+        outputnames.append(line)
+    return outputnames
+
+# Read and write results (output parameters)
+def _codeOutput(value, currentId, name, directory=None):
+  """
+  Define how a value should be saved.
+  value: object to be saved - value of a parameter
+  currentId: number of the current line (current point).
+  name: name of the parameter (name of the column in the csv file).
+  return: string to be saved in the csv file.
+  """
+  res = None
+  if isinstance(value, numbers.Number):
+    res = value
+  elif isinstance(value, str):
+    res = value
+    if res[0:1] == SampleIterator.ESCAPE_CHAR :
+      res = SampleIterator.ESCAPE_CHAR + res
+  else:
+    file_name = "idefixresult-{}-{}.pick".format(name, currentId)
+    res = SampleIterator.ESCAPE_CHAR + SampleIterator.PICK_CHAR + file_name
+    file_path = os.path.join(SampleIterator.RESULTDIR, file_name)
+    if directory :
+      file_path = os.path.join(directory, file_path)
+    with open(file_path, "wb") as f:
+      pickle.dump(value, f)
+  return res
+
+def _decodeOutput(obj, resultdir):
+  """
+  Decode a value read from the csv file.
+  obj: object to decode (string or number).
+  resultdir : directory which contains the result files
+  return: decoded object.
+  """
+  res = None
+  if isinstance(obj, numbers.Number):
+    res = obj
+  elif isinstance(obj, str):
+    res = obj
+    if res[0:1] == SampleIterator.ESCAPE_CHAR :
+      res = res[1:]
+      if res[0:1] == SampleIterator.ESCAPE_CHAR :# obj = @@string begins with@
+        pass
+      elif res[0:1] == SampleIterator.PICK_CHAR:# obj = @pidefixresult-x-1.pick
+        file_path = os.path.join(resultdir, res[1:])
+        with open(file_path, "rb") as f:
+          res = pickle.load(f)
+      else:
+        raise Exception("Unknown escape value:" + obj)
+  return res

pydefx/samplecsvmanager.py

@@ -0,0 +1,136 @@
+# Copyright (C) 2019-2024 EDF
+#
+# 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
+#
+import csv
+import inspect
+import os
+import pathlib
+from . import sample
+from . import samplecsviterator
+SampleIterator = samplecsviterator.SampleIterator
+
+class SampleManager:
+  """
+  The SampleManager is used by the study for reading and writing a sample from
+  and to the file system. This SampleManager uses the csv format.
+  The following services are needed by the study:
+  - write the sample on the local file system (prepareRun).
+  - know what files were written in order to copy them on the remote file system
+  (return value of prepareRun).
+  - know what files contain the result in order to bring them back from the
+  remote file system to the local one (getResultFileName).
+  - load the results from the local file system to a sample (loadResult).
+  - restore a sample from a local directory when you want to recover a job
+  launched in a previous session.
+  - the name of the module which contains the class SampleIterator in order to
+  iterate over the input values of the sample (getModuleName).
+  This name is written by the study in a configuration file and it is used by
+  the optimizer loop plugin.
+  """
+  def __init__(self):
+    pass
+
+  # Functions used by the study
+  def prepareRun(self, sample, directory):
+    """
+    Create a dump of the sample in the given directory.
+    sample: Sample object.
+    directory: path to a local working directory where all the working files are
+               copied. This directory should be already created.
+    Return a list of files to add to the input files list of the job.
+    """
+    datapath = os.path.join(directory, SampleIterator.DATAFILE)
+    with open(datapath, 'w', newline='') as csvfile:
+      writer = csv.DictWriter(csvfile,
+                              fieldnames=sample.getInputNames(),
+                              quoting=csv.QUOTE_NONNUMERIC )
+      writer.writeheader()
+      writer.writerows(sample.inputIterator())
+
+    outnamespath = os.path.join(directory, SampleIterator.OUTPUTNAMESFILE)
+    with open(outnamespath, 'w') as outputfile:
+      for v in sample.getOutputNames():
+        outputfile.write(v+'\n')
+    filename = inspect.getframeinfo(inspect.currentframe()).filename
+    install_directory = pathlib.Path(filename).resolve().parent
+    iteratorFile = os.path.join(install_directory, "samplecsviterator.py")
+    return [datapath,
+            outnamespath,
+            iteratorFile
+            ]
+
+  def loadResult(self, sample, directory):
+    """
+    The directory should contain a RESULTDIR directory with the result files.
+    The results are loaded into the sample.
+    Return the global result of the study which can be used by an insitu
+    computation.
+    """
+    resultdir = os.path.join(directory, SampleIterator.RESULTDIR)
+    datapath = os.path.join(resultdir, SampleIterator.RESULTFILE)
+    with open(datapath, newline='') as datafile:
+      data = csv.DictReader(datafile, quoting=csv.QUOTE_NONNUMERIC)
+      for elt in data:
+        index = int(elt[SampleIterator.IDCOLUMN]) # float to int
+        input_vals = {}
+        for name in sample.getInputNames():
+          input_vals[name] = elt[name]
+        output_vals = {}
+        for name in sample.getOutputNames():
+          output_vals[name] = samplecsviterator._decodeOutput(elt[name],
+                                                              resultdir)
+        try:
+          sample.checkId(index, input_vals)
+        except Exception as err:
+          extraInfo = "Error on processing file {} index number {}:".format(
+                                                datapath, str(index))
+          raise Exception(extraInfo + str(err))
+        sample.addResult(index, output_vals, elt[SampleIterator.ERRORCOLUMN])
+    return sample
+
+  def restoreSample(self, directory):
+    """ The directory should contain the files created by prepareRun. A new
+    sample object is created and returned from those files.
+    This function is used to recover a previous run.
+    """
+    sampleIt = SampleIterator(directory)
+    inputvalues = {}
+    for name in sampleIt.inputnames:
+      inputvalues[name] = []
+    for newid, values in sampleIt:
+      for name in sampleIt.inputnames:
+        inputvalues[name].append(values[name])
+    
+    result = sample.Sample(sampleIt.inputnames, sampleIt.outputnames)
+    result.setInputValues(inputvalues)
+    sampleIt.terminate()
+    return result
+
+  def getModuleName(self):
+    """
+    Return the module name which contains the class SampleIterator.
+    """
+    return "samplecsviterator"
+  
+  def getResultFileName(self):
+    """
+    Name of the file or directory which contains the result and needs to be
+    copied from the remote computer.
+    """
+    return SampleIterator.RESULTDIR
+

pydefx/schemas/idefix_pyschema.xml

@@ -0,0 +1,106 @@
+<?xml version='1.0' encoding='iso-8859-1' ?>
+<proc name="newSchema_1">
+   <type name="string" kind="string"/>
+   <struct name="Engines/dataref">
+      <member name="ref" type="string"/>
+   </struct>
+   <type name="bool" kind="bool"/>
+   <sequence name="boolvec" content="bool"/>
+   <type name="double" kind="double"/>
+   <sequence name="dblevec" content="double"/>
+   <objref name="file" id="file"/>
+   <type name="int" kind="int"/>
+   <sequence name="intvec" content="int"/>
+   <struct name="stringpair">
+      <member name="name" type="string"/>
+      <member name="value" type="string"/>
+   </struct>
+   <sequence name="propvec" content="stringpair"/>
+   <objref name="pyobj" id="python:obj:1.0"/>
+   <sequence name="seqboolvec" content="boolvec"/>
+   <sequence name="seqdblevec" content="dblevec"/>
+   <sequence name="seqintvec" content="intvec"/>
+   <sequence name="seqpyobj" content="pyobj"/>
+   <sequence name="stringvec" content="string"/>
+   <sequence name="seqstringvec" content="stringvec"/>
+   <container name="DefaultContainer">
+      <property name="container_kind" value="Salome"/>
+      <property name="attached_on_cloning" value="0"/>
+      <property name="container_name" value="FactoryServer"/>
+      <property name="name" value="localhost"/>
+   </container>
+   <container name="container0">
+      <property name="container_kind" value="Salome"/>
+      <property name="attached_on_cloning" value="0"/>
+   </container>
+   <optimizer name="OptimizerLoop0" nbranch="4" loopWeight="-1" lib="plugin.py" entry="myalgosync">
+      <remote name="Solver" elementaryWeight="-1">
+         <script><code><![CDATA[import pickle
+import traceback
+import importlib
+inputvals=pickle.loads(i0.encode())
+idefixstudy=importlib.import_module(studymodule)
+error=None
+result=None
+try:
+  result=idefixstudy._exec(**inputvals)
+except Exception as e:
+  error=str(e)
+  if not error :
+    error = "Exception " + repr(e)
+  traceback.print_exc()
+o0=pickle.dumps((error, result), protocol=0).decode()
+]]></code></script>
+         <load container="container0"/>
+         <inport name="i0" type="string"/>
+         <inport name="studymodule" type="string"/>
+         <outport name="o0" type="string"/>
+      </remote>
+   </optimizer>
+   <inline name="Initialisation">
+      <script><code><![CDATA[import json
+
+with open("idefixconfig.json", "r") as f:
+  config = json.load(f)
+nbbranches=config["nbbranches"]
+studymodule=config["studymodule"]
+
+prescript = None
+try:
+  with open("idefix_prescript.py") as f:
+    prescript = f.read()
+except FileNotFoundError:
+   pass
+if not prescript is None:
+  exec(prescript)
+]]></code></script>
+      <load container="DefaultContainer"/>
+      <outport name="nbbranches" type="int"/>
+      <outport name="studymodule" type="string"/>
+   </inline>
+   <control> <fromnode>Initialisation</fromnode> <tonode>OptimizerLoop0</tonode> </control>
+   <datalink control="false">
+      <fromnode>OptimizerLoop0</fromnode> <fromport>evalSamples</fromport>
+      <tonode>OptimizerLoop0.Solver</tonode> <toport>i0</toport>
+   </datalink>
+   <datalink control="false">
+      <fromnode>Initialisation</fromnode> <fromport>nbbranches</fromport>
+      <tonode>OptimizerLoop0</tonode> <toport>nbBranches</toport>
+   </datalink>
+   <datalink control="false">
+      <fromnode>Initialisation</fromnode> <fromport>studymodule</fromport>
+      <tonode>OptimizerLoop0.Solver</tonode> <toport>studymodule</toport>
+   </datalink>
+   <datalink control="false">
+      <fromnode>OptimizerLoop0.Solver</fromnode> <fromport>o0</fromport>
+      <tonode>OptimizerLoop0</tonode> <toport>evalResults</toport>
+   </datalink>
+   <parameter>
+      <tonode>OptimizerLoop0</tonode><toport>nbBranches</toport>
+      <value><int>4</int></value>
+   </parameter>
+   <presentation name="OptimizerLoop0" x="180.5" y="34.5" width="170" height="214" expanded="1" expx="180.5" expy="34.5" expWidth="170" expHeight="214" shownState="0"/>
+   <presentation name="OptimizerLoop0.Solver" x="8" y="120" width="158" height="90" expanded="1" expx="8" expy="120" expWidth="158" expHeight="90" shownState="0"/>
+   <presentation name="Initialisation" x="14" y="34" width="158" height="90" expanded="1" expx="14" expy="34" expWidth="158" expHeight="90" shownState="0"/>
+   <presentation name="__ROOT__" x="0" y="0" width="354.5" height="252.5" expanded="1" expx="0" expy="0" expWidth="354.5" expHeight="252.5" shownState="0"/>
+</proc>