X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_NoteBook.cxx;h=9572cbe4ce8d989668f73a7b5401bed78efa8338;hb=6239bbad3bbae7a33e21494c43df258cd49a7f99;hp=ffdb9b114350a9f1558be18b0062621be5871965;hpb=6c1ba1451cc732e7cf85f235141707740a972310;p=modules%2Fsmesh.git

diff --git a/src/SMESH_I/SMESH_NoteBook.cxx b/src/SMESH_I/SMESH_NoteBook.cxx
index ffdb9b114..9572cbe4c 100644
--- a/src/SMESH_I/SMESH_NoteBook.cxx
+++ b/src/SMESH_I/SMESH_NoteBook.cxx
@@ -23,6 +23,7 @@
 #include "SMESH_2smeshpy.hxx"
 #include "SMESH_NoteBook.hxx"
 #include "SMESH_Gen_i.hxx"
+#include "SMESH_PythonDump.hxx"
 
 #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
 #include <TColStd_SequenceOfAsciiString.hxx>
@@ -32,9 +33,9 @@
 #include <string>
 
 #ifdef _DEBUG_
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
 #else
-static int MYDEBUG = 0;
+static int MYDEBUG = 1;
 #endif
 
 using namespace std;
@@ -80,7 +81,10 @@ void ObjectStates::AddState(const TState &theState)
 //================================================================================
 TState ObjectStates::GetCurrectState() const
 {
-  return _states[_dumpstate];
+  if(_states.size() > _dumpstate)
+    return _states[_dumpstate];
+  TState empty;
+  return empty;
 }
 
 
@@ -113,6 +117,73 @@ TCollection_AsciiString ObjectStates::GetObjectType() const{
   return _type;
 }
 
+
+//================================================================================
+/*!
+ * \brief Constructor
+ */
+//================================================================================
+LayerDistributionStates::LayerDistributionStates():
+  ObjectStates("LayerDistribution")
+{
+}
+//================================================================================
+/*!
+ * \brief Destructor
+ */
+//================================================================================
+LayerDistributionStates::~LayerDistributionStates()
+{
+}
+
+
+//================================================================================
+/*!
+ * \brief AddDistribution
+ */
+//================================================================================
+void LayerDistributionStates::AddDistribution(const TCollection_AsciiString& theDistribution)
+{
+  _distributions.insert(pair<TCollection_AsciiString,TCollection_AsciiString>(theDistribution,""));
+}
+
+//================================================================================
+/*!
+ * \brief HasDistribution
+ */
+//================================================================================
+bool LayerDistributionStates::HasDistribution(const TCollection_AsciiString& theDistribution) const
+{
+  return _distributions.find(theDistribution) != _distributions.end();
+}
+
+//================================================================================
+/*!
+ * \brief SetDistributionType
+ */
+//================================================================================
+bool LayerDistributionStates::SetDistributionType(const TCollection_AsciiString& theDistribution,
+                                                  const TCollection_AsciiString& theType)
+{
+  TDistributionMap::iterator it = _distributions.find(theDistribution);
+  if(it == _distributions.end())
+    return false;
+  (*it).second = theType;
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief GetDistributionType
+ */
+//================================================================================
+TCollection_AsciiString LayerDistributionStates::
+GetDistributionType(const TCollection_AsciiString& theDistribution) const
+{
+  TDistributionMap::const_iterator it = _distributions.find(theDistribution);
+  return (it == _distributions.end()) ? TCollection_AsciiString() : (*it).second;
+}
+
 //================================================================================
 /*!
  * \brief Constructor
@@ -144,33 +215,335 @@ SMESH_NoteBook::~SMESH_NoteBook()
  * \retval TCollection_AsciiString - Convertion result
  */
 //================================================================================
-TCollection_AsciiString SMESH_NoteBook::ReplaceVariables(const TCollection_AsciiString& theString) const
-{
-  _pyCommand aCmd( theString, -1);
-  TCollection_AsciiString aMethod = aCmd.GetMethod();
-  TCollection_AsciiString aObject = aCmd.GetObject();
-  TVariablesMap::const_iterator it = _objectMap.find(aObject);
-  if(!aMethod.IsEmpty() && it != _objectMap.end() ) {
-    ObjectStates *aStates = (*it).second;
-    bool modified = false;
-    if(MYDEBUG)
-      cout<<"SMESH_NoteBook::ReplaceVariables :Object Type : "<<aStates->GetObjectType()<<endl;
-    if(aStates->GetObjectType().IsEqual("LocalLength")) {
-      if(aMethod == "SetLength") {
-        if(!aStates->GetCurrectState().at(0).IsEmpty() )
-          aCmd.SetArg(1,aStates->GetCurrectState().at(0));
-        aStates->IncrementState();
-      }
-      else if(aMethod == "SetPrecision") {
-        if(!aStates->GetCurrectState().at(1).IsEmpty() )
-          aCmd.SetArg(1,aStates->GetCurrectState().at(1));
-        aStates->IncrementState();
+void SMESH_NoteBook::ReplaceVariables()
+{
+  for(int i=0;i<_commands.size();i++) {
+    Handle(_pyCommand) aCmd = _commands[i];
+    TCollection_AsciiString aMethod = aCmd->GetMethod();
+    TCollection_AsciiString aObject = aCmd->GetObject();
+    TCollection_AsciiString aResultValue = aCmd->GetResultValue();
+    if(MYDEBUG) {
+      cout<<"Command before : "<< aCmd->GetString()<<endl;
+      cout<<"Method : "<< aMethod<<endl;
+      cout<<"Object : "<< aObject<<endl;
+      cout<<"Result : "<< aResultValue<<endl;
+    }
+    
+    // check if method modifies the object itself
+    TVariablesMap::const_iterator it = _objectMap.find(aObject);
+    if(it == _objectMap.end()) // check if method returns a new object
+      it = _objectMap.find(aResultValue);
+    
+    if(it == _objectMap.end()) { // check if method modifies a mesh using mesh editor
+      TMeshEditorMap::const_iterator meIt = myMeshEditors.find(aObject);
+      if(meIt != myMeshEditors.end()) {
+        TCollection_AsciiString aMesh = (*meIt).second;
+	it = _objectMap.find(aMesh);
       }
     }
-    return aCmd.GetString();
+    
+    if(it != _objectMap.end()) {
+      ObjectStates *aStates = (*it).second;
+      // Case for LocalLength hypothesis
+      if(aStates->GetObjectType().IsEqual("LocalLength") && aStates->GetCurrectState().size() >= 2) {
+        if(aMethod.IsEqual("SetLength")) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+        else if(aMethod.IsEqual("SetPrecision")) {
+          if(!aStates->GetCurrectState().at(1).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(1));
+          aStates->IncrementState();
+        }
+      }
+      
+      // Case for SegmentLengthAroundVertex hypothesis
+      else if(aStates->GetObjectType().IsEqual("SegmentLengthAroundVertex")
+              && aStates->GetCurrectState().size() >= 1) {
+        if(aMethod == "SetLength") {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+      }
+
+      // Case for Arithmetic1D and StartEndLength hypothesis
+      else if(aStates->GetObjectType().IsEqual("Arithmetic1D") || 
+              aStates->GetObjectType().IsEqual("StartEndLength")) {
+        if(aMethod == "SetLength" &&
+           aStates->GetCurrectState().size() >= 2) {
+          if(aCmd->GetArg(2) == "1" && !aStates->GetCurrectState().at(0).IsEmpty())
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          else if(!aStates->GetCurrectState().at(1).IsEmpty())
+            aCmd->SetArg(1,aStates->GetCurrectState().at(1));
+          aStates->IncrementState();
+        }
+      }
+      
+      //Case for Deflection1D hypothesis
+      else if(aStates->GetObjectType().IsEqual("Deflection1D")){
+        if(aMethod == "SetDeflection" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+      }
+      
+      // Case for LayerDistribution hypothesis (not finished yet)
+      else if(aStates->GetObjectType() == "LayerDistribution") {
+        if(aMethod == "SetLayerDistribution"){
+          LayerDistributionStates* aLDStates = (LayerDistributionStates*)(aStates);
+          aLDStates->AddDistribution(aCmd->GetArg(1));
+        }
+      }
+      
+      // Case for MaxElementArea hypothesis
+      else if(aStates->GetObjectType().IsEqual("MaxElementArea")){
+        if(aMethod == "SetMaxElementArea" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+      }
+
+      // Case for MaxElementVolume hypothesis
+      else if(aStates->GetObjectType().IsEqual("MaxElementVolume")){
+        if(aMethod == "SetMaxElementVolume" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+      }
+      // Case for NETGEN_Parameters_2D hypothesis
+      else if(aStates->GetObjectType().IsEqual("NETGEN_Parameters_2D")){
+        if(aMethod == "SetMaxSize" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+        else if(aMethod == "SetGrowthRate" && aStates->GetCurrectState().size() >= 2) {
+          if(!aStates->GetCurrectState().at(1).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(1));
+          aStates->IncrementState();
+        }
+        else if(aMethod == "SetNbSegPerEdge" && aStates->GetCurrectState().size() >= 3) {
+          if(!aStates->GetCurrectState().at(2).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(2));
+          aStates->IncrementState();
+        } 
+        else if(aMethod == "SetNbSegPerRadius" && aStates->GetCurrectState().size() >= 4) {
+          if(!aStates->GetCurrectState().at(3).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(3));
+          aStates->IncrementState();
+        } 
+      }
+
+      // Case for NumberOfLayers hypothesis
+      else if(aStates->GetObjectType().IsEqual("NumberOfLayers")){
+        if(aMethod == "SetNumberOfLayers" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          aStates->IncrementState();
+        }
+      }
+
+      // Case for NumberOfSegments hypothesis
+      else if(aStates->GetObjectType().IsEqual("NumberOfSegments")){
+        if(aMethod == "SetNumberOfSegments" && aStates->GetCurrectState().size() >= 1) {
+          if(!aStates->GetCurrectState().at(0).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(0));
+          if(aStates->GetCurrectState().size()==1)
+            aStates->IncrementState();
+        }
+        else if (aMethod == "SetScaleFactor" && aStates->GetCurrectState().size() >= 2) {
+          if(!aStates->GetCurrectState().at(1).IsEmpty() )
+            aCmd->SetArg(1,aStates->GetCurrectState().at(1));
+          aStates->IncrementState();
+        }
+      }
+      
+      else if(aStates->GetObjectType().IsEqual("Mesh")) {
+	TState aCurrentState = aStates->GetCurrectState();
+        int aCurrentStateSize = aCurrentState.size();
+	if(aMethod.IsEqual("Translate") ||
+           aMethod.IsEqual("TranslateMakeGroups") ||
+           aMethod.IsEqual("TranslateMakeMesh")) {
+          bool isVariableFound = false;
+          int anArgIndex = 0;
+          for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+            if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
+              anArgIndex = i+1;
+              break;
+            }
+          }
+          if(anArgIndex > 0) {
+	    if(aCurrentStateSize == 3) { // translation by dx, dy, dz
+	      for(int j = 0; j < aCurrentStateSize; j++) {
+		if(!aCurrentState.at(j).IsEmpty()) {
+		  isVariableFound = true;
+		  aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+		}
+	      }
+	    }
+	    else if(aCurrentStateSize == 6) { // translation by x1, x2, y1, y2, z1, z2
+	      isVariableFound = true;
+	      for(int j = 0; j < 3; j++) {
+		TCollection_AsciiString anArg = aCmd->GetArg(anArgIndex+j);
+		TCollection_AsciiString aValue1 = aCurrentState.at(2*j), aValue2 = aCurrentState.at(2*j+1);
+		bool aV1 = !aValue1.IsEmpty();
+		bool aV2 = !aValue2.IsEmpty();
+		double aValue, aCurrentValue = anArg.IsRealValue() ? anArg.RealValue() : 0;
+		if(aV1 && !aV2) {
+		  if(!GetReal(aValue1, aValue))
+		    aValue = 0;
+		  aValue2 = TCollection_AsciiString( aValue + aCurrentValue );
+		}
+		else if(!aV1 && aV2) {
+		  if(!GetReal(aValue2, aValue))
+		    aValue = 0;
+		  aValue1 = TCollection_AsciiString( aValue - aCurrentValue );
+		}
+		else if(!aV1 && !aV2) {
+		  aValue1 = TCollection_AsciiString( 0 );
+		  aValue2 = TCollection_AsciiString( aCurrentValue );
+		}
+		aCmd->SetArg(anArgIndex+j, aValue1 + ", " + aValue2 );
+	      }
+	    }
+          }
+          if(isVariableFound) {
+            TCollection_AsciiString aDim;
+	    if(aCurrentStateSize == 6)
+	      aDim = "6";
+            aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr"+aDim);
+            aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
+          }
+          aStates->IncrementState();
+        }
+	else if(aMethod.IsEqual("Rotate") ||
+		aMethod.IsEqual("RotateMakeGroups") ||
+		aMethod.IsEqual("RotateMakeMesh") ||
+		aMethod.IsEqual("RotationSweep") ||
+		aMethod.IsEqual("RotationSweepMakeGroups") ||
+		aMethod.IsEqual("Mirror") ||
+		aMethod.IsEqual("MirrorMakeGroups")) {
+	  bool isSubstitute = false;
+	  int anArgIndex = 0;
+	  for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+	    if(aCmd->GetArg(i).IsEqual("SMESH.AxisStruct")) {
+	      anArgIndex = i+1;
+	      break;
+	    }
+	  }
+	  if(anArgIndex > 0) {
+	    for(int j = 0; j < aCurrentStateSize; j++) {
+	      if(!aCurrentState.at(j).IsEmpty()) {
+		if(j < 6) // 0-5 - axis struct, 6 - angle (rotation & sweep), 7-8 - nbSteps and tolerance (sweep)
+		  isSubstitute = true;
+		aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+	      }
+	    }
+	  }
+	  if(isSubstitute)
+	    aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".AxisStructStr");
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("AddNode") ||
+		aMethod.IsEqual("MoveClosestNodeToPoint")) {
+	  for(int j = 0; j < aCurrentStateSize; j++) {
+	    if(!aCurrentState.at(j).IsEmpty())
+	      aCmd->SetArg(j+1, aCurrentState.at(j));
+	  }
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("MoveNode")) {
+	  for(int j = 0; j < aCurrentStateSize; j++) {
+	    if(!aCurrentState.at(j).IsEmpty())
+	      aCmd->SetArg(j+2, aCurrentState.at(j));
+	  }
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("ExtrusionSweep") ||
+		aMethod.IsEqual("ExtrusionSweepMakeGroups")) {
+	  bool isSubstitute = false;
+	  int anArgIndex = 0;
+	  for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+	    if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
+	      anArgIndex = i+1;
+	      break;
+	    }
+	  }
+	  if(anArgIndex > 0) {
+	    for(int j = 0; j < aCurrentStateSize; j++) {
+	      if(!aCurrentState.at(j).IsEmpty()) {
+		if(j < 3) // 0-2 - dir struct, 3 - number of steps
+		  isSubstitute = true;
+		aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+	      }
+	    }
+	  }
+	  if(isSubstitute) {
+            aCmd->SetArg(anArgIndex - 1, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
+            aCmd->SetArg(anArgIndex - 2, TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".DirStructStr");
+	  }
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("ExtrusionAlongPath") ||
+		aMethod.IsEqual("ExtrusionAlongPathMakeGroups") ||
+		/* workaround for a bug in the command parsing algorithm */
+		aCmd->GetString().Search("ExtrusionAlongPathMakeGroups") != -1) {
+	  int aNbAngles = aCurrentStateSize-3; // State looks like "Angle1:...:AngleN:X:Y:Z"
+	  bool isSubstitute = false;
+	  int anArgIndex = 0;
+	  for(int i = 1, n = aCmd->GetNbArgs(); i <= n; i++) {
+	    if(aCmd->GetArg(i).IsEqual("SMESH.PointStruct")) {
+	      anArgIndex = i-1-aNbAngles;
+	      break;
+	    }
+	  }
+	  if(anArgIndex > 0) {
+	    int j = 0;
+	    for(; j < aNbAngles; j++) {
+	      if(!aCurrentState.at(j).IsEmpty()) {
+		aCmd->SetArg(anArgIndex+j-1, aCurrentState.at(j));
+	      }
+	    }
+	    for(; j < aNbAngles+3; j++) {
+	      if(!aCurrentState.at(j).IsEmpty()) {
+		isSubstitute = true;
+		aCmd->SetArg(anArgIndex+j+2, aCurrentState.at(j));
+	      }
+	    }
+	  }
+	  if(isSubstitute)
+	    aCmd->SetArg(anArgIndex + aNbAngles + 1,
+			 TCollection_AsciiString(SMESH_2smeshpy::SmeshpyName())+".PointStructStr");
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("TriToQuad") ||
+		aMethod.IsEqual("Concatenate") ||
+		aMethod.IsEqual("ConcatenateWithGroups")) {
+	  if(aCurrentStateSize && !aCurrentState.at(0).IsEmpty())
+	    aCmd->SetArg(aCmd->GetNbArgs(), aCurrentState.at(0));
+	  aStates->IncrementState();
+	}
+	else if(aMethod.IsEqual("Smooth") ||
+		aMethod.IsEqual("SmoothParametric")) {
+	  int anArgIndex = aCmd->GetNbArgs() - 2;
+	  for(int j = 0; j < aCurrentStateSize; j++) {
+	    if(!aCurrentState.at(j).IsEmpty())
+	      aCmd->SetArg(anArgIndex+j, aCurrentState.at(j));
+	  }
+	  aStates->IncrementState();
+	}
+      }
+    }
+    if(MYDEBUG) {
+      cout<<"Command after: "<< aCmd->GetString()<<endl;
+    }
   }
-  
-  return theString;
+  //  ProcessLayerDistribution();
 }
 //================================================================================
 /*!
@@ -214,8 +587,12 @@ void SMESH_NoteBook::InitObjectMap()
       }
       if(MYDEBUG)
         cout<<"The object Type : "<<anObjType<<endl;
+      ObjectStates *aState = NULL;
+      if(anObjType == "LayerDistribution")
+        aState = new LayerDistributionStates();
+      else
+        aState = new  ObjectStates(anObjType);
       
-      ObjectStates *aState = new  ObjectStates(anObjType);
       for(int i = 0; i < aSections->length(); i++) {
         TState aVars;
         SALOMEDS::ListOfStrings aListOfVars = aSections[i];
@@ -236,3 +613,118 @@ void SMESH_NoteBook::InitObjectMap()
     }
   }
 }
+
+//================================================================================
+/*!
+ * 
+ */
+//================================================================================
+void SMESH_NoteBook::AddCommand(const TCollection_AsciiString& theString)
+{
+  if(MYDEBUG)
+    cout<<theString<<endl;
+  Handle(_pyCommand) aCommand = new _pyCommand( theString, -1);
+  _commands.push_back(aCommand);
+
+  if ( aCommand->GetMethod() == "GetMeshEditor" ) { // MeshEditor creation
+    myMeshEditors.insert( make_pair( aCommand->GetResultValue(),
+				     aCommand->GetObject() ) );
+  }
+}
+
+//================================================================================
+/*!
+ * 
+ */
+//================================================================================
+void SMESH_NoteBook::ProcessLayerDistribution()
+{
+  // 1) Find all LayerDistribution states
+  vector<LayerDistributionStates*> aLDS;
+  TVariablesMap::const_iterator it = _objectMap.begin();
+  for(;it != _objectMap.end();it++)
+    if(LayerDistributionStates* aLDStates = (LayerDistributionStates*)((*it).second)) {
+      aLDS.push_back(aLDStates);
+    }
+  
+  // 2) Initialize all type of 1D Distribution hypothesis
+  for(int i=0;i<_commands.size();i++){
+    for(int j =0;j < aLDS.size();j++){
+      TCollection_AsciiString aResultValue = _commands[i]->GetResultValue();
+      if(_commands[i]->GetMethod() == "CreateHypothesis" &&
+         aLDS[j]->HasDistribution(aResultValue)){
+        TCollection_AsciiString aType = _commands[i]->GetArg(1);
+        aType.RemoveAll('\'');
+        aLDS[j]->SetDistributionType(aResultValue,aType);
+      }
+    }
+  }
+  // 3) ... and replase variables ...
+
+  for(int i=0;i<_commands.size();i++){
+    for(int j =0;j < aLDS.size();j++){
+      TCollection_AsciiString anObject = _commands[i]->GetObject();
+
+      if(aLDS[j]->HasDistribution(anObject)) {
+        TCollection_AsciiString aType = aLDS[j]->GetDistributionType(anObject);
+        TCollection_AsciiString aMethod = _commands[i]->GetMethod();
+        if(aType == "LocalLength") {
+          if(aMethod == "SetLength") {
+            if(!aLDS[j]->GetCurrectState().at(0).IsEmpty() )
+              _commands[i]->SetArg(1,aLDS[j]->GetCurrectState().at(0));
+            aLDS[j]->IncrementState();
+          }
+          else if(aMethod == "SetPrecision") {
+            if(!aLDS[j]->GetCurrectState().at(1).IsEmpty() )
+              _commands[i]->SetArg(1,aLDS[j]->GetCurrectState().at(1));
+            aLDS[j]->IncrementState();
+          }
+        }
+      }
+    }
+  }
+}
+//================================================================================
+/*!
+ *  \brief Return result script
+ */
+//================================================================================
+TCollection_AsciiString SMESH_NoteBook::GetResultScript() const
+{
+  TCollection_AsciiString aResult;
+  for(int i=0;i<_commands.size();i++)
+    aResult+=_commands[i]->GetString()+"\n";
+  return aResult;
+}
+
+//================================================================================
+/*!
+ *  \brief Return value of the variable
+ */
+//================================================================================
+bool SMESH_NoteBook::GetReal(const TCollection_AsciiString& theVarName, double& theValue)
+{
+  bool ok = false;
+
+  SMESH_Gen_i *aGen = SMESH_Gen_i::GetSMESHGen();
+  if(!aGen)
+    return ok;
+
+  SALOMEDS::Study_ptr aStudy = aGen->GetCurrentStudy();
+  if(aStudy->_is_nil())
+    return ok;
+
+  TCollection_AsciiString aVarName = theVarName;
+  aVarName.RemoveAll('\"');
+
+  if(aVarName.IsEmpty())
+    return ok;
+
+  const char* aName = aVarName.ToCString();
+  if(aStudy->IsVariable(aName) && (aStudy->IsReal(aName) || aStudy->IsInteger(aName))) {
+    theValue = aStudy->GetReal(aVarName.ToCString());
+    ok = true;
+  }
+
+  return ok;
+}