Attachment #114660 for bug #155974

View | Details | Raw Unified | Return to bug 155974 | Differences between

and this patch

Lines 93-100 Link Here

(-)SMESH_SRC_3.2.2/doc/salome/gui/SMESH/files/importing_and_exporting_meshes.htm (-2 / +2 lines)
93	<h1>Importing and exporting meshes</h1>	93	<h1>Importing and exporting meshes</h1>
94		94
95	<p><img src="../i_blue.jpg" x-maintain-ratio="TRUE" width="30px" height="30px" border="0" class="img_whs1"> In MESH there is a functionality allowing importation/exportation	95	<p><img src="../i_blue.jpg" x-maintain-ratio="TRUE" width="30px" height="30px" border="0" class="img_whs1"> In MESH there is a functionality allowing importation/exportation
96	of meshes from <span style="font-weight: bold;"><B>MED</B></span>, <span style="font-weight: bold;"><B>UNV</B></span>	96	of meshes from <span style="font-weight: bold;"><B>MED</B></span> and <span style="font-weight: bold;"><B>UNV
97	format files. </p>	97	</B></span>(I-DEAS 10) format files. </p>
98		98
99	<p> </p>	99	<p> </p>
100		100

Lines 121-126 Link Here

(-)SMESH_SRC_3.2.2/idl/SMESH_Gen.idl (-1 / +3 lines)
121		121
122	/*!	122	/*!
123	* Create Mesh object importing data from given UNV file	123	* Create Mesh object importing data from given UNV file
		124	* (UNV supported version is I-DEAS 10)
124	*/	125	*/
125	SMESH_Mesh CreateMeshesFromUNV( in string theFileName )	126	SMESH_Mesh CreateMeshesFromUNV( in string theFileName )
126	raises ( SALOME::SALOME_Exception );	127	raises ( SALOME::SALOME_Exception );
Lines 169-175 Link Here
169	raises ( SALOME::SALOME_Exception );	170	raises ( SALOME::SALOME_Exception );
170		171
171	/*!	172	/*!
172	*	173	* Return indeces of faces, edges and vertices of given subshapes
		174	* within theMainObject
173	*/	175	*/
174	long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,	176	long_array GetSubShapesId( in GEOM::GEOM_Object theMainObject,
175	in object_array theListOfSubObjects )	177	in object_array theListOfSubObjects )





    /*!
     * Export Mesh to DAT, UNV and STL Formats
     * (UNV supported version is I-DEAS 10)
     */
    void ExportDAT( in string file )
      raises (SALOME::SALOME_Exception);


    /*!
     * If given element is node returns IDs of shape from position
     * If there is not node for given ID - returns -1
     * from SMESH_MeshEditor
     * If there is not element for given ID - returns -1
     */
    long GetShapeID(in long id);

    /*!
     * For given element returns ID of result shape after 
     * ::FindShape() from SMESH_MeshEditor
     * If there is not element for given ID - returns -1
     */
    long GetShapeIDForElem(in long id);

    /*!
     * Returns number of nodes for given element
     * If there is not element for given ID - returns -1
     */


    long AddNode(in double x, in double y, in double z);

    /*!
     *  Create edge both similar and quadratic (this is determed
     *  by number of given nodes).
     *  \param IdsOfNodes List of node IDs for creation of element.
     *  Needed order of nodes in this list corresponds to description
     *  of MED. This description is located by the following link:
     *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
     */
    long AddEdge(in long_array IDsOfNodes);

    /*!
     *  Create face both similar and quadratic (this is determed
     *  by number of given nodes).
     *  \param IdsOfNodes List of node IDs for creation of element.
     *  Needed order of nodes in this list corresponds to description
     *  of MED. This description is located by the following link:
     *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
     */
    long AddFace(in long_array IDsOfNodes);

    long AddPolygonalFace(in long_array IdsOfNodes);

    /*!
     *  Create volume both similar and quadratic (this is determed
     *  by number of given nodes).
     *  \param IdsOfNodes List of node IDs for creation of element.
     *  Needed order of nodes in this list corresponds to description
     *  of MED. This description is located by the following link:
     *   http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
     */
    long AddVolume(in long_array IDsOfNodes);

    /*!

Lines 41-47 Link Here

(-)SMESH_SRC_3.2.2/resources/SalomeApp.xml (-2 / +8 lines)
41	</section>	41	</section>
42	<section name="resources">	42	<section name="resources">
43	<!-- Module resources -->	43	<!-- Module resources -->
44	<parameter name="SMESH" value="${SMESH_ROOT_DIR}/share/salome/resources/smesh"/>	44	<parameter name="SMESH" value="${SMESH_ROOT_DIR}/share/salome/resources/smesh"/>
45	<parameter name="StdMeshers" value="${SMESH_ROOT_DIR}/share/salome/resources/smesh"/>	45	<parameter name="StdMeshers" value="${SMESH_ROOT_DIR}/share/salome/resources/smesh"/>
		46	<!-- NETGENPlugin and GHS3DPlugin -->
		47	<!-- Here the environment variables are used as case-sensitive, -->
		48	<!-- In GUI/src/SalomeApp/resources/SalomeApp.xml upper-case notation is used. -->
		49	<!-- As a result, both variants are acceptable. -->
		50	<parameter name="NETGENPlugin" value="${NETGENPlugin_ROOT_DIR}/share/salome/resources/netgenplugin"/>
		51	<parameter name="GHS3DPlugin" value="${GHS3DPlugin_ROOT_DIR}/share/salome/resources/ghs3dplugin"/>
46	</section>	52	</section>
47	</document>	53	</document>

Lines 987-995 Link Here

(-)SMESH_SRC_3.2.2/src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx (+2 lines)
987	}	987	}
988	catch(const std::exception& exc) {	988	catch(const std::exception& exc) {
989	INFOS("Follow exception was cought:\n\t"<<exc.what());	989	INFOS("Follow exception was cought:\n\t"<<exc.what());
		990	throw;
990	}	991	}
991	catch(...) {	992	catch(...) {
992	INFOS("Unknown exception was cought !!!");	993	INFOS("Unknown exception was cought !!!");
		994	throw;
993	}	995	}
994		996
995	myMeshId = -1;	997	myMeshId = -1;

Lines 66-72 Link Here

(-)SMESH_SRC_3.2.2/src/MEFISTO2/Rn.h (-1 / +9 lines)
66		66
67	//le type Z des nombres entiers relatifs	67	//le type Z des nombres entiers relatifs
68	//=========	68	//=========
69	typedef long int Z;	69	// 64-bit porting: "long" replaced with "int".
		70	// On 64-bit, C++ long type is 8 byte long. MEFISTO2D C code calls several Fortran subroutines passing
		71	// arguments of this type, however Fortran knows nothing about changed size of arguments,
		72	// therefore stack gets corrupted. With "int" used instead of "long", Fortran calls from C do no harm to the stack
		73	// After this modification, behavior on 32-bit platforms does not change: on all platforms supported by
		74	// SALOME 3, "int" and "long" have the same size of 4 bytes.
		75	//========
		76	//typedef long int Z;
		77	typedef int Z;
70		78
71	//le type R des nombres "reels"	79	//le type R des nombres "reels"
72	//=========	80	//=========

Lines 51-56 Link Here

(-)SMESH_SRC_3.2.2/src/OBJECT/Makefile.in (+1 lines)
51	LIB_CLIENT_IDL = SALOME_Exception.idl \	51	LIB_CLIENT_IDL = SALOME_Exception.idl \
52	SALOME_GenericObj.idl \	52	SALOME_GenericObj.idl \
53	SALOME_Comm.idl \	53	SALOME_Comm.idl \
		54	SALOME_Component.idl \
54	MED.idl \	55	MED.idl \
55	SMESH_Mesh.idl \	56	SMESH_Mesh.idl \
56	SMESH_Group.idl \	57	SMESH_Group.idl \





//=======================================================================
//function : IsApplicableHypotesis
//purpose  :
//=======================================================================

bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,


  // hypothesis
  switch ( theShapeType ) {
  case TopAbs_EDGE:
  case TopAbs_FACE:
  case TopAbs_SHELL:
  case TopAbs_SOLID:
    return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();

  case TopAbs_SHELL:
    // Special case for algorithms, building 2D mesh on a whole shell.
    // Before this fix there was a problem after restoring from study,
    // because in that case algorithm is assigned before hypothesis
    // (on shell in problem case) and hypothesis is checked on faces
    // (because it is 2D), where we have NO_ALGO state.
    // Now 2D hypothesis is also applicable to shells.
    return (theHypothesis->GetDim() == 2 || theHypothesis->GetDim() == 3);

//   case TopAbs_WIRE:
//   case TopAbs_COMPSOLID:
//   case TopAbs_COMPOUND:

        f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
        f.AndNot( SMESH_HypoFilter::Is( algo ));
        const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true );
        if (prevAlgo &&
            string(algo->GetName()) != string(prevAlgo->GetName()) )
          modifiedHyp = true;
      }

          f.And(    SMESH_HypoFilter::IsApplicableTo( _subShape ));
          f.AndNot( SMESH_HypoFilter::Is( algo ));
          const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true );
          if (prevAlgo &&
              string(algo->GetName()) != string(prevAlgo->GetName()) )
            modifiedHyp = true;
        }

Lines 51-59 Link Here

(-)SMESH_SRC_3.2.2/src/SMESHDS/SMESHDS_Group.hxx (-2 / +2 lines)
51		51
52	virtual SMDS_ElemIteratorPtr GetElements();	52	virtual SMDS_ElemIteratorPtr GetElements();
53		53
54	bool SMESHDS_Group::Add (const int theID);	54	bool Add (const int theID);
55		55
56	bool SMESHDS_Group::Remove (const int theID);	56	bool Remove (const int theID);
57		57
58	void Clear();	58	void Clear();
59		59





using namespace std;

//namespace{
  // Declarations
  //=============================================================
  void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,

	  if ( aFile.exists() )
	    aFile.remove();
	  SUIT_OverrideCursor wc;

	  try {
	    switch ( theCommandID ) {
	    case 125:
	    case 122:
	      aMesh->ExportToMED( aFilename.latin1(), toCreateGroups, aFormat );
	      break;
	    case 124:
	    case 121:
	      aMesh->ExportDAT( aFilename.latin1() );
	      break;
	    case 126:
	    case 123:
	      aMesh->ExportUNV( aFilename.latin1() );
	      break;
	    default:
	      break;
	    }
	  }
	  catch (const SALOME::SALOME_Exception& S_ex){
	    wc.suspend();
	    SUIT_MessageBox::warn1(SMESHGUI::desktop(),
				    QObject::tr("SMESH_WRN_WARNING"),
				    QObject::tr("SMESH_EXPORT_FAILED"),
				    QObject::tr("SMESH_BUT_OK"));
	    wc.resume();
	  }
	}
      }


    SMESHGUI::GetSMESHGUI()->updateObjBrowser();
  }
//}

extern "C" {
  Standard_EXPORT CAM_Module* createModule()

	  }
	}
      }
      
      // PAL13338 -->
      if ( ( theCommandID==301 || theCommandID==302 ) && !checkLock(aStudy) && !automaticUpdate() ) 
	SMESH::UpdateView();
      // PAL13338 <--

      if (anAction == SMESH::eErase) {
	SALOME_ListIO l1;

      }
      else
	aSel->setSelectedObjects( to_process );

      break;
    }


      LightApp_SelectionMgr* mgr = selectionMgr();
      SALOME_ListIO selected; mgr->selectedObjects( selected );

      SALOME_ListIteratorOfListIO it(selected);
      for(; it.More(); it.Next()) {
        Handle(SALOME_InteractiveObject) anIObject = it.Value();
	if(anIObject->hasEntry()) {
	  if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
	    anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
	  }
	}
      }
      break;
    }




// Copyright (C) 2005  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.
//
// 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

       SUBMESH_ON_SHELL_TAG   =8,
       SUBMESH_ON_SOLID_TAG   =9,
       SUBMESH_ON_COMPOUND_TAG=10 };

//================================================================================
/*!
 * \brief Constructor

    connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
    connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));

    if ( myToCreate )
      if ( myIsMesh ) myHelpFileName = "/files/constructing_meshes.htm";
      else myHelpFileName = "/files/constructing_submeshes.htm";
    else myHelpFileName = "files/reassigning_hypotheses_and_algorithms.htm";

          }
        }
      }
    }
  }
  return _PTR(SObject)();
}

      case GEOM::SOLID:
      case GEOM::SHELL:  shapeDim = 3; break;
      case GEOM::FACE:   shapeDim = 2; break;
      case GEOM::WIRE:
      case GEOM::EDGE:   shapeDim = 1; break;
      case GEOM::VERTEX: shapeDim = 0; break;
      default:

    {
      // if a submesh on the selected shape already exist, pass to submesh edition mode
      if ( _PTR(SObject) pSubmesh = getSubmeshByGeom() ) {
        SMESH::SMESH_subMesh_var sm =
          SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( pSubmesh );
        bool editSubmesh = ( !sm->_is_nil() &&
                             SUIT_MessageBox::question2( myDlg, tr( "SMESH_WARNING" ),

      }
    }
  }

  return true;
}


  const int nbColonsInMeshEntry = 3;
  bool isSubMesh = myToCreate ?
    !myIsMesh :
    myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ).contains(':') > nbColonsInMeshEntry;

  if ( isSubMesh )
  {


//================================================================================
/*!
 * \Brief Returns tab dimention
  * \param tab - the tab in the dlg
  * \param dlg - my dialogue
  * \retval int - dimention

                                        const int theType,
                                        const QString& theTypeName)
{
  // During a hypothesis creation we might need to select some objects.
  // Main dialog must not update it's own selected objects in this case.
  dlg()->deactivateAll();

  HypothesisData* aData = SMESH::GetHypothesisData(theTypeName.latin1());
  if (!aData)
    return;


//================================================================================
/*!
 * \brief access to hypothesis data
  * \param theDim - hyp dimension
  * \param theHypType - hyp type (Algo,MainHyp or AddHyp)
  * \param theIndex - index in the list


//================================================================================
/*!
 * \brief Creates and selects hypothesis of hypotheses set
 * \param theSetName - The name of hypotheses set
 */
//================================================================================


    for ( int aDim = SMESH::DIM_1D; aDim <= SMESH::DIM_3D; aDim++ ) {
      if ( !isAccessibleDim( aDim )) continue;

      // assign hypotheses
      for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ ) {
        int aHypIndex = currentHyp( aDim, aHypType );

Lines 173-178 Link Here

(-)SMESH_SRC_3.2.2/src/SMESHGUI/SMESH_msg_en.po (+4 lines)
173	msgid "SMESH_POLYEDRE_CREATE_ERROR"	173	msgid "SMESH_POLYEDRE_CREATE_ERROR"
174	msgstr "Polyedron creation error"	174	msgstr "Polyedron creation error"
175		175
		176	#Export mesh
		177	msgid "SMESH_EXPORT_FAILED"
		178	msgstr "Mesh export failed.\nProbably, there is not enough space on disk."
		179
176	#-------------------------------------------------------------------------	180	#-------------------------------------------------------------------------
177	# MEN	181	# MEN
178	#-------------------------------------------------------------------------	182	#-------------------------------------------------------------------------

Lines 426-443 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_I/SMESH_Gen_i.cxx (-8 / +17 lines)
426	myIsEmbeddedMode = theMode;	426	myIsEmbeddedMode = theMode;
427		427
428	if ( !myIsEmbeddedMode ) {	428	if ( !myIsEmbeddedMode ) {
429	bool raiseFPE;	429	//PAL10867: disable signals catching with "noexcepthandler" option
		430	char* envNoCatchSignals = getenv("NOT_INTERCEPT_SIGNALS");
		431	if (!envNoCatchSignals \|\| !atoi(envNoCatchSignals))
		432	{
		433	bool raiseFPE;
430	#ifdef _DEBUG_	434	#ifdef _DEBUG_
431	raiseFPE = true;	435	raiseFPE = true;
432	char* envDisableFPE = getenv("DISABLE_FPE");	436	char* envDisableFPE = getenv("DISABLE_FPE");
433	if (envDisableFPE && atoi(envDisableFPE))	437	if (envDisableFPE && atoi(envDisableFPE))
434	raiseFPE = false;	438	raiseFPE = false;
435	#else	439	#else
436	raiseFPE = false;	440	raiseFPE = false;
437	#endif	441	#endif
438	OSD::SetSignal( raiseFPE );	442	OSD::SetSignal( raiseFPE );
		443	}
		444	// else OSD::SetSignal() is called in GUI
439	}	445	}
440	// else OSD::SetSignal() is called in GUI
441	}	446	}
442		447
443	//=============================================================================	448	//=============================================================================
Lines 1095-1100 Link Here
1095	return myGen.Compute( myLocMesh, myLocShape);	1100	return myGen.Compute( myLocMesh, myLocShape);
1096	}	1101	}
1097	}	1102	}
		1103	catch ( std::bad_alloc& exc ) {
		1104	THROW_SALOME_CORBA_EXCEPTION( "Memory allocation problem",
		1105	SALOME::INTERNAL_ERROR );
		1106	}
1098	catch ( SALOME_Exception& S_ex ) {	1107	catch ( SALOME_Exception& S_ex ) {
1099	INFOS( "Compute(): catch exception "<< S_ex.what() );	1108	INFOS( "Compute(): catch exception "<< S_ex.what() );
1100	}	1109	}

Lines 327-332 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_I/SMESH_MEDSupport_i.cxx (+12 lines)
327		327
328	//=============================================================================	328	//=============================================================================
329	/*!	329	/*!
		330	* CORBA: get Nodes from file
		331	*/
		332	//=============================================================================
		333
		334	SALOME_MED::long_array * SMESH_MEDSupport_i::getNumberFromFile(
		335	SALOME_MED::medGeometryElement geomElement) throw(SALOME::SALOME_Exception)
		336	{
		337	return getNumber(geomElement);
		338	}
		339
		340	//=============================================================================
		341	/*!
330	* CORBA: Global Nodes Index (optionnaly designed by the user)	342	* CORBA: Global Nodes Index (optionnaly designed by the user)
331	* CORBA: ??????????????????????????????	343	* CORBA: ??????????????????????????????
332	*/	344	*/

Lines 66-71 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_I/SMESH_MEDSupport_i.hxx (+7 lines)
66	getNumber(SALOME_MED::medGeometryElement geomElement)	66	getNumber(SALOME_MED::medGeometryElement geomElement)
67	throw(SALOME::SALOME_Exception);	67	throw(SALOME::SALOME_Exception);
68		68
		69	/*!
		70	* Same function as getNumber.
		71	*/
		72	SALOME_MED::long_array *
		73	getNumberFromFile(SALOME_MED::medGeometryElement geomElement)
		74	throw(SALOME::SALOME_Exception);
		75
69	SALOME_MED::long_array * getNumberIndex()	76	SALOME_MED::long_array * getNumberIndex()
70	throw(SALOME::SALOME_Exception);	77	throw(SALOME::SALOME_Exception);
71		78




//#include "SMDS_ElemIterator.hxx"
#include "SMDS_VolumeTool.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_MeshEditor.hxx"

// OCCT Includes
#include <OSD_Path.hxx>

//=============================================================================
/*!
 * If given element is node returns IDs of shape from position
 * If there is not node for given ID - returns -1
 * from SMESH_MeshEditor
 * If there is not element for given ID - returns -1
 */
//=============================================================================


      return pos->GetShapeId();
  }

  return -1;
}


//=============================================================================
/*!
 * For given element returns ID of result shape after 
 * ::FindShape() from SMESH_MeshEditor
 * If there is not element for given ID - returns -1
 */
//=============================================================================

CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id)
{
  SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
  if ( aSMESHDS_Mesh == NULL )
    return -1;

  // try to find element
  const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
  if(!elem)
    return -1;

  //SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
  ::SMESH_MeshEditor aMeshEditor(_impl);
  int index = aMeshEditor.FindShape( elem );
  if(index>0)
    return index;

  return -1;
}






  /*!
   * If given element is node returns IDs of shape from position
   * If there is not node for given ID - returns -1
   * from SMESH_MeshEditor
   * If there is not element for given ID - returns -1
   */
  CORBA::Long GetShapeID(const CORBA::Long id);

  /*!
   * For given element returns ID of result shape after 
   * ::FindShape() from SMESH_MeshEditor
   * If there is not element for given ID - returns -1
   */
  CORBA::Long GetShapeIDForElem(const CORBA::Long id);

  /*!
   * Returns number of nodes for given element
   * If there is not element for given ID - returns -1
   */




#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
import geompy
import salome
import geompy
import smesh

import StdMeshers

#-----------------------------GEOM----------------------------------------




#-----------------------------SMESH-------------------------------------------
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# -- Init --
plane_mesh = salome.IDToObject( Id_face1)
smesh.SetCurrentStudy(salome.myStudy)

mesh = smesh.CreateMesh(plane_mesh)

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

id_mesh = salome.ObjectToID(mesh)
smeshgui.SetName( id_mesh, "Mesh_1")

# -- Init mesh --
plane_mesh = salome.IDToObject( Id_face1)

mesh = smesh.Mesh(plane_mesh, "Mesh_1")

print"---------------------Hypothesis and Algorithms"

#---------------- NumberOfSegments

numberOfSegment = 9

algoWireDes = mesh.Segment()
listHyp = algoWireDes.GetCompatibleHypothesis()
print algoWireDes.GetName()
algoWireDes.SetName("Ware descritisation")

hypNbSeg = algoWireDes.NumberOfSegments(numberOfSegment)
print hypNbSeg.GetName()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "Nb. Segments")


#--------------------------Max. Element Area
maxElementArea = 200

algoMef = mesh.Triangle()
hypArea200.SetMaxElementArea( maxElementArea )
print hypArea200.GetName()
print hypArea200.GetMaxElementArea()

smeshgui.SetName(salome.ObjectToID(hypArea200), "Max. Element Area")

print"---------------------Algorithms"

#----------------------------Wire discretisation
algoWireDes = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
listHyp = algoWireDes.GetCompatibleHypothesis()

print algoWireDes.GetName()
smeshgui.SetName(salome.ObjectToID(algoWireDes), "Ware descritisation")

#----------------------------Triangle (Mefisto)
algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
listHyp = algoMef.GetCompatibleHypothesis()

print algoMef.GetName()
algoMef.SetName("Triangle (Mefisto)")

hypArea200 = algoMef.MaxElementArea(maxElementArea)
print hypArea200.GetName()
print hypArea200.GetMaxElementArea()
smesh.SetName(hypArea200, "Max. Element Area")
mesh.AddHypothesis( plane_mesh, algoWireDes )  # Regular 1D/wire discretisation
mesh.AddHypothesis( plane_mesh, algoMef )      # MEFISTO 2D

smeshgui.SetName(salome.ObjectToID(algoMef), "Triangle (Mefisto)")

print "---------------------Compute the mesh"

ret = mesh.Compute()
print ret

salome.sg.updateObjBrowser(1)






import salome
import geompy
import smesh


#----------------------------------GEOM




#---------------------------------SMESH
# get smesh engine
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

# get SMESH GUI
smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

# create hypoteses
hypNbSeg1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg1.SetNumberOfSegments(18)
id_hypNbSeg1 = salome.ObjectToID(hypNbSeg1) 
smeshgui.SetName(id_hypNbSeg1, "NumberOfSegments 1");

hypNbSeg2 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg2.SetNumberOfSegments(34)
id_hypNbSeg2 = salome.ObjectToID(hypNbSeg2) 
smeshgui.SetName(id_hypNbSeg2, "NumberOfSegments 2");

# create algorithmes
algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
id_algoReg = salome.ObjectToID(algoReg)
smeshgui.SetName(id_algoReg, "Regular_1D");

# create the path mesh
mesh1 = smesh.Mesh(ellipse1, "Path Mesh")

algoReg1 = mesh1.Segment()
algoReg1.SetName("Regular_1D")
hypNbSeg1 = algoReg1.NumberOfSegments(18)
smesh.SetName(hypNbSeg1, "NumberOfSegments 1")
mesh1.AddHypothesis(ellipse1,hypNbSeg1)

# create the tool mesh
mesh2 = smesh.Mesh(ellipse2, "Tool Mesh")
algoReg2 = mesh2.Segment()
algoReg2.SetName("Regular_1D")
hypNbSeg2 = algoReg2.NumberOfSegments(34)
smesh.SetName(hypNbSeg2, "NumberOfSegments 2")
mesh2.AddHypothesis(ellipse2,algoReg)
mesh2.AddHypothesis(ellipse2,hypNbSeg2)

# compute meshes
mesh1.Compute()
mesh2.Compute()


# ---- udate object browser





import salome
import geompy
import smesh
import StdMeshers

# get smesh engine
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

# create points to build two circles
p1 = geompy.MakeVertex(0,  100,  0)

idcircle = geompy.addToStudy(circle, "Circle")
idface   = geompy.addToStudy(face,   "Circular face")


smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

# create hypoteses
hypNbSeg = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg.SetNumberOfSegments(12)
idseg = salome.ObjectToID(hypNbSeg) 
smeshgui.SetName(idseg, "NumberOfSegments_10");

hypArea = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypArea.SetMaxElementArea(30)
idarea = salome.ObjectToID(hypArea)
smeshgui.SetName(idarea, "MaxElementArea_20");

# create algorithmes
algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
idreg = salome.ObjectToID(algoReg)
smeshgui.SetName(idreg, "Regular_1D");

algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
idmef = salome.ObjectToID(algoMef)
smeshgui.SetName(idmef, "MEFISTO_2D");

# init a Mesh with the circular face
mesh1 = smesh.Mesh(face, "Mesh on circular face")

# set hypotheses and algos to the first mesh
numberOfSegments1 = 12
algoReg1 = mesh1.Segment()
algoReg1.SetName("Regular_1D")
hypNbSeg1 = algoReg1.NumberOfSegments(numberOfSegments1)
smesh.SetName(hypNbSeg1, "NumberOfSegments_" + str(numberOfSegments1))

maxElementArea = 30

algoMef = mesh1.Triangle()
algoMef.SetName("MEFISTO_2D")
hypArea = algoMef.MaxElementArea(maxElementArea)
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))


# init a Mesh with the second circle
mesh2 = smesh.Mesh(circle, "Mesh on circular edge")

numberOfSegments2 = 12
algoReg2 = mesh2.Segment()
algoReg2.SetName("Regular_1D")
hypNbSeg2 = algoReg2.NumberOfSegments(numberOfSegments2)
smesh.SetName(hypNbSeg2, "NumberOfSegments_" + str(numberOfSegments2))


# compute meshes
mesh1.Compute()
mesh2.Compute()

# ---- udate object browser
salome.sg.updateObjBrowser(1);




# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
import smesh
import SMESH
import math

def GetNewNodes(mesh,Elems,OldNodes):

            
    
# create empty mesh
mesh = smesh.Mesh()

ed = mesh.GetMeshEditor()
tol = 0.001

# create a cross from quadrangle faces
# 1. create first edge and make extrusion along 0x
n1 = mesh.AddNode(55,-5,0)
n2 = mesh.AddNode(55,5,0)
e1 = mesh.AddEdge([n1,n2])
dir1 = smesh.DirStruct(smesh.PointStruct(-10,0,0))
mesh.ExtrusionSweep([e1],dir1,11)
# 2. create second edge and make extrusion along 0y
n3 = mesh.AddNode(-5,-55,0)
n4 = mesh.AddNode(5,-55,0)
e2 = mesh.AddEdge([n3,n4])
dir2 = smesh.DirStruct(smesh.PointStruct(0,10,0))
mesh.ExtrusionSweep([e2],dir2,11)

# since result has coincident nodes and faces
# we have to make merge
nodes = mesh.FindCoincidentNodes(0.001)
mesh.MergeNodes(nodes)
mesh.MergeEqualElements()

# make extrusion faces along 0z
faces = mesh.GetElementsByType(smesh.FACE)
nbf = len(faces)
maxang = 2.0
zstep = 5
nbzsteps = 50
dir3 = smesh.DirStruct(smesh.PointStruct(0,0,zstep))
newfaces = [] # list for keeping created top faces
              # during extrusion

for i in range(0,nbzsteps):
    mesh.ExtrusionSweep(faces,dir3,1)
    # find top faces after each extrusion and keep them
    res = mesh.GetLastCreatedElems()
    nbr = len(res)
    nfaces = []
    for j in res:

    pass
    
# rotate faces from newfaces
axisr1 = smesh.AxisStruct(0,0,0,0,0,1)
for i in range(0,nbzsteps):
    ang = maxang*(1-math.cos((i+1)*math.pi/nbzsteps))
    mesh.Rotate(newfaces[i],axisr1,ang,0)


# create circles
# create two edges and rotate them for creation
# full circle
n5 = mesh.AddNode(65,0,0)
n6 = mesh.AddNode(67.5,0,0)
n7 = mesh.AddNode(70,0,0)
e56 = mesh.AddEdge([n5,n6])
e67 = mesh.AddEdge([n6,n7])
axisr2 = smesh.AxisStruct(65,0,0,0,1,0)
mesh.RotationSweep([e56,e67],axisr2, math.pi/6, 12, tol)
res = mesh.GetLastCreatedElems()
faces1 = []
for i in res:
    nbn = mesh.GetElemNbNodes(i)


# create other two edges and rotate them for creation
# other full circle
n8 = mesh.AddNode(-65,0,0)
n9 = mesh.AddNode(-67.5,0,0)
n10 = mesh.AddNode(-70,0,0)
e8 = mesh.AddEdge([n8,n9])
e9 = mesh.AddEdge([n9,n10])
axisr3 = smesh.AxisStruct(-65,0,0,0,-1,0)
mesh.RotationSweep([e8,e9],axisr3, math.pi/6, 12, tol)
res = mesh.GetLastCreatedElems()
faces2 = []
for i in res:
    nbn = mesh.GetElemNbNodes(i)


# there are coincident nodes after rotation
# therefore we have to merge nodes
nodes = mesh.FindCoincidentNodes(0.001)
mesh.MergeNodes(nodes)

nbcircs = 2
nbrsteps = 24

oldnodes = newnodes

nodes = []
mesh.RotationSweep(faces1,axisr1, math.pi*2/nbrsteps, nbrs, tol)
res = mesh.GetLastCreatedElems()

for i in range(0,nbrs):
    volumes = []

    newnodes = GetNewNodes(mesh,volumes,oldnodes)
    for j in newnodes:
        xyz = mesh.GetNodeXYZ(j)
        mesh.MoveNode(j,xyz[0],xyz[1],xyz[2]+dz*(i+1))
        pass
    oldnodes = newnodes
    pass

oldnodes = newnodes

nodes = []
mesh.RotationSweep(faces2,axisr1, math.pi*2/nbrsteps, nbrs, tol)
res = mesh.GetLastCreatedElems()

for i in range(0,nbrs):
    volumes = []

    newnodes = GetNewNodes(mesh,volumes,oldnodes)
    for j in newnodes:
        xyz = mesh.GetNodeXYZ(j)
        mesh.MoveNode(j,xyz[0],xyz[1],xyz[2]+dz*(i+1))
        pass
    oldnodes = newnodes
    pass

smesh.salome.sg.updateObjBrowser(1)




#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#

from SMESH_test1 import *

## Old style
def CheckBelongToGeomFilterOld(theMeshGen, theMesh, theShape, theSubShape, theElemType):
    import geompy
    if theShape != theSubShape:
        aName = str(theSubShape)

    aFilter.SetPredicate(aBelongToGeom)
    return aFilter.GetElementsId(theMesh)

## Current style
def CheckBelongToGeomFilter(theMesh, theShape, theSubShape, theElemType):
    import geompy
    if theShape != theSubShape:
        aName = str(theSubShape)
        geompy.addToStudyInFather(theShape,theSubShape,aName)

    theMesh.Compute()
    aFilter = theMesh.GetFilter(theElemType, smesh.FT_BelongToGeom, theSubShape)
    return aFilter.GetElementsId(theMesh.GetMesh())
    

anElemType = smesh.FACE;
print "anElemType =", anElemType
#anIds = CheckBelongToGeomFilter(mesh,box,subShapeList[1],anElemType)
anIds = CheckBelongToGeomFilter(mesh,box,box,anElemType)
print "Number of ids = ", len(anIds)
print "anIds = ", anIds
## Check old version
#anIds = CheckBelongToGeomFilterOld(smesh.smesh,mesh.GetMesh(),box,box,anElemType)
#print "anIds = ", anIds

salome.sg.updateObjBrowser(1);




#  Module : SMESH

from SMESH_test1 import *
import SMESH

# Compute the mesh created in SMESH_test1

mesh.Compute()

# Create geometry groups on plane:
aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])

geompy.addToStudy(aGeomGroup1, "Group on Faces")
geompy.addToStudy(aGeomGroup2, "Group on Edges")

aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)

salome.sg.updateObjBrowser(1);




#  Project                  : PAL/SALOME
#============================================================================== 
from SMESH_test1 import *


# Compute the mesh created in SMESH_test1

mesh.Compute()

# Create geometry groups on plane:
aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])

geompy.addToStudy(aGeomGroup1, "Group on Faces")
geompy.addToStudy(aGeomGroup2, "Group on Edges")

aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)

print "Create aGroupOnShell - a group linked to a shell"
aGroupOnShell = mesh.GroupOnGeom(shell, "GroupOnShell", smesh.EDGE)
print "aGroupOnShell type =", aGroupOnShell.GetType()
print "aGroupOnShell size =", aGroupOnShell.Size()
print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()

print " "

print "Re-compute mesh, contents of aGroupOnShell changes again:"
mesh.Compute()
print "aGroupOnShell size =", aGroupOnShell.Size()
print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()





#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
import smesh

def BuildGroupLyingOn(theMesh, theElemType, theName, theShape):
    aFilterMgr = smesh.smesh.CreateFilterManager()
    aFilter = aFilterMgr.CreateFilter()
   
    aLyingOnGeom = aFilterMgr.CreateLyingOnGeom()

#Example
from SMESH_test1 import *

mesh.Compute()

# First way
BuildGroupLyingOn(mesh.GetMesh(), smesh.FACE, "Group of faces lying on edge #1", edge )

# Second way
mesh.MakeGroup("Group of faces lying on edge #2", smesh.FACE, smesh.FT_LyingOnGeom, edge)

salome.sg.updateObjBrowser(1);





import geompy
import salome
import smesh
import os
import math
import StdMeshers
import SMESH

#Sketcher_1 creation
print "Sketcher creation..."

Cut_1_ID = geompy.addToStudy(Cut_1, "Cut_1")

#Mesh creation
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# -- Init --
shape_mesh = salome.IDToObject( Cut_1_ID )

mesh = smesh.Mesh(shape_mesh, "Nut")
smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)
idmesh = salome.ObjectToID(mesh)
smeshgui.SetName( idmesh, "Nut" )

#HYPOTHESIS CREATION
print "-------------------------- Average length"
theAverageLength = 5
algoReg1D = mesh.Segment()
hAvLength = algoReg1D.LocalLength(theAverageLength)
print hAvLength.GetName()
print hAvLength.GetId()
print hAvLength.GetLength()
smesh.SetName(hAvLength, "AverageLength_"+str(theAverageLength))

print "-------------------------- MaxElementArea"
theMaxElementArea = 20
algoMef = mesh.Triangle(smesh.MEFISTO)
hArea = algoMef.MaxElementArea( theMaxElementArea )
print hArea.GetName()
print hArea.GetId()
print hArea.GetMaxElementArea()
smesh.SetName(hArea, "MaxElementArea_"+str(theMaxElementArea))

print "-------------------------- MaxElementVolume"
theMaxElementVolume = 150
algoNg = mesh.Tetrahedron(smesh.NETGEN)
hVolume = algoNg.MaxElementVolume( theMaxElementVolume )
print hVolume.GetName()
print hVolume.GetId()
print hVolume.GetMaxElementVolume()
smesh.SetName(hVolume, "MaxElementVolume_"+str(theMaxElementVolume))

mesh.AddHypothesis(shape_mesh, hAvLength)
mesh.AddHypothesis(shape_mesh, hArea20)
mesh.AddHypothesis(shape_mesh, hVolume150)

print "-------------------------- Regular_1D"

algoReg1D = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
listHyp = algoReg1D.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg1D.GetName()
print algoReg1D.GetId()
smeshgui.SetName(salome.ObjectToID(algoReg1D), "Wire discretisation")

print "-------------------------- MEFISTO_2D"
algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()
smeshgui.SetName(salome.ObjectToID(algoMef), "Triangle (Mefisto)")

print "-------------------------- NETGEN_3D"

algoNg = smesh.CreateHypothesis( "NETGEN_3D", "libNETGENEngine.so" )
print algoNg.GetName()
print algoNg.GetId()
smeshgui.SetName(salome.ObjectToID(algoNg), "Tetrahedron (NETGEN)")
mesh.AddHypothesis(shape_mesh, algoReg1D)
mesh.AddHypothesis(shape_mesh, algoMef)
mesh.AddHypothesis(shape_mesh, algoNg)

print "-------------------------- compute the mesh of the mechanic piece"
mesh.Compute()

print "Information about the Nut:"
print "Number of nodes       : ", mesh.NbNodes()





import salome
import geompy
import smesh
from math import sqrt

import StdMeshers
import NETGENPlugin

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

#---------------------------------------------------------------



# ---- launch SMESH

# ---- init a Mesh with the alveole
shape_mesh = salome.IDToObject( idalveole )

mesh = smesh.Mesh(shape_mesh, "MeshAlveole")

print "-------------------------- create Hypothesis (In this case global hypothesis are used)"

print "-------------------------- NumberOfSegments"

numberOfSegments = 10

regular1D = mesh.Segment()
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 0.1

mefisto2D = mesh.Triangle()
hypArea = mefisto2D.MaxElementArea(maxElementArea)
print hypArea.GetName()
print hypArea.GetId()
print hypArea.GetMaxElementArea()
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_0.1")

print "-------------------------- MaxElementVolume"

maxElementVolume = 0.5

netgen3D = mesh.Tetrahedron(smesh.NETGEN)
hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))
smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_0.5")

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")
smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")

# ---- init a Mesh with the alveole
shape_mesh = salome.IDToObject( idalveole )

mesh = smesh.CreateMesh(shape_mesh)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshAlveole")

# ---- add hypothesis to alveole

print "-------------------------- add hypothesis to alveole"

mesh.AddHypothesis(shape_mesh,regular1D)
mesh.AddHypothesis(shape_mesh,hypNbSeg)

mesh.AddHypothesis(shape_mesh,mefisto2D)
mesh.AddHypothesis(shape_mesh,hypArea)

mesh.AddHypothesis(shape_mesh,netgen3D)
mesh.AddHypothesis(shape_mesh,hypVolume)

print "-------------------------- compute the mesh of alveole "
ret = mesh.Compute()

if ret != 0:
    log=mesh.GetLog(0) # no erase trace




import salome
import geompy
import math
import smesh

import GEOM_Spanner

isBlocksTest = 0 # False
isMeshTest   = 1 # True
hasGUI       = 1 # True

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

GEOM_Spanner.MakeSpanner(geompy, math, isBlocksTest, isMeshTest, smesh)

salome.sg.updateObjBrowser(1);




import salome
from salome import sg
import geompy
import smesh

import StdMeshers

# ---- launch GEOM

geom          = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
meshgenerator = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

###geom.GetCurrentStudy(salome.myStudy._get_StudyId())
meshgenerator.SetCurrentStudy(salome.myStudy)

# Plate

box    = geompy.MakeBox(0.,0.,0.,1.,1.,1.)
boxId  = geompy.addToStudy(box,"box")

# ---- SMESH

# ---- init a Mesh
smeshgui.Init(salome.myStudyId)
# meshgenerator=smeshpy.smeshpy()


# Hypothesis

hypL1=meshgenerator.CreateHypothesis("LocalLength","libStdMeshersEngine.so")
hypL1.SetLength(0.25)
hypL1Id = salome.ObjectToID(hypL1) 
smeshgui.SetName(hypL1Id, "LocalLength")

box_mesh=smesh.Mesh(box, "box_mesh")

# set Hypothesis and Algorithm
alg1DId = salome.ObjectToID(alg1D) 
smeshgui.SetName(alg1DId, "algo1D")

alg1D = box_mesh.Segment()
alg1D.SetName("algo1D")
hypL1 = alg1D.LocalLength(0.25)
smesh.SetName(hypL1, "LocalLength")
    
alg2D = box_mesh.Quadrangle()
alg2D.SetName("algo2D")

alg3D = box_mesh.Hexahedron()
alg3D.SetName("algo3D")
smeshgui.SetName(alg3DId, "algo3D")
 
# ---- init a Mesh

# compute mesh
box_meshId = salome.ObjectToID(box_mesh)
smeshgui.SetName(box_meshId, "box_mesh")

# ---- set Hypothesis & Algorithm

box_mesh.AddHypothesis(box,alg1D)
box_mesh.AddHypothesis(box,alg2D)
box_mesh.AddHypothesis(box,alg3D)
box_mesh.AddHypothesis(box,hypL1)

box_mesh.Compute()

sg.updateObjBrowser(1)





import salome
import geompy
import smesh

import StdMeshers
import NETGENPlugin

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId);

# ---- define 2 boxes box1 and box2



### ---------------------------- SMESH --------------------------------------

# ---- init a Mesh with the shell

mesh = smesh.Mesh(shell, "MeshBox2")


# ---- set Hypothesis and Algorithm

print "-------------------------- NumberOfSegments"

numberOfSegments = 10

regular1D = mesh.Segment()
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)

print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 500

mefisto2D = mesh.Triangle()
hypArea = mefisto2D.MaxElementArea(maxElementArea)

print hypArea.GetName()
print hypArea.GetId()
print hypArea.GetMaxElementArea()
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_500")

print "-------------------------- MaxElementVolume"

maxElementVolume = 500

netgen3D = mesh.Tetrahedron(smesh.NETGEN)
hypVolume = netgen3D.MaxElementVolume(maxElementVolume)

print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))

smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_500")

# ---- create Algorithms

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")
smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")

# ---- init a Mesh with the shell

mesh = smesh.CreateMesh(shell)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshBox2")

# ---- add hypothesis to shell

print "-------------------------- add hypothesis to shell"

mesh.AddHypothesis(shell,regular1D)
mesh.AddHypothesis(shell,hypNbSeg)

mesh.AddHypothesis(shell,mefisto2D)
mesh.AddHypothesis(shell,hypArea)

mesh.AddHypothesis(shell,netgen3D)
mesh.AddHypothesis(shell,hypVolume)

salome.sg.updateObjBrowser(1)

print "-------------------------- compute shell"
ret = mesh.Compute()
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace





import salome
import geompy
import smesh

import StdMeshers
import NETGENPlugin

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId);

# ---- define 3 boxes box1, box2 and box3



### ---------------------------- SMESH --------------------------------------

# ---- create Hypothesis

# ---- init a Mesh with the shell

mesh = smesh.Mesh(shell, "MeshBox3")


# ---- set Hypothesis and Algorithm

print "-------------------------- NumberOfSegments"

numberOfSegments = 10

regular1D = mesh.Segment()
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)

print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 500

mefisto2D = mesh.Triangle()
hypArea = mefisto2D.MaxElementArea(maxElementArea)

print hypArea.GetName()
print hypArea.GetId()
print hypArea.GetMaxElementArea()
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_500")

print "-------------------------- MaxElementVolume"

maxElementVolume = 500

netgen3D = mesh.Tetrahedron(smesh.NETGEN)
hypVolume = netgen3D.MaxElementVolume(maxElementVolume)

print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))

smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_500")

# ---- create Algorithms

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")
smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")

# ---- init a Mesh with the shell

mesh = smesh.CreateMesh(shell)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshBox3")

# ---- add hypothesis to shell

print "-------------------------- add hypothesis to shell"

mesh.AddHypothesis(shell,regular1D)
mesh.AddHypothesis(shell,hypNbSeg)

mesh.AddHypothesis(shell,mefisto2D)
mesh.AddHypothesis(shell,hypArea)

mesh.AddHypothesis(shell,netgen3D)
mesh.AddHypothesis(shell,hypVolume)

salome.sg.updateObjBrowser(1)

print "-------------------------- compute shell"
ret = mesh.Compute()
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace





import salome
import geompy
import smesh

import StdMeshers
import NETGENPlugin

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId);

# ---- define a boxe



### ---------------------------- SMESH --------------------------------------

# ---- init a Mesh with the boxe

mesh = smesh.Mesh(box, "MeshBox")

# ---- set Hypothesis and Algorithm

print "-------------------------- NumberOfSegments"
numberOfSegments = 10

regular1D = mesh.Segment()
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)

print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 500

mefisto2D = mesh.Triangle()
hypArea = mefisto2D.MaxElementArea(maxElementArea)

print hypArea.GetName()
print hypArea.GetId()
print hypArea.GetMaxElementArea()
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_500")

print "-------------------------- MaxElementVolume"

maxElementVolume = 500

netgen3D = mesh.Tetrahedron(smesh.NETGEN)
hypVolume = netgen3D.MaxElementVolume(maxElementVolume)

print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))
smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_500")

# ---- create Algorithms

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")
smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")

# ---- init a Mesh with the boxe

mesh = smesh.CreateMesh(box)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshBox")

# ---- add hypothesis to the boxe

print "-------------------------- add hypothesis to the box"

mesh.AddHypothesis(box,regular1D)
mesh.AddHypothesis(box,hypNbSeg)

mesh.AddHypothesis(box,mefisto2D)
mesh.AddHypothesis(box,hypArea)

mesh.AddHypothesis(box,netgen3D)
mesh.AddHypothesis(box,hypVolume)

salome.sg.updateObjBrowser(1)

print "-------------------------- compute the mesh of the boxe"
ret = mesh.Compute()
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace




#  Module : SMESH


import smesh
import SMESH_mechanic

salome = smesh.salome
mesh   = SMESH_mechanic.mesh
salome = SMESH_mechanic.salome


# ---- Criterion : AREA > 100

# create group
aGroup = mesh.MakeGroup("Area > 100", smesh.FACE, smesh.FT_Area, smesh.FT_MoreThan, 100)
aFunctor = aFilterMgr.CreateArea()
aPredicate = aFilterMgr.CreateMoreThan()
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 100 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Area > 100 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Area > 100" )
aGroup.Add( anIds )


# Criterion : Taper > 3e-15

aFunctor = aFilterMgr.CreateTaper()
aPredicate = aFilterMgr.CreateMoreThan()
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 3e-15 )

# ----  Criterion : Taper > 3e-15
aFilter.SetPredicate( aPredicate )

# create group
aGroup = mesh.MakeGroup("Taper > 3e-15", smesh.FACE, smesh.FT_Taper, smesh.FT_MoreThan, 3e-15)

# print result
anIds = aGroup.GetIDs()
print "Criterion: Taper > 3e-15 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Taper > 3e-15" )
aGroup.Add( anIds )

# ----  Criterion : ASPECT RATIO > 1.3

# create group
aGroup = mesh.MakeGroup("Aspect Ratio > 1.3", smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 1.3)
aFunctor = aFilterMgr.CreateAspectRatio()
aPredicate = aFilterMgr.CreateMoreThan()
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 1.3 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Aspect Ratio > 1.3 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Aspect Ratio > 1.3" )
aGroup.Add( anIds )

# ----  Criterion : MINIMUM ANGLE < 30

# create group
aGroup = mesh.MakeGroup("Minimum Angle < 30", smesh.FACE, smesh.FT_MinimumAngle, smesh.FT_LessThan, 30)
aFunctor = aFilterMgr.CreateMinimumAngle()
aPredicate = aFilterMgr.CreateLessThan()
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 30 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Minimum Angle < 30 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Minimum Angle < 30" )
aGroup.Add( anIds )

# Criterion : Warp > 2e-13

aFunctor = aFilterMgr.CreateWarping()
aPredicate = aFilterMgr.CreateMoreThan()
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 2e-13 )

# ---- Criterion : Warp > 2e-13
aFilter.SetPredicate( aPredicate )

# create group
aGroup = mesh.MakeGroup("Warp > 2e-13", smesh.FACE, smesh.FT_Warping, smesh.FT_MoreThan, 2e-13 )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Warp > 2e-13 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Warp > 2e-13" )
aGroup.Add( anIds )

# ---- Criterion : Skew > 18

# create group
aGroup = mesh.MakeGroup("Skew > 18", smesh.FACE, smesh.FT_Skew, smesh.FT_MoreThan, 18 )
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 18 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Skew > 18 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.FACE, "Skew > 18" )
aGroup.Add( anIds )

# Criterion : Length > 10

# create group
aGroup = mesh.MakeGroup("Length > 10", smesh.FACE, smesh.FT_Length, smesh.FT_MoreThan, 10 )
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 10 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Length > 10 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.EDGE, "Length > 10" )
aGroup.Add( anIds )

# Criterion : Borders at multi-connections = 2

# create group
aGroup = mesh.MakeGroup("Borders at multi-connections = 2", smesh.EDGE, smesh.FT_MultiConnection, smesh.FT_EqualTo, 2)
aPredicate.SetNumFunctor( aFunctor )
aPredicate.SetMargin( 2 )

aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
anIds = aGroup.GetIDs()
print "Criterion: Borders at multi-connections = 2 Nb = ", len( anIds )
#for i in range( len( anIds ) ):
  #print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.EDGE, "Borders at multi-connections = 2" )
aGroup.Add( anIds )


salome.sg.updateObjBrowser(1)





import salome
import geompy
import smesh
import StdMeshers
import NETGENPlugin

geom  = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId);

import math


# -----------------------------------------------------------------------------

ShapeTypeShell     = 3


### ---------------------------- SMESH --------------------------------------

# ---- init a Mesh with the volume

mesh = smesh.Mesh(vol, "meshVolume")

# ---- set Hypothesis and Algorithm to main shape

print "-------------------------- NumberOfSegments the global one"

numberOfSegments = 10

regular1D = mesh.Segment()
regular1D.SetName("Wire Discretisation")
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments")

smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments")

print "-------------------------- NumberOfSegments in the Z direction"

numberOfSegmentsZ = 40

hypNbSegZ=smesh.CreateHypothesis("NumberOfSegments","libStdMeshersEngine.so")
hypNbSegZ.SetNumberOfSegments(numberOfSegmentsZ)
hypNbSegZID = hypNbSegZ.GetId()
print hypNbSegZ.GetName()
print hypNbSegZID
print hypNbSegZ.GetNumberOfSegments()

smeshgui.SetName(salome.ObjectToID(hypNbSegZ), "NumberOfSegmentsZ")

# ---- create Algorithms

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D=smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- Quadrangle_2D"

quad2D=mesh.Quadrangle()
quad2D.SetName("Quadrangle_2D")

print "-------------------------- Hexa_3D"

hexa3D=mesh.Hexahedron()
hexa3D.SetName("Hexa_3D")

# ---- init a Mesh with the volume

print "-------------------------- NumberOfSegments in the Z direction"
smeshgui.SetName(salome.ObjectToID(mesh), "meshVolume")

# ---- add hypothesis to the volume

print "-------------------------- add hypothesis to the volume"

numberOfSegmentsZ = 40
print ret
ret=mesh.AddHypothesis(vol,hypNbSeg)
print ret
ret=mesh.AddHypothesis(vol,quad2D)
print ret
ret=mesh.AddHypothesis(vol,hexa3D)
print ret

for i in range(8):
    print "-------------------------- add hypothesis to edge in the Z directions", (i+1)

    algo = mesh.Segment(edgeZ[i])
    hyp = algo.NumberOfSegments(numberOfSegmentsZ)
    smesh.SetName(hyp, "NumberOfSegmentsZ")
    smesh.SetName(algo.GetSubMesh(), "SubMeshEdgeZ_"+str(i+1))
  

salome.sg.updateObjBrowser(1)

print "-------------------------- compute the mesh of the volume"

ret=mesh.Compute()

print ret
if ret != 0:




#

import SMESH_fixation
import smesh
import StdMeshers

compshell = SMESH_fixation.compshell
idcomp = SMESH_fixation.idcomp

print " check status ", status

### ---------------------------- SMESH --------------------------------------
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# ---- init a Mesh with the compshell
shape_mesh = salome.IDToObject( idcomp  )

mesh = smesh.Mesh(shape_mesh, "MeshCompShell")


# ---- set Hypothesis and Algorithm

print "-------------------------- NumberOfSegments"

numberOfSegments = 5

regular1D = mesh.Segment()
regular1D.SetName("Wire Discretisation")
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_5")

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")

smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- Quadrangle_2D"

quad2D = mesh.Quadrangle()
quad2D.SetName("Quadrangle_2D")
smeshgui.SetName(salome.ObjectToID(quad2D), "Quadrangle_2D")

print "-------------------------- Hexa_3D"

hexa3D = mesh.Hexahedron()
hexa3D.SetName("Hexa_3D")
smeshgui.SetName(salome.ObjectToID(hexa3D), "Hexa_3D")

# ---- init a Mesh with the compshell
shape_mesh = salome.IDToObject( idcomp  )

mesh = smesh.CreateMesh(shape_mesh)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshCompShell")


print "-------------------------- add hypothesis to compshell"

mesh.AddHypothesis(shape_mesh,regular1D)
mesh.AddHypothesis(shape_mesh,hypNbSeg)

mesh.AddHypothesis(shape_mesh,quad2D)
mesh.AddHypothesis(shape_mesh,hexa3D)

salome.sg.updateObjBrowser(1)

print "-------------------------- compute compshell"
ret = mesh.Compute()
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace




# The new Netgen algorithm is used that discretizes baoundaries itself
#

import StdMeshers
import NETGENPlugin
import SMESH_fixation
import smesh


print "-------------------------- create Mesh, algorithm, hypothesis"

mesh = smesh.Mesh(compshell, "MeshcompShel");
netgen = mesh.Tetrahedron(smesh.FULL_NETGEN)
netgen.SetMaxSize( 50 )
#netgen.SetSecondOrder( 0 )
netgen.SetFineness( smesh.Fine )
#netgen.SetOptimize( 1 )
#hyp.SetOptimize( 1 )

salome.sg.updateObjBrowser(1)





# Hypothesis and algorithms for the mesh generation are global
#

import StdMeshers
import NETGENPlugin
import SMESH_fixation
import smesh

compshell = SMESH_fixation.compshell
idcomp = SMESH_fixation.idcomp

print " check status ", status

### ---------------------------- SMESH --------------------------------------
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# ---- init a Mesh with the compshell

mesh = smesh.Mesh(compshell, "MeshcompShell")


# ---- set Hypothesis and Algorithm

print "-------------------------- NumberOfSegments"

numberOfSegments = 5

regular1D = mesh.Segment()
regular1D.SetName("Wire Discretisation")
hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))

## print "-------------------------- MaxElementArea"

print "-------------------------- MaxElementArea"

## maxElementArea = 80

## mefisto2D = mesh.Triangle()
## mefisto2D.SetName("MEFISTO_2D")
## hypArea = mefisto2D.MaxElementArea(maxElementArea)
## print hypArea.GetName()
## print hypArea.GetId()
## print hypArea.GetMaxElementArea()
## smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))

print "-------------------------- LengthFromEdges"

mefisto2D = mesh.Triangle()
mefisto2D.SetName("MEFISTO_2D")
hypLengthFromEdges = mefisto2D.LengthFromEdges()
print hypLengthFromEdges.GetName()
print hypLengthFromEdges.GetId()
smesh.SetName(hypLengthFromEdges, "LengthFromEdges")


print "-------------------------- MaxElementVolume"

maxElementVolume = 1000

netgen3D = mesh.Tetrahedron(smesh.NETGEN)
netgen3D.SetName("NETGEN_3D")
hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))

smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_1000")

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")

smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")

smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")

smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")

# ---- init a Mesh with the compshell

mesh = smesh.CreateMesh(compshell)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshcompShel")

print "-------------------------- add hypothesis to compshell"

mesh.AddHypothesis(compshell,regular1D)
mesh.AddHypothesis(compshell,hypNbSeg)

mesh.AddHypothesis(compshell,mefisto2D)
mesh.AddHypothesis(compshell,hypLengthFromEdges)

mesh.AddHypothesis(compshell,netgen3D)
mesh.AddHypothesis(compshell,hypVolume)

salome.sg.updateObjBrowser(1)

print "-------------------------- compute compshell"
ret = mesh.Compute(mesh)
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace




import os
import salome
import geompy
import smesh

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)


# ---------------------------- GEOM --------------------------------------


### ---------------------------- SMESH --------------------------------------

# ---- init a Mesh with the shell
shape_mesh = salome.IDToObject( idShape )

mesh = smesh.Mesh(shape_mesh, "MeshFlight")


# ---- set Hypothesis and Algorithm

print "-------------------------- LocalLength"

lengthOfSegments = 0.3

regular1D = mesh.Segment()
hypLength = regular1D.LocalLength(lengthOfSegments)

print hypLength.GetName()
print hypLength.GetId()
print hypLength.GetLength()
smesh.SetName(hypLength, "LocalLength_" + str(lengthOfSegments))
smeshgui.SetName(salome.ObjectToID(hypLength), "LocalLength_0.3")

print "-------------------------- LengthFromEdges"

mefisto2D = mesh.Triangle()
hypLengthFromEdge = mefisto2D.LengthFromEdges()
print hypLengthFromEdge.GetName()
print hypLengthFromEdge.GetId()
smesh.SetName(hypLengthFromEdge,"LengthFromEdge")

smeshgui.SetName(salome.ObjectToID(hypLengthFromEdge), "LengthFromEdge")

print "-------------------------- create Algorithms"

print "-------------------------- Regular_1D"

regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")

smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")

print "-------------------------- MEFISTO_2D"

mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")

smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")

# ---- init a Mesh with the shell
shape_mesh = salome.IDToObject( idShape )

mesh = smesh.CreateMesh(shape_mesh)
smeshgui.SetName(salome.ObjectToID(mesh), "MeshFlight")

# ---- add hypothesis to flight

print "-------------------------- add hypothesis to flight"

mesh.AddHypothesis(shape_mesh,regular1D)
mesh.AddHypothesis(shape_mesh,hypLength)
mesh.AddHypothesis(shape_mesh,mefisto2D)
mesh.AddHypothesis(shape_mesh,hypLengthFromEdge)

salome.sg.updateObjBrowser(1)


print "-------------------------- compute the skin flight"
ret = mesh.Compute()
print ret
if ret != 0:
    log = mesh.GetLog(0) # no erase trace




#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
import salome
import geompy
import smesh


# Create box without one plane

box = geompy.MakeBox(0., 0., 0., 10., 20., 30.)
subShapeList = geompy.SubShapeAll(box, geompy.ShapeType["FACE"])

FaceList  = []
for i in range( 5 ):
  FaceList.append( subShapeList[ i ] )

aComp = geompy.MakeCompound( FaceList )
aBox = geompy.Sew( aComp, 1. )
idbox = geompy.addToStudy( aBox, "box" )

aBox  = salome.IDToObject( idbox )

# Create mesh

mesh = smesh.Mesh(aBox, "Mesh_freebord")

algoReg = mesh.Segment()
hypNbSeg = algoReg.NumberOfSegments(5)

algoMef = mesh.Triangle()
hypArea = algoMef.MaxElementArea(20)


mesh.Compute()


# Criterion : Free edges. Create group.

aCriterion = smesh.GetCriterion(smesh.EDGE, smesh.FT_FreeEdges)

aGroup = mesh.MakeGroupByCriterion("Free edges", aCriterion)

anIds = aGroup.GetIDs()

# print result
print "Criterion: Free edges Nb = ", len( anIds )
for i in range( len( anIds ) ):
  print anIds[ i ]

salome.sg.updateObjBrowser(1)
aFilterMgr = smesh.CreateFilterManager()
aPredicate = aFilterMgr.CreateFreeBorders()
aFilter = aFilterMgr.CreateFilter()
aFilter.SetPredicate( aPredicate )

anIds = aFilter.GetElementsId( mesh )

# print result
print "Criterion: Free edges Nb = ", len( anIds )
for i in range( len( anIds ) ):
  print anIds[ i ]

# create group
aGroup = mesh.CreateGroup( SMESH.EDGE, "Free edges" )
aGroup.Add( anIds )


salome.sg.updateObjBrowser(1)




#==============================================================================

import salome
from salome import sg

import geompy
import smesh

import math


geom = salome.lcc.FindOrLoadComponent("FactoryServer", "GEOM")
myBuilder = salome.myStudy.NewBuilder()
gg = salome.ImportComponentGUI("GEOM")
from salome import sg

ShapeTypeCompSolid = 1
ShapeTypeSolid     = 2


print "-------------------------- mesh"

import SMESH
import StdMeshers
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

# ---- create Hypothesis
print "-------------------------- create Hypothesis"
numberOfSegments = 4
hypNbSegA=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSegA.SetNumberOfSegments(numberOfSegments)
numberOfSegments = 10
hypNbSegB=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSegB.SetNumberOfSegments(numberOfSegments)
numberOfSegments = 15
hypNbSegC=smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSegC.SetNumberOfSegments(numberOfSegments)

# ---- create Algorithms
print "-------------------------- create Algorithms"
regular1D=smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
quad2D=smesh.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")
hexa3D=smesh.CreateHypothesis("Hexa_3D", "libStdMeshersEngine.so")

# ---- init a Mesh with the geom shape
shape_mesh = blob
mesh=smesh.Mesh(shape_mesh, "MeshBlob")

# ---- add hypothesis and algorithms to mesh
print "-------------------------- add hypothesis to mesh"
algo1 = mesh.Segment()
algo2 = mesh.Quadrangle()
algo3 = mesh.Hexahedron()

numberOfSegmentsA = 4

algo = mesh.Segment(aretes[0])
algo.NumberOfSegments(numberOfSegmentsA)
algo = mesh.Segment(aretes[2])
algo.NumberOfSegments(numberOfSegmentsA)
algo = mesh.Segment(aretes[8])
algo.NumberOfSegments(numberOfSegmentsA)
algo = mesh.Segment(aretes[10])
algo.NumberOfSegments(numberOfSegmentsA)


numberOfSegmentsC = 15

algo = mesh.Segment(aretes[1])
algo.NumberOfSegments(numberOfSegmentsC)
algo = mesh.Segment(aretes[3])
algo.NumberOfSegments(numberOfSegmentsC)
algo = mesh.Segment(aretes[9])
algo.NumberOfSegments(numberOfSegmentsC)
algo = mesh.Segment(aretes[11])
algo.NumberOfSegments(numberOfSegmentsC)


numberOfSegmentsB = 10
algo = mesh.Segment(aretes[4])
algo.NumberOfSegments(numberOfSegmentsB)
algo = mesh.Segment(aretes[5])
algo.NumberOfSegments(numberOfSegmentsB)
algo = mesh.Segment(aretes[6])
algo.NumberOfSegments(numberOfSegmentsB)
algo = mesh.Segment(aretes[7])
algo.NumberOfSegments(numberOfSegmentsB)


# ---- compute mesh

print "-------------------------- compute mesh"
ret=mesh.Compute()
print ret
if ret != 0:
    #log=mesh.GetLog(0) # no erase trace
    #for linelog in log:
    #    print linelog
    print "Information about the Mesh:"
    print "Number of nodes       : ", mesh.NbNodes()
    print "Number of edges       : ", mesh.NbEdges()
    print "Number of faces       : ", mesh.NbFaces()
    print "Number of quadrangles : ", mesh.NbQuadrangles()
    print "Number of volumes     : ", mesh.NbVolumes()
    print "Number of hexahedrons : ", mesh.NbHexas()
else:
    print "problem when Computing the mesh"






import salome
import geompy
import smesh

import StdMeshers



# ---------------------------- SMESH --------------------------------------

# ---- launch SMESH, init a Mesh with shape 'mechanic'

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# -- Init --
shape_mesh = salome.IDToObject( Id_mechanic )
smesh.SetCurrentStudy(salome.myStudy)

mesh = smesh.CreateMesh(shape_mesh)

mesh = smesh.Mesh(shape_mesh, "Mesh_mechanic")
smeshgui.Init(salome.myStudyId)

idmesh = salome.ObjectToID(mesh)
smeshgui.SetName( idmesh, "Mesh_mechanic" )

print "-------------------------- NumberOfSegments"

numberOfSegment = 10

algo = mesh.Segment()
hypNbSeg = algo.NumberOfSegments(numberOfSegment)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_10")
smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 25

algo = mesh.Triangle()
hypArea25 = algo.MaxElementArea(maxElementArea)
print hypArea25.GetName()
print hypArea25.GetId()
print hypArea25.GetMaxElementArea()
smesh.SetName(hypArea25, "MaxElementArea_25")

# Create submesh on sub_face1 - sub_face4
# ---------------------------------------
print "-------------------------- MaxElementArea"

maxElementArea = 35

hypArea35 = smesh.CreateHypothesis( "MaxElementArea", "libStdMeshersEngine.so" )
hypArea35.SetMaxElementArea( maxElementArea )
print hypArea35.GetName()
print hypArea35.GetId()
print hypArea35.GetMaxElementArea()

smeshgui.SetName(salome.ObjectToID(hypArea35), "MaxElementArea_35")

print "-------------------------- Regular_1D"

algoReg1D = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
listHyp = algoReg1D.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg1D.GetName()
print algoReg1D.GetId()

smeshgui.SetName(salome.ObjectToID(algoReg1D), "Regular_1D")

print "-------------------------- MEFISTO_2D"

algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()

smeshgui.SetName(salome.ObjectToID(algoMef), "MEFISTO_2D")

print "-------------------------- SMESH_Quadrangle_2D"

algoQuad = smesh.CreateHypothesis( "Quadrangle_2D", "libStdMeshersEngine.so" )
listHyp = algoQuad.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoQuad.GetName()
print algoQuad.GetId()

smeshgui.SetName(salome.ObjectToID(algoQuad), "SMESH_Quadrangle_2D")

print "-------------------------- add hypothesis to main shape"

mesh.AddHypothesis( shape_mesh, hypNbSeg )   # nb segments
mesh.AddHypothesis( shape_mesh, hypArea25 )  # max area

mesh.AddHypothesis( shape_mesh, algoReg1D )  # Regular 1D/wire discretisation
mesh.AddHypothesis( shape_mesh, algoMef )    # MEFISTO 2D

print "-------------------------- add hypothesis and algorithm to sub face 1"

submesh = mesh.GetSubMesh(sub_face1, "SubMeshFace1")

mesh.AddHypothesis( sub_face1, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face1, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorithm to sub face 2"

submesh = mesh.GetSubMesh(sub_face2, "SubMeshFace2")

mesh.AddHypothesis( sub_face2, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face2, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorith to sub face 3"

submesh = mesh.GetSubMesh(sub_face3, "SubMeshFace3")

mesh.AddHypothesis( sub_face3, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face3, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorith to sub face 4"

submesh = mesh.GetSubMesh(sub_face4, "SubMeshFace4")

# Set 2D algorithm to submesh on sub_face1
algo = mesh.Quadrangle(sub_face1)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace1")

# Set 2D algorithm to submesh on sub_face2
algo = mesh.Quadrangle(sub_face2)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace2")

# Set 2D algorithm to submesh on sub_face3
algo = mesh.Quadrangle(sub_face3)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace3")

# Set 2D algorithm to submesh on sub_face4
algo = mesh.Quadrangle(sub_face4)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace4")

print "-------------------------- compute the mesh of the mechanic piece"

mesh.Compute()

print "Information about the Mesh_mechanic:"
print "Number of nodes       : ", mesh.NbNodes()





import salome
import geompy
import smesh
import StdMeshers

import SMESH

# ---------------------------- GEOM --------------------------------------



# ---------------------------- SMESH --------------------------------------

# ---- launch SMESH, init a Mesh with shape 'mechanic'

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")

# -- Init --
shape_mesh = salome.IDToObject( Id_mechanic )
smesh.SetCurrentStudy(salome.myStudy)

mesh = smesh.CreateMesh(shape_mesh)

mesh = smesh.Mesh(shape_mesh, "Mesh_mechanic")
smeshgui.Init(salome.myStudyId)

idmesh = salome.ObjectToID(mesh)
smeshgui.SetName( idmesh, "Mesh_mechanic" )

print "-------------------------- NumberOfSegments"

numberOfSegment = 10

algo = mesh.Segment()
hypNbSeg = algo.NumberOfSegments(numberOfSegment)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegment))

smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 25

algo = mesh.Triangle()
hypArea25 = algo.MaxElementArea(maxElementArea)
print hypArea25.GetName()
print hypArea25.GetId()
print hypArea25.GetMaxElementArea()
smesh.SetName(hypArea25, "MaxElementArea_" + str(maxElementArea))

smeshgui.SetName(salome.ObjectToID(hypArea25), "MaxElementArea_25")

print "-------------------------- MaxElementArea"

maxElementArea = 35

hypArea35 = smesh.CreateHypothesis( "MaxElementArea", "libStdMeshersEngine.so" )
hypArea35.SetMaxElementArea( maxElementArea )
print hypArea35.GetName()
print hypArea35.GetId()
print hypArea35.GetMaxElementArea()

smeshgui.SetName(salome.ObjectToID(hypArea35), "MaxElementArea_35")

print "-------------------------- Regular_1D"

algoReg1D = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
listHyp = algoReg1D.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg1D.GetName()
print algoReg1D.GetId()

smeshgui.SetName(salome.ObjectToID(algoReg1D), "Regular_1D")

print "-------------------------- MEFISTO_2D"

algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()

smeshgui.SetName(salome.ObjectToID(algoMef), "MEFISTO_2D")

# Create submesh on sub_face1 - sub_face4
# ---------------------------------------

# Set 2D algorithm to submesh on sub_face1
algo = mesh.Quadrangle(sub_face1)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace1")
submesh1 = algo.GetSubMesh()

# Set 2D algorithm to submesh on sub_face2
algo = mesh.Quadrangle(sub_face2)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace2")
submesh2 = algo.GetSubMesh()

# Set 2D algorithm to submesh on sub_face3
algo = mesh.Quadrangle(sub_face3)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace3")
submesh3 = algo.GetSubMesh()

# Set 2D algorithm to submesh on sub_face4
algo = mesh.Quadrangle(sub_face4)
smesh.SetName(algo.GetSubMesh(), "SubMeshFace4")
submesh4 = algo.GetSubMesh()

smeshgui.SetName(salome.ObjectToID(algoQuad), "SMESH_Quadrangle_2D")

print "-------------------------- add hypothesis to main shape"

mesh.AddHypothesis( shape_mesh, hypNbSeg )   # nb segments
mesh.AddHypothesis( shape_mesh, hypArea25 )  # max area

mesh.AddHypothesis( shape_mesh, algoReg1D )  # Regular 1D/wire discretisation
mesh.AddHypothesis( shape_mesh, algoMef )    # MEFISTO 2D

print "-------------------------- add hypothesis and algorithm to sub face 1"

submesh = mesh.GetSubMesh(sub_face1, "SubMeshFace1")

mesh.AddHypothesis( sub_face1, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face1, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorithm to sub face 2"

submesh = mesh.GetSubMesh(sub_face2, "SubMeshFace2")

mesh.AddHypothesis( sub_face2, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face2, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorith to sub face 3"

submesh = mesh.GetSubMesh(sub_face3, "SubMeshFace3")

mesh.AddHypothesis( sub_face3, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face3, hypArea35 )  # max area

print "-------------------------- add hypothesis and algorith to sub face 4"

submesh = mesh.GetSubMesh(sub_face4, "SubMeshFace4")

mesh.AddHypothesis( sub_face4, algoQuad )   # Quadrangle 2D
mesh.AddHypothesis( sub_face4, hypArea35 )  # max area

print "-------------------------- compute the mesh of the mechanic piece"

mesh.Compute()

print "Information about the Mesh_mechanic:"
print "Number of nodes       : ", mesh.NbNodes()

print "Number of tetrahedrons: ", mesh.NbTetras()


MeshEditor = mesh.GetMeshEditor()

#1 cutting of quadrangles of the 'SubMeshFace2' submesh
mesh.SplitQuadObject(submesh2, 1)
MeshEditor.SplitQuadObject(submesh, 1)

#2 cutting of triangles of the group
FacesTriToQuad = [2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422]
GroupTriToQuad = mesh.MakeGroupByIds("Group of faces (quad)", smesh.FACE, FacesTriToQuad)
mesh.TriToQuadObject(GroupTriToQuad, None , 1.57)
MeshEditor.TriToQuadObject(GroupTriToQuad, None , 1.57)

#3 extrusion of the group
point = smesh.PointStruct(0, 0, 5)
vector = smesh.DirStruct(point) 
mesh.ExtrusionSweepObject(GroupTriToQuad, vector, 5)

#4 mirror object
mesh.Mirror([], smesh.AxisStruct(0, 0, 0, 0, 0, 0), smesh.POINT, 0) 

#5 mesh translation
point = smesh.PointStruct(10, 10, 10)
vector = smesh.DirStruct(point) 
mesh.Translate([], vector, 0)

#6 mesh rotation
axisXYZ = smesh.AxisStruct(0, 0, 0, 10, 10, 10)
angle180 =  180*3.141/180
mesh.Rotate([], axisXYZ, angle180, 0)

#7 group smoothing
FacesSmooth = [864, 933, 941, 950, 1005, 1013]
GroupSmooth = mesh.MakeGroupByIds("Group of faces (smooth)", smesh.FACE, FacesSmooth)
mesh.SmoothObject(GroupSmooth, [], 20, 2, smesh.CENTROIDAL_SMOOTH)
MeshEditor.SmoothObject(GroupSmooth, [], 20, 2, SMESH.SMESH_MeshEditor.CENTROIDAL_SMOOTH)

#8 rotation sweep object
FacesRotate = [492, 493, 502, 503]
GroupRotate = mesh.MakeGroupByIds("Group of faces (rotate)", smesh.FACE, FacesRotate)
GroupRotate.Add(FacesRotate)
angle45 =  45*3.141/180
axisXYZ = smesh.AxisStruct(-38.3128, -73.3658, -133.321, -13.3402, -13.3265, 6.66632)
mesh.RotationSweepObject(GroupRotate, axisXYZ, angle45, 4, 1e-5)

#9 reorientation of the submesh1
mesh.ReorientObject(submesh1)
MeshEditor.ReorientObject(submesh)

salome.sg.updateObjBrowser(1)





geom  = geompy.geom

import StdMeshers
import NETGENPlugin
import smesh

# ---------------------------- GEOM --------------------------------------

print "-------------------------- create Mesh, algorithm, hypothesis"

mesh = smesh.Mesh(mechanic, "Mesh_mechanic");
netgen = mesh.Triangle(smesh.NETGEN)
netgen.SetMaxSize( 50 )
#netgen.SetSecondOrder( 0 )
netgen.SetFineness( smesh.Fine )
netgen.SetQuadAllowed( 1 )
#netgen.SetOptimize( 1 )
#hyp.SetOptimize( 1 )

salome.sg.updateObjBrowser(1)


print ret
if ret != 0:
    print "Information about the MeshcompShel:"
    print "Number of nodes        : ", mesh.NbNodes()
    print "Number of edges        : ", mesh.NbEdges()
    print "Number of faces        : ", mesh.NbFaces()
    print "Number of triangles    : ", mesh.NbTriangles()
    print "Number of quadrangles  : ", mesh.NbQuadrangles()
    print "Number of volumes      : ", mesh.NbVolumes()
    print "Number of tetrahedrons : ", mesh.NbTetras()
    
else:
    print "problem when computing the mesh"





import salome
import geompy
import smesh

geom  = geompy.geom
smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

import StdMeshers
import NETGENPlugin

# ---------------------------- GEOM --------------------------------------



### ---------------------------- SMESH --------------------------------------

shape_mesh = salome.IDToObject( Id_mechanic  )

mesh = smesh.Mesh(shape_mesh, "Mesh_mechanic_tetra")

print "-------------------------- add hypothesis to main mechanic"

numberOfSegment = 10

algo1 = mesh.Segment()
hypNbSeg = algo1.NumberOfSegments(numberOfSegment)
print hypNbSeg.GetName()
print hypNbSeg.GetId()
print hypNbSeg.GetNumberOfSegments()
smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegment))

smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_10")

print "-------------------------- MaxElementArea"

maxElementArea = 20

algo2 = mesh.Triangle(smesh.MEFISTO)
hypArea = algo2.MaxElementArea(maxElementArea)
print hypArea.GetName()
print hypArea.GetId()
print hypArea.GetMaxElementArea()
smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))

smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_20")

print "-------------------------- MaxElementVolume"

maxElementVolume = 20

algo3 = mesh.Tetrahedron(smesh.NETGEN)
hypVolume = algo3.MaxElementVolume(maxElementVolume)
print hypVolume.GetName()
print hypVolume.GetId()
print hypVolume.GetMaxElementVolume()
smesh.SetName(hypVolume, "maxElementVolume_" + str(maxElementVolume))

smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_20")

print "-------------------------- Regular_1D"

algoReg1D = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
listHyp =algoReg1D.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg1D.GetName()
print algoReg1D.GetId()

smeshgui.SetName(salome.ObjectToID(algoReg1D), "Regular_1D")

print "-------------------------- MEFISTO_2D"

algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()

smeshgui.SetName(salome.ObjectToID(algoMef), "MEFISTO_2D")

print "-------------------------- NETGEN_3D"

algoNg = smesh.CreateHypothesis( "NETGEN_3D", "libNETGENEngine.so" )
listHyp = algoNg.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoNg.GetName()
print algoNg.GetId()

smeshgui.SetName(salome.ObjectToID(algoNg), "NETGEN_3D")

print "-------------------------- add hypothesis to main mechanic"

shape_mesh = salome.IDToObject( Id_mechanic  )

mesh = smesh.CreateMesh(shape_mesh)

idmesh = salome.ObjectToID(mesh)
smeshgui.SetName( idmesh, "Mesh_mechanic_tetra" )

mesh.AddHypothesis( shape_mesh, hypNbSeg )   # nb segments
mesh.AddHypothesis( shape_mesh, hypArea )    # max area
mesh.AddHypothesis( shape_mesh, hypVolume )  # max volume

mesh.AddHypothesis( shape_mesh, algoReg1D )  # Regular 1D/wire discretisation
mesh.AddHypothesis( shape_mesh, algoMef )    # MEFISTO 2D
mesh.AddHypothesis( shape_mesh, algoNg )     # NETGEN 3D

print "-------------------------- compute the mesh of the mechanic piece"
mesh.Compute()

print "Information about the Mesh_mechanic_tetra:"
print "Number of nodes       : ", mesh.NbNodes()





import salome
import geompy
import smesh

import StdMeshers

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

# ---- define a box
print "Define box"

smeshgui.Init(salome.myStudyId)


# ---- Creating meshes

box = salome.IDToObject(idbox)
names = [ "MeshBoxReg", "MeshBoxScale", "MeshBoxTable", "MeshBoxExpr" ]
hypLen1.SetLength(100)
print hypLen1.GetName()
print hypLen1.GetId()
print hypLen1.GetLength()

idlength = salome.ObjectToID(hypLen1)
smeshgui.SetName(idlength, "Local_Length_100");

hypNbSeg = []
print "-------------------------- NumberOfSegments"
hypNbSeg1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg1.SetDistrType(0)
hypNbSeg1.SetNumberOfSegments(7)
print hypNbSeg1.GetName()
print hypNbSeg1.GetId()
print hypNbSeg1.GetNumberOfSegments()
idseg1 = salome.ObjectToID(hypNbSeg1)
smeshgui.SetName(idseg1, "NumberOfSegmentsReg");
hypNbSeg.append(hypNbSeg1)

hypNbSeg2 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg2.SetDistrType(1)
hypNbSeg2.SetNumberOfSegments(7)
hypNbSeg2.SetScaleFactor(2)
print hypNbSeg2.GetName()
print hypNbSeg2.GetId()
print hypNbSeg2.GetNumberOfSegments()
idseg2 = salome.ObjectToID(hypNbSeg2)
smeshgui.SetName(idseg2, "NumberOfSegmentsScale");
hypNbSeg.append(hypNbSeg2)

hypNbSeg3 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg3.SetDistrType(2)
hypNbSeg3.SetNumberOfSegments(7)
hypNbSeg3.SetTableFunction( [0, 0.1, 0.5, 1.0, 1.0, 0.1] )
hypNbSeg3.SetConversionMode(0)
print hypNbSeg3.GetName()
print hypNbSeg3.GetId()
print hypNbSeg3.GetNumberOfSegments()
idseg3 = salome.ObjectToID(hypNbSeg3)
smeshgui.SetName(idseg3, "NumberOfSegmentsTable");
hypNbSeg.append(hypNbSeg3)

hypNbSeg4 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypNbSeg4.SetDistrType(3)
hypNbSeg4.SetNumberOfSegments(10)
hypNbSeg4.SetExpressionFunction("sin(3*t)")
hypNbSeg4.SetConversionMode(1)
print hypNbSeg4.GetName()
print hypNbSeg4.GetId()
print hypNbSeg4.GetNumberOfSegments()
idseg4 = salome.ObjectToID(hypNbSeg4)
smeshgui.SetName(idseg4, "NumberOfSegmentsExpr");
hypNbSeg.append(hypNbSeg4)

print "-------------------------- MaxElementArea"
hypArea1 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypArea1.SetMaxElementArea(2500)
print hypArea1.GetName()
print hypArea1.GetId()
print hypArea1.GetMaxElementArea()

idarea1 = salome.ObjectToID(hypArea1)
smeshgui.SetName(idarea1, "MaxElementArea_2500");

print "-------------------------- MaxElementArea"
hypArea2 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypArea2.SetMaxElementArea(500)
print hypArea2.GetName()
print hypArea2.GetId()
print hypArea2.GetMaxElementArea()

idarea2 = salome.ObjectToID(hypArea2)
smeshgui.SetName(idarea2, "MaxElementArea_500");

print "-------------------------- Regular_1D"
algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
listHyp = algoReg.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg.GetName()
print algoReg.GetId()

idreg = salome.ObjectToID(algoReg)
smeshgui.SetName(idreg, "Regular_1D");

print "-------------------------- MEFISTO_2D"
algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()

idmef = salome.ObjectToID(algoMef)
smeshgui.SetName(idmef, "MEFISTO_2D");

salome.sg.updateObjBrowser(1);

print "-------------------------- Create ", names[0], " mesh"
mesh = smesh.Mesh(box, names[0])
algo = mesh.Segment()
hyp = algo.NumberOfSegments(7)
hyp.SetDistrType(0)
smesh.SetName(hyp, "NumberOfSegmentsReg")
algo = mesh.Triangle()
algo.MaxElementArea(2500)

print "-------------------------- Create ", names[1], " mesh"
mesh = smesh.Mesh(box, names[1])
algo = mesh.Segment()
hyp = algo.NumberOfSegments(7)
hyp.SetDistrType(1)
hyp.SetScaleFactor(2)
smesh.SetName(hyp, "NumberOfSegmentsScale")
algo = mesh.Triangle()
algo.MaxElementArea(2500)

print "-------------------------- Create ", names[2], " mesh"
mesh = smesh.Mesh(box,names[2])
algo = mesh.Segment()
hyp = algo.NumberOfSegments(7)
hyp.SetDistrType(2)
hyp.SetTableFunction( [0, 0.1, 0.5, 1.0, 1.0, 0.1] )
hyp.SetConversionMode(0)
smesh.SetName(hyp, "NumberOfSegmentsTable")
algo = mesh.Triangle()
algo.MaxElementArea(2500)

print "-------------------------- Create ", names[3], " mesh"
mesh = smesh.Mesh(box, names[3])
algo = mesh.Segment()
hyp = algo.NumberOfSegments(10)
hyp.SetDistrType(3)
hyp.SetExpressionFunction("sin(3*t)")
hyp.SetConversionMode(1)
smesh.SetName(hyp, "NumberOfSegmentsExpr")
algo = mesh.Triangle()
algo.MaxElementArea(2500)

box = salome.IDToObject(idbox)
names = [ "MeshBoxReg", "MeshBoxScale", "MeshBoxTable", "MeshBoxExpr" ];
j = 0
for i in range(4):
  mesh = smesh.CreateMesh(box)
  idmesh = salome.ObjectToID(mesh)
  smeshgui.SetName(idmesh, names[j]);
  print "-------------------------- add hypothesis to box"
  mesh.AddHypothesis(box,algoReg)
  mesh.AddHypothesis(box,hypNbSeg[j])
  mesh.AddHypothesis(box,algoMef)
  mesh.AddHypothesis(box,hypArea1)
  j=j+1

salome.sg.updateObjBrowser(1);






import salome
import geompy
import smesh

import SMESH
import StdMeshers

# ---- define a box


name = geompy.SubShapeName(edge, face)
ide = geompy.addToStudyInFather(face, edge, name)

# ---- SMESH

gen = smeshpy.smeshpy()
mesh = gen.CreateMesh(idb)

print "-------------------------- create Hypothesis"

print "-------------------------- LocalLength"

hypo1 = gen.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")
print hypo1.GetName()
print hypo1.GetId()
print hypo1.GetLength()
hypo1.SetLength(100)
print hypo1.GetLength()

print "-------------------------- bidon"

box = salome.IDToObject(idb)
mesh = smesh.Mesh(box, "Meshbox")
print "-------------------------- NumberOfSegments"

hypo3 = gen.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")
hypo3.SetNumberOfSegments(7)
print hypo3.GetName()
print hypo3.GetNumberOfSegments()
print hypo3.GetId()

print "-------------------------- MaxElementArea"

hypo4 = gen.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypo4.SetMaxElementArea(5000)
print hypo4.GetName()
print hypo4.GetMaxElementArea()
print hypo4.GetId()

print "-------------------------- add hypothesis to box"

algo_1 = mesh.Segment(box)
hyp = algo_1.LocalLength(100)
print hyp.GetName()
print hyp.GetId()
print hyp.GetLength()

algo_2 = mesh.Triangle(smesh.MEFISTO, box)
hyp = algo_2.MaxElementArea(5000)
print hyp.GetName()
print hyp.GetId()
print hyp.GetMaxElementArea()

smesh.SetName(algo_2.GetSubMesh(), "SubMeshBox")

algo_2 = gen.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
print algo_2.GetName()
print algo_2.GetId()
listHyp = algo_2.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algo_2.GetId()

print "-------------------------- add hypothesis to edge"

edge = salome.IDToObject(ide)
submesh = mesh.GetSubMesh(edge, "SubMeshEdge")
ret = mesh.AddHypothesis(edge,algo_1)
print ret
ret = mesh.AddHypothesis(edge,hypo1)
print ret

algo_3 = mesh.Segment(edge)
hyp = algo_3.LocalLength(100)
print hyp.GetName()
print hyp.GetId()
print hyp.GetLength()
##    print a

smesh.SetName(algo_3.GetSubMesh(), "SubMeshEdge")

box = salome.IDToObject(idb)
submesh = mesh.GetSubMesh(box, "SubMeshBox")
ret = mesh.AddHypothesis(box,algo_1)
print ret
ret = mesh.AddHypothesis(box,hypo1)
print ret
ret = mesh.AddHypothesis(box,algo_2)
print ret
ret = mesh.AddHypothesis(box,hypo4)
print ret

print "-------------------------- compute face"

face = salome.IDToObject(idf)

ret = mesh.Compute(face)
print ret
log = mesh.GetLog(0) # 0 - GetLog without ClearLog after, else if 1 - ClearLog after
for a in log:

            i3 = a.indexes[ii]
            ii = ii+1
            print "AddTriangle %i - %i %i %i" % (ind, i1, i2, i3)

##print "-------------------------- compute box"
##ret=gen.Compute(mesh,idb)
##print ret
##log=mesh.GetLog(1);
##print log

##shell=salome.IDToObject(ids)
##submesh=mesh.GetElementsOnShape(shell)
##ret=mesh.AddHypothesis(shell,algo_1)
##print ret
##ret=mesh.AddHypothesis(shell,hypo1)
##print ret
##ret=gen.Compute(mesh,ids)
##print ret

Lines 26-32 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_test0.py (-1 lines)
26	import geompy	26	import geompy
27	from geompy import geom	27	from geompy import geom
28		28
29	import SMESH
30		29
31	myBuilder = salome.myStudy.NewBuilder()	30	myBuilder = salome.myStudy.NewBuilder()
32		31





import salome
import geompy
import smesh

import StdMeshers

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

# ---- define a box


print name
idedge = geompy.addToStudyInFather(face, edge, name)

# ---- launch SMESH

smeshgui = salome.ImportComponentGUI("SMESH")
smeshgui.Init(salome.myStudyId)

# ---- SMESH

# ---- Init a Mesh with the box
hypLen1 = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")
hypLen1.SetLength(100)
print hypLen1.GetName()
print hypLen1.GetId()
print hypLen1.GetLength()

mesh = smesh.Mesh(box, "Meshbox")
smeshgui.SetName(idlength, "Local_Length_100");

print "-------------------------- add hypothesis to box"
algoReg1 = mesh.Segment()
hypNbSeg1 = algoReg1.NumberOfSegments(7)
print hypNbSeg1.GetName()
print hypNbSeg1.GetId()
print hypNbSeg1.GetNumberOfSegments()
smesh.SetName(hypNbSeg1, "NumberOfSegments_7")

algoMef1 = mesh.Triangle()
hypArea1 = algoMef1.MaxElementArea(2500)

print "-------------------------- MaxElementArea"
hypArea1 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypArea1.SetMaxElementArea(2500)
print hypArea1.GetName()
print hypArea1.GetId()
print hypArea1.GetMaxElementArea()
smesh.SetName(hypArea1, "MaxElementArea_2500")
idarea1 = salome.ObjectToID(hypArea1)
smeshgui.SetName(idarea1, "MaxElementArea_2500");

print "-------------------------- MaxElementArea"
hypArea2 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")
hypArea2.SetMaxElementArea(500)
print hypArea2.GetName()
print hypArea2.GetId()
print hypArea2.GetMaxElementArea()

idarea2 = salome.ObjectToID(hypArea2)
smeshgui.SetName(idarea2, "MaxElementArea_500");

print "-------------------------- Regular_1D"
algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
listHyp = algoReg.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoReg.GetName()
print algoReg.GetId()

idreg = salome.ObjectToID(algoReg)
smeshgui.SetName(idreg, "Regular_1D");

print "-------------------------- MEFISTO_2D"
algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
listHyp = algoMef.GetCompatibleHypothesis()
for hyp in listHyp:
    print hyp
print algoMef.GetName()
print algoMef.GetId()

idmef = salome.ObjectToID(algoMef)
smeshgui.SetName(idmef, "MEFISTO_2D");

# ---- Init a Mesh with the box

box = salome.IDToObject(idbox)
mesh = smesh.CreateMesh(box)
idmesh = salome.ObjectToID(mesh)
smeshgui.SetName(idmesh, "Meshbox");

print "-------------------------- add hypothesis to box"
mesh.AddHypothesis(box,algoReg)
mesh.AddHypothesis(box,hypNbSeg1)
mesh.AddHypothesis(box,algoMef)
mesh.AddHypothesis(box,hypArea1)

# ---- add hypothesis to edge

print "-------------------------- add hypothesis to edge"
edge = salome.IDToObject(idedge)
submesh = mesh.GetSubMesh(edge, "SubMeshEdge")
mesh.AddHypothesis(edge, algoReg)
mesh.AddHypothesis(edge, hypLen1)

algoReg2 = mesh.Segment(edge)
hypLen1 = algoReg2.LocalLength(100)
smesh.SetName(algoReg2.GetSubMesh(), "SubMeshEdge")
print hypLen1.GetName()
print hypLen1.GetId()
print hypLen1.GetLength()
smesh.SetName(hypLen1, "Local_Length_100")

# ---- add hypothesis to face
print "-------------------------- add hypothesis to face"
face = salome.IDToObject(idface)

algoMef2 = mesh.Triangle(face)
hypArea2 = algoMef2.MaxElementArea(500)
smesh.SetName(algoMef2.GetSubMesh(), "SubMeshFace")
print hypArea2.GetName()
print hypArea2.GetId()
print hypArea2.GetMaxElementArea()
smesh.SetName(hypArea2, "MaxElementArea_500")


salome.sg.updateObjBrowser(1);




# ---- compute box

print "-------------------------- compute box"
ret = mesh.Compute()
print ret
log = mesh.GetLog(0); # no erase trace
for linelog in log:
    print linelog

salome.sg.updateObjBrowser(1)

# ---- compute edge

##print "-------------------------- compute edge"
##ret=gen.Compute(mesh,idedge)
##print ret
##log=mesh.GetLog(1);
##for a in log:
##    print a

# ---- add hypothesis to face

# ---- compute face

#print "-------------------------- compute face"
#ret=gen.Compute(mesh,idface)
#print ret
#log=mesh.GetLog(1);
#for a in log:
#    print a

##shell=salome.IDToObject(ids)
##submesh=mesh.GetElementsOnShape(shell)
##ret=mesh.AddHypothesis(shell,algoReg)
##print ret
##ret=mesh.AddHypothesis(shell,hypLen1)
##print ret
##ret=gen.Compute(mesh,ids)
##print ret




#
import salome
import geompy
import smesh
import StdMeshers


# ---- GEOM

box   = geompy.MakeBox(0., 0., 0., 100., 200., 300.)
idbox = geompy.addToStudy(box, "box")

box  = salome.IDToObject(idbox)
face = salome.IDToObject(idface)

# ---- SMESH

mesh = smesh.Mesh(box, "Meshbox")

# Set 1D algorithm/hypotheses to mesh
algo1 = mesh.Segment()
algo1.NumberOfSegments(10)

# Set 2D algorithm/hypotheses to mesh
algo2 = mesh.Triangle(smesh.MEFISTO)
algo2.MaxElementArea(10)

# Create submesh on face
algo3 = mesh.Segment(face)
algo3.NumberOfSegments(10)
algo4 = mesh.Triangle(smesh.MEFISTO, face)
algo4.MaxElementArea(100)
submesh = algo4.GetSubMesh()
smesh.SetName(submesh, "SubMeshFace")

mesh.AddHypothesis(face,algo2)

mesh.Compute()

faces = submesh.GetElementsByType(smesh.FACE)
if len(faces) > 1:
    print len(faces), len(faces)/2
    group1 = mesh.CreateEmptyGroup(smesh.FACE,"Group of faces")
    group2 = mesh.CreateEmptyGroup(smesh.FACE,"Another group of faces")
    group1.Add(faces[:int(len(faces)/2)])
    group2.Add(faces[int(len(faces)/2):])





#
#
#
#  File   : SMESH_test5.py
#  Module : SMESH

import salome
import smesh
import SALOMEDS
import CORBA
import os


    for iMesh in range(len(aMeshes)) :
        aMesh = aMeshes[iMesh]
        print aMesh.GetName(),
        print anSObj.GetName(),
        aFileName = anInitFileName
        aFileName = os.path.basename(aFileName)
        aMesh.SetName(aFileName)
        print aMesh.GetName()

        aOutPath = '/tmp/'
        aFileName = aOutPath + theFile + "." + str(iMesh) + ".unv"
        aMesh.ExportUNV(aFileName)
        aMesh = smesh.CreateMeshesFromUNV(aFileName)
        print aMesh.GetName(),
        print anSObj.GetName(),
        os.remove(aFileName)
        aFileName = os.path.basename(aFileName)
        aMesh.SetName(aFileName)
        print aMesh.GetName()

smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

aPath = os.getenv('DATA_DIR') + '/MedFiles/'
aListDir = os.listdir(aPath)






    # ---- SMESH
    print "-------------------------- create mesh"
    mesh = smesh.Mesh(shape_mesh)
      
    print "-------------------------- create Hypothesis"
    if (len is not None):
        print "-------------------------- LocalLength"
        algoReg = mesh.Segment()
        hypLength1 = algoReg.LocalLength(len)
        print "Hypothesis type : ", hypLength1.GetName()
        print "Hypothesis ID   : ", hypLength1.GetId()
        print "Hypothesis Value: ", hypLength1.GetLength()
    
    if (nbseg is not None):   
        print "-------------------------- NumberOfSegments"
        algoReg = mesh.Segment()
        hypNbSeg1 = algoReg.NumberOfSegments(nbseg)
        print "Hypothesis type : ", hypNbSeg1.GetName()
        print "Hypothesis ID   : ", hypNbSeg1.GetId()
        print "Hypothesis Value: ", hypNbSeg1.GetNumberOfSegments()

    if (area == "LengthFromEdges"):
        print "-------------------------- LengthFromEdges"
        algoMef = mesh.Triangle()
        hypLengthFromEdges = algoMef.LengthFromEdges(1)
        print "Hypothesis type     : ", hypLengthFromEdges.GetName()
        print "Hypothesis ID       : ", hypLengthFromEdges.GetId()
        print "LengthFromEdges Mode: ", hypLengthFromEdges.GetMode()
       
    else:
        print "-------------------------- MaxElementArea"
        algoMef = mesh.Triangle()
        hypArea1 = algoMef.MaxElementArea(area)
        print "Hypothesis type : ", hypArea1.GetName()
        print "Hypothesis ID   : ", hypArea1.GetId()
        print "Hypothesis Value: ", hypArea1.GetMaxElementArea()
              
    
    print "-------------------------- Regular_1D"
    algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
   
    listHyp = algoReg.GetCompatibleHypothesis()
    for hyp in listHyp:
        print hyp

    print "Algo ID  : ", algoReg.GetId()
   
    print "-------------------------- MEFISTO_2D"
    algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
    
    listHyp = algoMef.GetCompatibleHypothesis()
    for hyp in listHyp:
        print hyp


    # ---- add hypothesis to shape

    print "-------------------------- add hypothesis to shape"
    mesh = smesh.CreateMesh(shape_mesh) 

    ret = mesh.AddHypothesis(shape_mesh, algoReg)
    print "Add Regular_1D algo .... ", 
    print ret
    
    if (nbseg is not None):
        ret = mesh.AddHypothesis(shape_mesh, hypNbSeg1)
        print "Add Number Of Segements algo .... ", 
        print ret

    if (len is not None):
        ret = mesh.AddHypothesis(shape_mesh,hypLength1)
        print "Add  Local Length algo .... ", 
        print ret

    ret = mesh.AddHypothesis(shape_mesh, algoMef)
    print "Add MEFISTO_2D algo....", 
    print ret
    
    if (area == "LengthFromEdges"):
        ret = mesh.AddHypothesis( shape_mesh, hypLengthFromEdges)    # length from edge 
        print "Add Length From Edges algo .... ",
        print ret
    else:
        ret = mesh.AddHypothesis(shape_mesh, hypArea1)
        print "Add Max Triangle Area algo .... ", 
        print ret
    
    print "-------------------------- compute mesh"
    ret = mesh.Compute()
    print  "Compute Mesh .... ", 
    print ret
    log = mesh.GetLog(0); # no erase trace




#  Copyright (C) 2005  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.
#
#  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   : smesh.py
#  Author : Francis KLOSS, OCC
#  Module : SMESH

"""
 \namespace smesh
 \brief Module smesh

import geompy
import StdMeshers
import SMESH
from   SMESH import *

## Types of algo
REGULAR = 1
PYTHON  = 2

MEFISTO = 3
NETGEN  = 4
GHS3D   = 5
FULL_NETGEN = 6

## MirrorType enumeration
POINT = SMESH_MeshEditor.POINT
AXIS =  SMESH_MeshEditor.AXIS 
PLANE = SMESH_MeshEditor.PLANE

## Smooth_Method enumeration
LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH
CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH

## Fineness enumeration(for NETGEN)
VeryCoarse = 0
Coarse = 1
Moderate = 2
Fine = 3
VeryFine = 4
Custom = 5


NO_NAME = "NoName"


smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
smesh.SetCurrentStudy(salome.myStudy)

## Global functions

## Gets object name

def GetName(obj):
    ior  = salome.orb.object_to_string(obj)
    sobj = salome.myStudy.FindObjectIOR(ior)

        attr = sobj.FindAttribute("AttributeName")[1]
        return attr.Value()

## Sets name to object
def SetName(obj, name):
    ior  = salome.orb.object_to_string(obj)
    sobj = salome.myStudy.FindObjectIOR(ior)
    if not sobj is None:
        attr = sobj.FindAttribute("AttributeName")[1]
        attr.SetValue(name)
        
## Returns long value from enumeration
#  Uses for FT_... enumeration
def EnumToLong(theItem):
    return theItem._v

## Get PointStruct from vertex
#  @param theVertex is GEOM object(vertex)
#  @return SMESH.PointStruct
def GetPointStruct(theVertex):
    [x, y, z] = geompy.PointCoordinates(theVertex)
    return PointStruct(x,y,z)

## Get DirStruct from vector
#  @param theVector is GEOM object(vector)
#  @return SMESH.DirStruct
def GetDirStruct(theVector):
    vertices = geompy.SubShapeAll( theVector, geompy.ShapeType["VERTEX"] )
    if(len(vertices) != 2):
        print "Error: vector object is incorrect."
        return None
    p1 = geompy.PointCoordinates(vertices[0])
    p2 = geompy.PointCoordinates(vertices[1])
    pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
    dir = DirStruct(pnt)
    return dir

## Get AxisStruct from object
#  @param theObj is GEOM object(line or plane)
#  @return SMESH.AxisStruct
def GetAxisStruct(theObj):
    edges = geompy.SubShapeAll( theObj, geompy.ShapeType["EDGE"] )
    if len(edges) > 1:
        vertex1, vertex2 = geompy.SubShapeAll( edges[0], geompy.ShapeType["VERTEX"] )
        vertex3, vertex4 = geompy.SubShapeAll( edges[1], geompy.ShapeType["VERTEX"] )
        vertex1 = geompy.PointCoordinates(vertex1)
        vertex2 = geompy.PointCoordinates(vertex2)
        vertex3 = geompy.PointCoordinates(vertex3)
        vertex4 = geompy.PointCoordinates(vertex4)
        v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
        v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
        normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ]
        axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
        return axis
    elif len(edges) == 1:
        vertex1, vertex2 = geompy.SubShapeAll( edges[0], geompy.ShapeType["VERTEX"] )
        p1 = geompy.PointCoordinates( vertex1 )
        p2 = geompy.PointCoordinates( vertex2 )
        axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
        return axis
    return None

## From SMESH_Gen interface:
#  ------------------------

## Set the current mode
def SetEmbeddedMode( theMode ):
    smesh.SetEmbeddedMode(theMode)

## Get the current mode
def IsEmbeddedMode():
    return smesh.IsEmbeddedMode()

## Set the current study
def SetCurrentStudy( theStudy ):
    smesh.SetCurrentStudy(theStudy)

## Get the current study
def GetCurrentStudy():
    return smesh.GetCurrentStudy()

## Create Mesh object importing data from given UNV file
#  @return an instance of Mesh class
def CreateMeshesFromUNV( theFileName ):
    aSmeshMesh = smesh.CreateMeshesFromUNV(theFileName)
    aMesh = Mesh(aSmeshMesh)
    return aMesh

## Create Mesh object(s) importing data from given MED file
#  @return a list of Mesh class instances
def CreateMeshesFromMED( theFileName ):
    aSmeshMeshes, aStatus = smesh.CreateMeshesFromMED(theFileName)
    aMeshes = []
    for iMesh in range(len(aSmeshMeshes)) :
        aMesh = Mesh(aSmeshMeshes[iMesh])
        aMeshes.append(aMesh)
    return aMeshes, aStatus

## Create Mesh object importing data from given STL file
#  @return an instance of Mesh class
def CreateMeshesFromSTL( theFileName ):
    aSmeshMesh = smesh.CreateMeshesFromSTL(theFileName)
    aMesh = Mesh(aSmeshMesh)
    return aMesh

## From SMESH_Gen interface
def GetSubShapesId( theMainObject, theListOfSubObjects ):
    return smesh.GetSubShapesId(theMainObject, theListOfSubObjects)


## Filtering. Auxiliary functions:
#  ------------------------------

## Creates an empty criterion
#  @return SMESH.Filter.Criterion
def GetEmptyCriterion():
    Type = EnumToLong(FT_Undefined)
    Compare = EnumToLong(FT_Undefined)
    Threshold = 0
    ThresholdStr = ""
    ThresholdID = ""
    UnaryOp = EnumToLong(FT_Undefined)
    BinaryOp = EnumToLong(FT_Undefined)
    Tolerance = 1e-07
    TypeOfElement = ALL
    Precision = -1 ##@1e-07
    return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID,
                            UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision)
      
## Creates a criterion by given parameters
#  @param elementType is the type of elements(NODE, EDGE, FACE, VOLUME)
#  @param CritType is type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
#  @param Compare belong to {FT_LessThan, FT_MoreThan, FT_EqualTo}
#  @param Treshold is threshold value (range of ids as string, shape, numeric)
#  @param UnaryOp is FT_LogicalNOT or FT_Undefined
#  @param BinaryOp is binary logical operation FT_LogicalAND, FT_LogicalOR or
#                  FT_Undefined(must be for the last criterion in criteria)
#  @return SMESH.Filter.Criterion
def GetCriterion(elementType,
                 CritType,
                 Compare = FT_EqualTo,
                 Treshold="",
                 UnaryOp=FT_Undefined,
                 BinaryOp=FT_Undefined):
    aCriterion = GetEmptyCriterion()
    aCriterion.TypeOfElement = elementType
    aCriterion.Type = EnumToLong(CritType)
        
    aTreshold = Treshold
        
    if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
        aCriterion.Compare = EnumToLong(Compare)
    else:
        aCriterion.Compare = EnumToLong(FT_EqualTo)
        aTreshold = Compare

    if CritType in [FT_BelongToGeom,     FT_BelongToPlane,
                    FT_BelongToCylinder, FT_LyingOnGeom]:
        # Check treshold
        if isinstance(aTreshold, geompy.GEOM._objref_GEOM_Object):
            aCriterion.ThresholdStr = GetName(aTreshold)
            aCriterion.ThresholdID = salome.ObjectToID(aTreshold)
        else:
            print "Error: Treshold should be a shape."
            return None
    elif CritType == FT_RangeOfIds:
        # Check treshold
        if isinstance(aTreshold, str):
            aCriterion.ThresholdStr = aTreshold
        else:
            print "Error: Treshold should be a string."
            return None
    elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume]:
        # Here we don't need treshold
        if aTreshold ==  FT_LogicalNOT:
            aCriterion.UnaryOp = EnumToLong(FT_LogicalNOT)
        elif aTreshold in [FT_LogicalAND, FT_LogicalOR]:
            aCriterion.BinaryOp = aTreshold
    else:
        # Check treshold
        try:
            aTreshold = float(aTreshold)
            aCriterion.Threshold = aTreshold
        except:
            print "Error: Treshold should be a number."
            return None

    if Treshold ==  FT_LogicalNOT or UnaryOp ==  FT_LogicalNOT:
        aCriterion.UnaryOp = EnumToLong(FT_LogicalNOT)

    if Treshold in [FT_LogicalAND, FT_LogicalOR]:
        aCriterion.BinaryOp = EnumToLong(Treshold)

    if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
        aCriterion.BinaryOp = EnumToLong(UnaryOp)

    if BinaryOp in [FT_LogicalAND, FT_LogicalOR]:
        aCriterion.BinaryOp = EnumToLong(BinaryOp)

    return aCriterion
  
    
## Mother class to define algorithm, recommended to don't use directly.
#
#  More details.

    def GetAlgorithm(self):
        return self.algo

    ## Get list of hypothesis that can be used with this algorithm
    def GetCompatibleHypothesis(self):
        list = []
        if self.algo:
            list = self.algo.GetCompatibleHypothesis()
        return list

    ## Get name of algo
    def GetName(self):
        GetName(self.algo)

    ## Set name to algo
    def SetName(self, name):
        SetName(self.algo, name)

    ## Get id of algo
    def GetId(self):
        return self.algo.GetId()
    
    ## Private method. Print error message if a hypothesis was not assigned.
    def TreatHypoStatus(self, status, hypName, geomName, isAlgo):
        if isAlgo:
            hypType = "algorithm"
        else:
            hypType = "hypothesis"
        if status == HYP_UNKNOWN_FATAL :
            reason = "for unknown reason"
        elif status == HYP_INCOMPATIBLE :
            reason = "this hypothesis mismatches algorithm"
        elif status == HYP_NOTCONFORM :
            reason = "not conform mesh would be built"
        elif status == HYP_ALREADY_EXIST :
            reason = hypType + " of the same dimension already assigned to this shape"
        elif status == HYP_BAD_DIM :
            reason = hypType + " mismatches shape"
        elif status == HYP_CONCURENT :
            reason = "there are concurrent hypotheses on sub-shapes"
        elif status == HYP_BAD_SUBSHAPE :
            reason = "shape is neither the main one, nor its subshape, nor a valid group"
        else:
            return
        hypName = '"' + hypName + '"'
        geomName= '"' + geomName+ '"'
        if status < HYP_UNKNOWN_FATAL:
            print hypName, "was assigned to",    geomName,"but", reason
        else:
            print hypName, "was not assigned to",geomName,":", reason
        pass
        
    ## Private method.
    def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
        if geom is None:

        SetName(self.algo, name + "/" + hypo)
        status = mesh.mesh.AddHypothesis(self.geom, self.algo)
        self.TreatHypoStatus( status, hypo, name, 1 )
        
    ## Private method
    def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
        hypo = smesh.CreateHypothesis(hyp, so)

        status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
        self.TreatHypoStatus( status, hyp, name, 0 )
        return hypo
       
# Public class: Mesh_Segment
# --------------------------


    ## Private constructor.
    def __init__(self, mesh, geom=0):
        self.Create(mesh, geom, "Regular_1D")
        
    ## Define "LocalLength" hypothesis to cut an edge in several segments with the same length
    #  @param l for the length of segments that cut an edge
    def LocalLength(self, l):
        hyp = self.Hypothesis("LocalLength", [l])
        hyp.SetLength(l)
        return hyp
        
    ## Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments
    #  @param n for the number of segments that cut an edge
    #  @param s for the scale factor (optional)

            hyp.SetScaleFactor(s)
        hyp.SetNumberOfSegments(n)
        return hyp
        
    ## Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
    #  @param start for the length of the first segment
    #  @param end   for the length of the last  segment

        hyp.SetLength(start, 1)
        hyp.SetLength(end  , 0)
        return hyp
        
    ## Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
    #  @param start for the length of the first segment
    #  @param end   for the length of the last  segment

        hyp.SetLength(start, 1)
        hyp.SetLength(end  , 0)
        return hyp
        
    ## Define "Deflection1D" hypothesis
    #  @param d for the deflection
    def Deflection1D(self, d):
        hyp = self.Hypothesis("Deflection1D", [d])
        hyp.SetDeflection(d)
        return hyp
        
    ## Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
    #  the opposite side in the case of quadrangular faces
    def Propagation(self):

    def __init__(self, mesh, geom=0):
        import Python1dPlugin
        self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
    
    ## Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
    #  @param n for the number of segments that cut an edge
    #  @param func for the python function that calculate the length of all segments

        hyp.SetNumberOfSegments(n)
        hyp.SetPythonLog10RatioFunction(func)
        return hyp
        
# Public class: Mesh_Triangle
# ---------------------------


#  More details.
class Mesh_Triangle(Mesh_Algorithm):

    algoType = 0
    params = 0
   
    ## Private constructor.
    def __init__(self, mesh, algoType, geom=0):
        if algoType == MEFISTO:
            self.Create(mesh, geom, "MEFISTO_2D")
        elif algoType == NETGEN:
            self.Create(mesh, geom, "NETGEN_2D", "libNETGENEngine.so")
        self.algoType = algoType

    ## Define "MaxElementArea" hypothesis to give the maximun area of each triangles
    #  @param area for the maximum area of each triangles
    def MaxElementArea(self, area):
        if self.algoType == MEFISTO:
            hyp = self.Hypothesis("MaxElementArea", [area])
            hyp.SetMaxElementArea(area)
            return hyp
        elif self.algoType == NETGEN:
            print "Netgen 1D-2D algo doesn't support this hypothesis"
            return None
            
    ## Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
    def LengthFromEdges(self):
        if self.algoType == MEFISTO:
            hyp = self.Hypothesis("LengthFromEdges")
            return hyp
        elif self.algoType == NETGEN:
            print "Netgen 1D-2D algo doesn't support this hypothesis"
            return None
        
    ## Define "Netgen 2D Parameters" hypothesis
    def Parameters(self):
        if self.algoType == NETGEN:
            self.params = self.Hypothesis("NETGEN_Parameters_2D", [], "libNETGENEngine.so")
            return self.params
        elif self.algoType == MEFISTO:
            print "Mefisto algo doesn't support this hypothesis"
            return None

    ## Set MaxSize
    def SetMaxSize(self, theSize):
        if self.params == 0:
            self.Parameters()
        self.params.SetMaxSize(theSize)
        
    ## Set SecondOrder flag
    def SetSecondOrder(seld, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetSecondOrder(theVal)

    ## Set Optimize flag
    def SetOptimize(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetOptimize(theVal)

    ## Set Fineness
    #  @param theFineness is:
    #  VeryCoarse, Coarse, Moderate, Fine, VeryFine or Custom
    def SetFineness(self, theFineness):
        if self.params == 0:
            self.Parameters()
        self.params.SetFineness(theFineness)
        
    ## Set GrowthRate  
    def SetGrowthRate(self, theRate):
        if self.params == 0:
            self.Parameters()
        self.params.SetGrowthRate(theRate)

    ## Set NbSegPerEdge
    def SetNbSegPerEdge(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetNbSegPerEdge(theVal)

    ## Set NbSegPerRadius
    def SetNbSegPerRadius(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetNbSegPerRadius(theVal)

    ## Set QuadAllowed flag
    def SetQuadAllowed(self, toAllow):
        if self.params == 0:
            self.Parameters()
        self.params.SetQuadAllowed(toAllow)
        
    
# Public class: Mesh_Quadrangle
# -----------------------------


    ## Private constructor.
    def __init__(self, mesh, geom=0):
        self.Create(mesh, geom, "Quadrangle_2D")
    
    ## Define "QuadranglePreference" hypothesis, forcing construction
    #  of quadrangles if the number of nodes on opposite edges is not the same
    #  in the case where the global number of nodes on edges is even
    def QuadranglePreference(self):
        hyp = self.Hypothesis("QuadranglePreference")
        return hyp
    
# Public class: Mesh_Tetrahedron
# ------------------------------


#  More details.
class Mesh_Tetrahedron(Mesh_Algorithm):

    params = 0
    algoType = 0

    ## Private constructor.
    def __init__(self, mesh, algoType, geom=0):
        if algoType == NETGEN:
            self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
        elif algoType == GHS3D:
            import GHS3DPlugin
            self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
        elif algoType == FULL_NETGEN:
            self.Create(mesh, geom, "NETGEN_2D3D", "libNETGENEngine.so")
        self.algoType = algoType

    ## Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
    #  @param vol for the maximum volume of each tetrahedral

        hyp.SetMaxElementVolume(vol)
        return hyp

    ## Define "Netgen 3D Parameters" hypothesis
    def Parameters(self):
        if (self.algoType == FULL_NETGEN):
            self.params = self.Hypothesis("NETGEN_Parameters", [], "libNETGENEngine.so")
            return self.params
        else:
            print "Algo doesn't support this hypothesis"
            return None 
            
    ## Set MaxSize
    def SetMaxSize(self, theSize):
        if self.params == 0:
            self.Parameters()
        self.params.SetMaxSize(theSize)
        
    ## Set SecondOrder flag
    def SetSecondOrder(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetSecondOrder(theVal)

    ## Set Optimize flag
    def SetOptimize(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetOptimize(theVal)

    ## Set Fineness
    #  @param theFineness is:
    #  VeryCoarse, Coarse, Moderate, Fine, VeryFine or Custom
    def SetFineness(self, theFineness):
        if self.params == 0:
            self.Parameters()
        self.params.SetFineness(theFineness)
        
    ## Set GrowthRate  
    def SetGrowthRate(self, theRate):
        if self.params == 0:
            self.Parameters()
        self.params.SetGrowthRate(theRate)

    ## Set NbSegPerEdge
    def SetNbSegPerEdge(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetNbSegPerEdge(theVal)

    ## Set NbSegPerRadius
    def SetNbSegPerRadius(self, theVal):
        if self.params == 0:
            self.Parameters()
        self.params.SetNbSegPerRadius(theVal)

# Public class: Mesh_Hexahedron
# ------------------------------


    def __init__(self, mesh, geom=0):
        self.Create(mesh, geom, "Hexa_3D")

# Deprecated, only for compatibility!
# Public class: Mesh_Netgen
# ------------------------------


        else:
            hyp = self.Hypothesis("NETGEN_Parameters_2D", [], "libNETGENEngine.so")
        return hyp
        
# Public class: Mesh
# ==================

## Class to define a mesh
#
#  The class contains mesh shape, SMESH_Mesh, SMESH_MeshEditor
#  More details.
class Mesh:

    geom = 0
    mesh = 0
    editor = 0

    ## Constructor
    #
    #  Creates mesh on the shape \a geom(or the empty mesh if geom equal to 0),
    #  sets GUI name of this mesh to \a name.
    #  @param obj Shape to be meshed or SMESH_Mesh object
    #  @param name Study name of the mesh
    def __init__(self, obj=0, name=0):
        if obj != 0:
            if isinstance(obj, geompy.GEOM._objref_GEOM_Object):
                self.geom = obj
                self.mesh = smesh.CreateMesh(self.geom)
            elif isinstance(obj, SMESH._objref_SMESH_Mesh):
                self.SetMesh(obj)
        else:
            self.mesh = smesh.CreateEmptyMesh()
        if name != 0:
            SetName(self.mesh, name)
        elif obj != 0:
            SetName(self.mesh, GetName(obj))

        self.editor = self.mesh.GetMeshEditor()

    ## Method that inits the Mesh object from SMESH_Mesh interface
    #  @param theMesh is SMESH_Mesh object
    def SetMesh(self, theMesh):
        self.mesh = theMesh
        self.geom = self.mesh.GetShapeToMesh()
            
    ## Method that returns the mesh
    #  @return SMESH_Mesh object
    def GetMesh(self):
        return self.mesh

    ## Get mesh name
    def GetName(self):
        name = GetName(self.GetMesh())
        return name

    ## Set name to mesh
    def SetName(self, name):
        SetName(self.GetMesh(), name)
    
    ## Get the subMesh object associated to a subShape. The subMesh object
    #  gives access to nodes and elements IDs.
    #  SubMesh will be used instead of SubShape in a next idl version to
    #  adress a specific subMesh...
    def GetSubMesh(self, theSubObject, name):
        submesh = self.mesh.GetSubMesh(theSubObject, name)
        return submesh
        
    ## Method that returns the shape associated to the mesh
    #  @return GEOM_Object
    def GetShape(self):
        return self.geom

    ## Method that associates given shape to the mesh(entails the mesh recreation)
    #  @param geom shape to be meshed(GEOM_Object)
    def SetShape(self, geom):
        self.mesh = smesh.CreateMesh(geom)  
                
    ## Return true if hypotheses are defined well
    #  @param theMesh is an instance of Mesh class
    #  @param theSubObject subshape of a mesh shape
    def IsReadyToCompute(self, theSubObject):
        return smesh.IsReadyToCompute(self.mesh, theSubObject)

    ## Return errors of hypotheses definintion
    #  error list is empty if everything is OK
    #  @param theMesh is an instance of Mesh class
    #  @param theSubObject subshape of a mesh shape
    #  @return a list of errors
    def GetAlgoState(self, theSubObject):
        return smesh.GetAlgoState(self.mesh, theSubObject)
    
    ## Return geometrical object the given element is built on.
    #  The returned geometrical object, if not nil, is either found in the 
    #  study or is published by this method with the given name
    #  @param theMesh is an instance of Mesh class
    #  @param theElementID an id of the mesh element
    #  @param theGeomName user defined name of geometrical object
    #  @return GEOM::GEOM_Object instance
    def GetGeometryByMeshElement(self, theElementID, theGeomName):
        return smesh.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName )
        
    ## Returns mesh dimension depending on shape one
    def MeshDimension(self):
        shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )

        else:
            return 0;
        pass
        
    ## Creates a segment discretization 1D algorithm.
    #  If the optional \a algo parameter is not sets, this algorithm is REGULAR.
    #  If the optional \a geom parameter is not sets, this algorithm is global.

            return Mesh_Segment_Python(self, geom)
        else:
            return Mesh_Segment(self, geom)
        
    ## Creates a triangle 2D algorithm for faces.
    #  If the optional \a geom parameter is not sets, this algorithm is global.
    #  Otherwise, this algorithm define a submesh based on \a geom subshape.
    #  @param algo values are: smesh.MEFISTO or smesh.NETGEN
    #  @param geom If defined, subshape to be meshed
    def Triangle(self, algo=MEFISTO, geom=0):
        ## if Triangle(geom) is called by mistake
        if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
            geom = algo
            algo = MEFISTO
        
        return Mesh_Triangle(self, algo, geom)
        
    ## Creates a quadrangle 2D algorithm for faces.
    #  If the optional \a geom parameter is not sets, this algorithm is global.
    #  Otherwise, this algorithm define a submesh based on \a geom subshape.

    #  The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
    #  If the optional \a geom parameter is not sets, this algorithm is global.
    #  Otherwise, this algorithm define a submesh based on \a geom subshape.
    #  @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.FULL_NETGEN
    #  @param geom If defined, subshape to be meshed
    def Tetrahedron(self, algo=NETGEN, geom=0):
        ## if Tetrahedron(geom) is called by mistake
        if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
            algo, geom = geom, algo
            pass
        return Mesh_Tetrahedron(self, algo, geom)
        
    ## Creates a hexahedron 3D algorithm for solids.
    #  If the optional \a geom parameter is not sets, this algorithm is global.
    #  Otherwise, this algorithm define a submesh based on \a geom subshape.

    def Hexahedron(self, geom=0):
        return Mesh_Hexahedron(self, geom)

    ## Deprecated, only for compatibility!
    #  Creates a NETGEN-based 2D or 3D independent algorithm (i.e. needs no
    #  discrete boundary).
    #  If the optional \a geom parameter is not sets, this algorithm is global.
    #  Otherwise, this algorithm defines a submesh based on \a geom subshape.

    #  @param geom If defined, subshape to be meshed
    def Netgen(self, is3D, geom=0):
        return Mesh_Netgen(self, is3D, geom)
      
    ## Compute the mesh and return the status of the computation
    def Compute(self, geom=0):
        if geom == 0 or not isinstance(geom, geompy.GEOM._objref_GEOM_Object):
            if self.geom == 0:
                print "Compute impossible: mesh is not constructed on geom shape."
                return 0
            else:
                geom = self.geom
        ok = smesh.Compute(self.mesh, geom)
        if not ok:
            errors = smesh.GetAlgoState( self.mesh, geom )
            allReasons = ""
            for err in errors:
                if err.isGlobalAlgo:

                    glob = " local "
                    pass
                dim = str(err.algoDim)
                if err.name == MISSING_ALGO:
                    reason = glob + dim + "D algorithm is missing"
                elif err.name == MISSING_HYPO:
                    name = '"' + err.algoName + '"'
                    reason = glob + dim + "D algorithm " + name + " misses " + dim + "D hypothesis"
                else:

            self.Tetrahedron(NETGEN)
            pass
        return self.Compute()
        
    ## Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
    #  The parameter \a fineness [0.-1.] defines mesh fineness
    def AutomaticHexahedralization(self, fineness=0):

            self.Hexahedron()            
            pass
        return self.Compute()
    
    ## Get the list of hypothesis added on a geom
    #  @param geom is subhape of mesh geometry
    def GetHypothesisList(self, geom):
        return self.mesh.GetHypothesisList( geom )
                
    ## Removes all global hypotheses
    def RemoveGlobalHypotheses(self):
        current_hyps = self.mesh.GetHypothesisList( self.geom )

            self.mesh.RemoveHypothesis( self.geom, hyp )
            pass
        pass
        
    ## Create a mesh group based on geometric object \a grp
    #  and give a \a name, if this parameter is not defined
    #  the name is the same as the geometric group name
    #  Note: this function is obsolete. Works like GroupOnGeom(). 
    #  @param grp  is a geometric group, a vertex, an edge, a face or a solid
    #  @param name is the name of the mesh group
    #  @return SMESH_GroupOnGeom
    def Group(self, grp, name=""):
        return self.GroupOnGeom(grp, name)
       
    ## Deprecated, only for compatibility! Please, use ExportMED() method instead.
    #  Export the mesh in a file with the MED format and choice the \a version of MED format
        tgeo = str(grp.GetShapeType())
        if tgeo == "VERTEX":
            type = SMESH.NODE
        elif tgeo == "EDGE":
            type = SMESH.EDGE
        elif tgeo == "FACE":
            type = SMESH.FACE
        elif tgeo == "SOLID":
            type = SMESH.VOLUME
        elif tgeo == "SHELL":
            type = SMESH.VOLUME
        elif tgeo == "COMPOUND":
            if len( geompy.GetObjectIDs( grp )) == 0:
                print "Mesh.Group: empty geometric group", GetName( grp )
                return 0
            tgeo = geompy.GetType(grp)
            if tgeo == geompy.ShapeType["VERTEX"]:
                type = SMESH.NODE
            elif tgeo == geompy.ShapeType["EDGE"]:
                type = SMESH.EDGE
            elif tgeo == geompy.ShapeType["FACE"]:
                type = SMESH.FACE
            elif tgeo == geompy.ShapeType["SOLID"]:
                type = SMESH.VOLUME

        if type == []:
            print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
            return 0
        else:
            return self.mesh.CreateGroupFromGEOM(type, name, grp)

    ## Export the mesh in a file with the MED format and choice the \a version of MED format
    #  @param f is the file name
    #  @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
    def ExportToMED(self, f, version, opt=0):
        self.mesh.ExportToMED(f, opt, version)
        
    ## Export the mesh in a file with the MED format
    #  @param f is the file name
    #  @param auto_groups boolean parameter for creating/not creating
    #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
    #  the typical use is auto_groups=false.
    #  @param version MED format version(MED_V2_1 or MED_V2_2)
    def ExportMED(self, f, auto_groups=0, version=MED_V2_2):
        self.mesh.ExportToMED(f, auto_groups, version)
        
    ## Export the mesh in a file with the DAT format
    #  @param f is the file name
    def ExportDAT(self, f):
        self.mesh.ExportDAT(f)
        
    ## Export the mesh in a file with the UNV format
    #  @param f is the file name
    def ExportUNV(self, f):
        self.mesh.ExportUNV(f)
        
    ## Export the mesh in a file with the STL format
    #  @param f is the file name
    #  @param ascii defined the kind of file contents
    def ExportSTL(self, f, ascii=1):
        self.mesh.ExportSTL(f, ascii)
    
    ###################################################################################
        
    ## Operations with groups
    #  ----------------------

    ## Creates an empty mesh group
    #  @param elementType is the type of elements in the group
    #  @param name is the name of the mesh group
    #  @return SMESH_Group
    def CreateEmptyGroup(self, elementType, name):
        return self.mesh.CreateGroup(elementType, name)
    
    ## Creates a mesh group based on geometric object \a grp
    #  and give a \a name, if this parameter is not defined
    #  the name is the same as the geometric group name
    #  @param grp  is a geometric group, a vertex, an edge, a face or a solid
    #  @param name is the name of the mesh group
    #  @return SMESH_GroupOnGeom
    def GroupOnGeom(self, grp, name="", type=None):
        if name == "":
            name = grp.GetName()

        if type == None:
            tgeo = str(grp.GetShapeType())
            if tgeo == "VERTEX":
                type = NODE
            elif tgeo == "EDGE":
                type = EDGE
            elif tgeo == "FACE":
                type = FACE
            elif tgeo == "SOLID":
                type = VOLUME
            elif tgeo == "SHELL":
                type = VOLUME
            elif tgeo == "COMPOUND":
                if len( geompy.GetObjectIDs( grp )) == 0:
                    print "Mesh.Group: empty geometric group", GetName( grp )
                    return 0
                tgeo = geompy.GetType(grp)
                if tgeo == geompy.ShapeType["VERTEX"]:
                    type = NODE
                elif tgeo == geompy.ShapeType["EDGE"]:
                    type = EDGE
                elif tgeo == geompy.ShapeType["FACE"]:
                    type = FACE
                elif tgeo == geompy.ShapeType["SOLID"]:
                    type = VOLUME

        if type == None:
            print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
            return 0
        else:
            return self.mesh.CreateGroupFromGEOM(type, name, grp)

    ## Create a mesh group by the given ids of elements
    #  @param groupName is the name of the mesh group
    #  @param elementType is the type of elements in the group
    #  @param elemIDs is the list of ids
    #  @return SMESH_Group
    def MakeGroupByIds(self, groupName, elementType, elemIDs):
        group = self.mesh.CreateGroup(elementType, groupName)
        group.Add(elemIDs)
        return group
    
    ## Create a mesh group by the given conditions
    #  @param groupName is the name of the mesh group
    #  @param elementType is the type of elements in the group
    #  @param CritType is type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
    #  @param Compare belong to {FT_LessThan, FT_MoreThan, FT_EqualTo}
    #  @param Treshold is threshold value (range of id ids as string, shape, numeric)
    #  @param UnaryOp is FT_LogicalNOT or FT_Undefined
    #  @return SMESH_Group
    def MakeGroup(self,
                  groupName,
                  elementType,
                  CritType=FT_Undefined,
                  Compare=FT_EqualTo,
                  Treshold="",
                  UnaryOp=FT_Undefined):
        aCriterion = GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
        group = self.MakeGroupByCriterion(groupName, aCriterion)
        return group

    ## Create a mesh group by the given criterion
    #  @param groupName is the name of the mesh group
    #  @param Criterion is the instance of Criterion class
    #  @return SMESH_Group
    def MakeGroupByCriterion(self, groupName, Criterion):
        aFilterMgr = smesh.CreateFilterManager()
        aFilter = aFilterMgr.CreateFilter()
        aCriteria = []
        aCriteria.append(Criterion)
        aFilter.SetCriteria(aCriteria)
        group = self.MakeGroupByFilter(groupName, aFilter)
        return group
    
    ## Create a mesh group by the given criteria(list of criterions)
    #  @param groupName is the name of the mesh group
    #  @param Criteria is the list of criterions
    #  @return SMESH_Group
    def MakeGroupByCriteria(self, groupName, theCriteria):
        aFilterMgr = smesh.CreateFilterManager()
        aFilter = aFilterMgr.CreateFilter()
        aFilter.SetCriteria(theCriteria)
        group = self.MakeGroupByFilter(groupName, aFilter)
        return group
    
    ## Create a mesh group by the given filter
    #  @param groupName is the name of the mesh group
    #  @param Criterion is the instance of Filter class
    #  @return SMESH_Group
    def MakeGroupByFilter(self, groupName, theFilter):
        anIds = theFilter.GetElementsId(self.mesh)
        anElemType = theFilter.GetElementType()
        group = self.MakeGroupByIds(groupName, anElemType, anIds)
        return group

    ## Creates filter by given parameters of criterion
    #  @param elementType is the type of elements in the group
    #  @param CritType is type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
    #  @param Compare belong to {FT_LessThan, FT_MoreThan, FT_EqualTo}
    #  @param Treshold is threshold value (range of id ids as string, shape, numeric)
    #  @param UnaryOp is FT_LogicalNOT or FT_Undefined
    #  @return SMESH_Filter
    def GetFilter(self,
                  elementType,
                  CritType=FT_Undefined,
                  Compare=FT_EqualTo,
                  Treshold="",
                  UnaryOp=FT_Undefined):
        aCriterion = GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
        aFilterMgr = smesh.CreateFilterManager()
        aFilter = aFilterMgr.CreateFilter()
        aCriteria = []
        aCriteria.append(aCriterion)
        aFilter.SetCriteria(aCriteria)
        return aFilter
        
    ## Remove a group
    def RemoveGroup(self, group):
        self.mesh.RemoveGroup(group)

    ## Remove group with its contents
    def RemoveGroupWithContents(self, group):
        self.mesh.RemoveGroupWithContents(group)
        
    ## Get the list of groups existing in the mesh
    def GetGroups(self):
        return self.mesh.GetGroups()

    ## Get the list of names of groups existing in the mesh
    def GetGroupNames(self):
        groups = self.GetGroups()
        names = []
        for group in groups:
            names.append(group.GetName())
        return names

    ## Union of two groups
    #  New group is created. All mesh elements that are
    #  present in initial groups are added to the new one
    def UnionGroups(self, group1, group2, name):
        return self.mesh.UnionGroups(group1, group2, name)

    ## Intersection of two groups
    #  New group is created. All mesh elements that are
    #  present in both initial groups are added to the new one.
    def IntersectGroups(self, group1, group2, name):
        return self.mesh.IntersectGroups(group1, group2, name)
    
    ## Cut of two groups
    #  New group is created. All mesh elements that are present in
    #  main group but do not present in tool group are added to the new one
    def CutGroups(self, mainGroup, toolGroup, name):
        return self.mesh.CutGroups(mainGroup, toolGroup, name)
         
    
    ## Get some info about mesh:
    #  ------------------------

    ## Get the log of nodes and elements added or removed since previous
    #  clear of the log.
    #  @param clearAfterGet log is emptied after Get (safe if concurrents access)
    #  @return list of log_block structures:
    #                                        commandType
    #                                        number
    #                                        coords
    #                                        indexes
    def GetLog(self, clearAfterGet):
        return self.mesh.GetLog(clearAfterGet)

    ## Clear the log of nodes and elements added or removed since previous
    #  clear. Must be used immediately after GetLog if clearAfterGet is false.
    def ClearLog(self):
        self.mesh.ClearLog()

    ## Get the internal Id
    def GetId(self):
        return self.mesh.GetId()

    ## Get the study Id
    def GetStudyId(self):
        return self.mesh.GetStudyId()

    ## Check group names for duplications.
    #  Consider maximum group name length stored in MED file.
    def HasDuplicatedGroupNamesMED(self):
        return self.mesh.GetStudyId()
        
    ## Obtain instance of SMESH_MeshEditor
    def GetMeshEditor(self):
        return self.mesh.GetMeshEditor()

    ## Get MED Mesh
    def GetMEDMesh(self):
        return self.mesh.GetMEDMesh()
    
    
    ## Get informations about mesh contents:
    #  ------------------------------------

    ## Returns number of nodes in mesh
    def NbNodes(self):
        return self.mesh.NbNodes()

    ## Returns number of elements in mesh
    def NbElements(self):
        return self.mesh.NbElements()

    ## Returns number of edges in mesh
    def NbEdges(self):
        return self.mesh.NbEdges()

    ## Returns number of edges with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbEdgesOfOrder(self, elementOrder):
        return self.mesh.NbEdgesOfOrder(elementOrder)
    
    ## Returns number of faces in mesh
    def NbFaces(self):
        return self.mesh.NbFaces()

    ## Returns number of faces with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbFacesOfOrder(self, elementOrder):
        return self.mesh.NbFacesOfOrder(elementOrder)

    ## Returns number of triangles in mesh
    def NbTriangles(self):
        return self.mesh.NbTriangles()

    ## Returns number of triangles with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbTrianglesOfOrder(self, elementOrder):
        return self.mesh.NbTrianglesOfOrder(elementOrder)

    ## Returns number of quadrangles in mesh
    def NbQuadrangles(self):
        return self.mesh.NbQuadrangles()

    ## Returns number of quadrangles with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbQuadranglesOfOrder(self, elementOrder):
        return self.mesh.NbQuadranglesOfOrder(elementOrder)

    ## Returns number of polygons in mesh
    def NbPolygons(self):
        return self.mesh.NbPolygons()

    ## Returns number of volumes in mesh
    def NbVolumes(self):
        return self.mesh.NbVolumes()

    ## Returns number of volumes with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbVolumesOfOrder(self, elementOrder):
        return self.mesh.NbVolumesOfOrder(elementOrder)

    ## Returns number of tetrahedrons in mesh
    def NbTetras(self):
        return self.mesh.NbTetras()

    ## Returns number of tetrahedrons with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbTetrasOfOrder(self, elementOrder):
        return self.mesh.NbTetrasOfOrder(elementOrder)

    ## Returns number of hexahedrons in mesh
    def NbHexas(self):
        return self.mesh.NbHexas()

    ## Returns number of hexahedrons with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbHexasOfOrder(self, elementOrder):
        return self.mesh.NbHexasOfOrder(elementOrder)

    ## Returns number of pyramids in mesh
    def NbPyramids(self):
        return self.mesh.NbPyramids()

    ## Returns number of pyramids with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbPyramidsOfOrder(self, elementOrder):
        return self.mesh.NbPyramidsOfOrder(elementOrder)

    ## Returns number of prisms in mesh
    def NbPrisms(self):
        return self.mesh.NbPrisms()

    ## Returns number of prisms with given order in mesh
    #  @param elementOrder is order of elements:
    #  ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
    def NbPrismsOfOrder(self, elementOrder):
        return self.mesh.NbPrismsOfOrder(elementOrder)

    ## Returns number of polyhedrons in mesh
    def NbPolyhedrons(self):
        return self.mesh.NbPolyhedrons()

    ## Returns number of submeshes in mesh
    def NbSubMesh(self):
        return self.mesh.NbSubMesh()

    ## Returns list of mesh elements ids
    def GetElementsId(self):
        return self.mesh.GetElementsId()

    ## Returns list of ids of mesh elements with given type
    #  @param elementType is required type of elements
    def GetElementsByType(self, elementType):
        return self.mesh.GetElementsByType(elementType)

    ## Returns list of mesh nodes ids
    def GetNodesId(self):
        return self.mesh.GetNodesId()
    
    ## Get informations about mesh elements:
    #  ------------------------------------
    
    ## Returns type of mesh element
    def GetElementType(self, id, iselem):
        return self.mesh.GetElementType(id, iselem)

    ## Returns list of submesh elements ids
    #  @param shapeID is geom object(subshape) IOR
    def GetSubMeshElementsId(self, shapeID):
        return self.mesh.GetSubMeshElementsId(shapeID)

    ## Returns list of submesh nodes ids
    #  @param shapeID is geom object(subshape) IOR
    def GetSubMeshNodesId(self, shapeID, all):
        return self.mesh.GetSubMeshNodesId(shapeID, all)
    
    ## Returns list of ids of submesh elements with given type
    #  @param shapeID is geom object(subshape) IOR
    def GetSubMeshElementType(self, shapeID):
        return self.mesh.GetSubMeshElementType(shapeID)
      
    ## Get mesh description
    def Dump(self):
        return self.mesh.Dump()

    
    ## Get information about nodes and elements of mesh by its ids:
    #  -----------------------------------------------------------

    ## Get XYZ coordinates of node as list of double
    #  If there is not node for given ID - returns empty list
    def GetNodeXYZ(self, id):
        return self.mesh.GetNodeXYZ(id)

    ## For given node returns list of IDs of inverse elements
    #  If there is not node for given ID - returns empty list
    def GetNodeInverseElements(self, id):
        return self.mesh.GetNodeInverseElements(id)
    
    ## If given element is node returns IDs of shape from position
    # else - return ID of result shape after Mesh.FindShape()
    # If there is not element for given ID - returns -1
    def GetShapeID(self, id):
        return self.mesh.GetShapeID(id)

    ## Returns number of nodes for given element
    #  If there is not element for given ID - returns -1
    def GetElemNbNodes(self, id):
        return self.mesh.GetElemNbNodes(id)

    ## Returns ID of node by given index for given element
    #  If there is not element for given ID - returns -1
    #  If there is not node for given index - returns -2
    def GetElemNode(self, id, index):
        return self.mesh.GetElemNode(id, index)

    ## Returns true if given node is medium node
    #  in given quadratic element
    def IsMediumNode(self, elementID, nodeID):
        return self.mesh.IsMediumNode(elementID, nodeID)
    
    ## Returns true if given node is medium node
    #  in one of quadratic elements
    def IsMediumNodeOfAnyElem(self, nodeID, elementType):
        return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType)

    ## Returns number of edges for given element
    def ElemNbEdges(self, id):
        return self.mesh.ElemNbEdges(id)
        
    ## Returns number of faces for given element
    def ElemNbFaces(self, id):
        return self.mesh.ElemNbFaces(id)

    ## Returns true if given element is polygon
    def IsPoly(self, id):
        return self.mesh.IsPoly(id)

    ## Returns true if given element is quadratic
    def IsQuadratic(self, id):
        return self.mesh.IsQuadratic(id)

    ## Returns XYZ coordinates of bary center for given element
    #  as list of double
    #  If there is not element for given ID - returns empty list
    def BaryCenter(self, id):
        return self.mesh.BaryCenter(id)
    
    
    ## Mesh edition (SMESH_MeshEditor functionality):
    #  ---------------------------------------------

    ## Removes elements from mesh by ids
    #  @param IDsOfElements is list of ids of elements to remove
    def RemoveElements(self, IDsOfElements):
        return self.editor.RemoveElements(IDsOfElements)

    ## Removes nodes from mesh by ids
    #  @param IDsOfNodes is list of ids of nodes to remove
    def RemoveNodes(self, IDsOfNodes):
        return self.editor.RemoveNodes(IDsOfNodes)

    ## Add node to mesh by coordinates
    def AddNode(self, x, y, z):
        return self.editor.AddNode( x, y, z)

    
    ## Create edge both similar and quadratic (this is determed
    #  by number of given nodes).
    #  @param IdsOfNodes List of node IDs for creation of element.
    #  Needed order of nodes in this list corresponds to description
    #  of MED. This description is located by the following link:
    #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
    def AddEdge(self, IDsOfNodes):
        return self.editor.AddEdge(IDsOfNodes)

    ## Create face both similar and quadratic (this is determed
    #  by number of given nodes).
    #  @param IdsOfNodes List of node IDs for creation of element.
    #  Needed order of nodes in this list corresponds to description
    #  of MED. This description is located by the following link:
    #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
    def AddFace(self, IDsOfNodes):
        return self.editor.AddFace(IDsOfNodes)
    
    ## Add polygonal face to mesh by list of nodes ids
    def AddPolygonalFace(self, IdsOfNodes):
        return self.editor.AddPolygonalFace(IdsOfNodes)
    
    ## Create volume both similar and quadratic (this is determed
    #  by number of given nodes).
    #  @param IdsOfNodes List of node IDs for creation of element.
    #  Needed order of nodes in this list corresponds to description
    #  of MED. This description is located by the following link:
    #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
    def AddVolume(self, IDsOfNodes):
        return self.editor.AddVolume(IDsOfNodes)

    ## Create volume of many faces, giving nodes for each face.
    #  @param IdsOfNodes List of node IDs for volume creation face by face.
    #  @param Quantities List of integer values, Quantities[i]
    #         gives quantity of nodes in face number i.
    def AddPolyhedralVolume (self, IdsOfNodes, Quantities):
        return self.editor.AddPolyhedralVolume(IdsOfNodes, Quantities)

    ## Create volume of many faces, giving IDs of existing faces.
    #  @param IdsOfFaces List of face IDs for volume creation.
    #
    #  Note:  The created volume will refer only to nodes
    #         of the given faces, not to the faces itself.
    def AddPolyhedralVolumeByFaces (self, IdsOfFaces):
        return self.editor.AddPolyhedralVolumeByFaces(IdsOfFaces)
    
    ## Move node with given id
    #  @param NodeID id of the node
    #  @param x displacing along the X axis
    #  @param y displacing along the Y axis
    #  @param z displacing along the Z axis
    def MoveNode(self, NodeID, x, y, z):
        return self.editor.MoveNode(NodeID, x, y, z)

    ## Replace two neighbour triangles sharing Node1-Node2 link
    #  with ones built on the same 4 nodes but having other common link.
    #  @param NodeID1 first node id
    #  @param NodeID2 second node id
    #  @return false if proper faces not found
    def InverseDiag(self, NodeID1, NodeID2):
        return self.editor.InverseDiag(NodeID1, NodeID2)

    ## Replace two neighbour triangles sharing Node1-Node2 link
    #  with a quadrangle built on the same 4 nodes.
    #  @param NodeID1 first node id
    #  @param NodeID2 second node id
    #  @return false if proper faces not found
    def DeleteDiag(self, NodeID1, NodeID2):
        return self.editor.DeleteDiag(NodeID1, NodeID2)

    ## Reorient elements by ids
    #  @param IDsOfElements if undefined reorient all mesh elements
    def Reorient(self, IDsOfElements=None):
        if IDsOfElements == None:
            IDsOfElements = self.GetElementsId()
        return self.editor.Reorient(IDsOfElements)

    ## Reorient all elements of the object
    #  @param theObject is mesh, submesh or group
    def ReorientObject(self, theObject):
        return self.editor.ReorientObject(theObject)

    ## Fuse neighbour triangles into quadrangles.
    #  @param IDsOfElements The triangles to be fused,
    #  @param Criterion     is used to choose a neighbour to fuse with.
    #  @param MaxAngle      is a max angle between element normals at which fusion
    #                       is still performed; theMaxAngle is mesured in radians.
    #  @return TRUE in case of success, FALSE otherwise.
    def TriToQuad(self, IDsOfElements, Criterion, MaxAngle):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        return self.editor.TriToQuad(IDsOfElements, Criterion, MaxAngle)

    ## Fuse neighbour triangles of the object into quadrangles
    #  @param theObject is mesh, submesh or group
    #  @param Criterion is used to choose a neighbour to fuse with.
    #  @param MaxAngle  is a max angle between element normals at which fusion
    #                   is still performed; theMaxAngle is mesured in radians.
    #  @return TRUE in case of success, FALSE otherwise.
    def TriToQuadObject (self, theObject, Criterion, MaxAngle):
        return self.editor.TriToQuadObject(theObject, Criterion, MaxAngle)

    ## Split quadrangles into triangles.
    #  @param IDsOfElements the faces to be splitted.
    #  @param theCriterion  is used to choose a diagonal for splitting.
    #  @param @return TRUE in case of success, FALSE otherwise.
    def QuadToTri (self, IDsOfElements, Criterion):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        return self.editor.QuadToTri(IDsOfElements, Criterion)

    ## Split quadrangles into triangles.
    #  @param theObject object to taking list of elements from, is mesh, submesh or group
    def QuadToTriObject (self, theObject, Criterion):
        return self.editor.QuadToTriObject(theObject, Criterion)

    ## Split quadrangles into triangles.
    #  @param theElems  The faces to be splitted
    #  @param the13Diag is used to choose a diagonal for splitting.
    #  @return TRUE in case of success, FALSE otherwise.
    def SplitQuad (self, IDsOfElements, Diag13):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        return self.editor.SplitQuad(IDsOfElements, Diag13)

    ## Split quadrangles into triangles.
    #  @param theObject is object to taking list of elements from, is mesh, submesh or group
    def SplitQuadObject (self, theObject, Diag13):
        return self.editor.SplitQuadObject(theObject, Diag13)

    ## Find better splitting of the given quadrangle.
    #  @param IDOfQuad  ID of the quadrangle to be splitted.
    #  @param Criterion is a criterion to choose a diagonal for splitting.
    #  @return 1 if 1-3 diagonal is better, 2 if 2-4
    #          diagonal is better, 0 if error occurs.
    def BestSplit (self, IDOfQuad, Criterion):
        return self.editor.BestSplit(IDOfQuad, Criterion)
    
    ## Smooth elements
    #  @param IDsOfElements list if ids of elements to smooth
    #  @param IDsOfFixedNodes list of ids of fixed nodes.
    #  Note that nodes built on edges and boundary nodes are always fixed.
    #  @param MaxNbOfIterations maximum number of iterations
    #  @param MaxAspectRatio varies in range [1.0, inf]
    #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
    def Smooth(self, IDsOfElements, IDsOfFixedNodes,
               MaxNbOfIterations, MaxAspectRatio, Method):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
                                  MaxNbOfIterations, MaxAspectRatio, Method)
    
    ## Smooth elements belong to given object
    #  @param theObject object to smooth
    #  @param IDsOfFixedNodes list of ids of fixed nodes.
    #  Note that nodes built on edges and boundary nodes are always fixed.
    #  @param MaxNbOfIterations maximum number of iterations
    #  @param MaxAspectRatio varies in range [1.0, inf]
    #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
    def SmoothObject(self, theObject, IDsOfFixedNodes, 
                     MaxNbOfIterations, MaxxAspectRatio, Method):
        return self.editor.SmoothObject(theObject, IDsOfFixedNodes, 
                                        MaxNbOfIterations, MaxxAspectRatio, Method)

    ## Parametric smooth the given elements
    #  @param IDsOfElements list if ids of elements to smooth
    #  @param IDsOfFixedNodes list of ids of fixed nodes.
    #  Note that nodes built on edges and boundary nodes are always fixed.
    #  @param MaxNbOfIterations maximum number of iterations
    #  @param MaxAspectRatio varies in range [1.0, inf]
    #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
    def SmoothParametric(IDsOfElements, IDsOfFixedNodes,
                         MaxNbOfIterations, MaxAspectRatio, Method):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
                                            MaxNbOfIterations, MaxAspectRatio, Method)
    
    ## Parametric smooth elements belong to given object
    #  @param theObject object to smooth
    #  @param IDsOfFixedNodes list of ids of fixed nodes.
    #  Note that nodes built on edges and boundary nodes are always fixed.
    #  @param MaxNbOfIterations maximum number of iterations
    #  @param MaxAspectRatio varies in range [1.0, inf]
    #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
    def SmoothParametricObject(self, theObject, IDsOfFixedNodes,
                               MaxNbOfIterations, MaxAspectRatio, Method):
        return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
                                                  MaxNbOfIterations, MaxAspectRatio, Method)

    ## Converts all mesh to quadratic one, deletes old elements, replacing 
    #  them with quadratic ones with the same id.
    def ConvertToQuadratic(self, theForce3d):
        self.editor.ConvertToQuadratic(theForce3d)

    ## Converts all mesh from quadratic to ordinary ones,
    #  deletes old quadratic elements, replacing 
    #  them with ordinary mesh elements with the same id.
    def ConvertFromQuadratic(self):
        return self.editor.ConvertFromQuadratic()

    ## Renumber mesh nodes
    def RenumberNodes(self):
        self.editor.RenumberNodes()

    ## Renumber mesh elements
    def RenumberElements(self):
        self.editor.RenumberElements()

    ## Generate new elements by rotation of the elements around the axis
    #  @param IDsOfElements list of ids of elements to sweep
    #  @param Axix axis of rotation, AxisStruct or line(geom object)
    #  @param AngleInRadians angle of Rotation
    #  @param NbOfSteps number of steps
    #  @param Tolerance tolerance
    def RotationSweep(self, IDsOfElements, Axix, AngleInRadians, NbOfSteps, Tolerance):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( Axix, geompy.GEOM._objref_GEOM_Object)):
            Axix = GetAxisStruct(Axix)
        self.editor.RotationSweep(IDsOfElements, Axix, AngleInRadians, NbOfSteps, Tolerance)

    ## Generate new elements by rotation of the elements of object around the axis
    #  @param theObject object wich elements should be sweeped
    #  @param Axix axis of rotation, AxisStruct or line(geom object)
    #  @param AngleInRadians angle of Rotation
    #  @param NbOfSteps number of steps
    #  @param Tolerance tolerance
    def RotationSweepObject(self, theObject, Axix, AngleInRadians, NbOfSteps, Tolerance):
        if ( isinstance( Axix, geompy.GEOM._objref_GEOM_Object)):
            Axix = GetAxisStruct(Axix)
        self.editor.RotationSweepObject(theObject, Axix, AngleInRadians, NbOfSteps, Tolerance)

    ## Generate new elements by extrusion of the elements with given ids
    #  @param IDsOfElements list of elements ids for extrusion
    #  @param StepVector vector, defining the direction and value of extrusion 
    #  @param NbOfSteps the number of steps
    def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( StepVector, geompy.GEOM._objref_GEOM_Object)):
            StepVector = GetDirStruct(StepVector)
        self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)

    ## Generate new elements by extrusion of the elements with given ids
    #  @param IDsOfElements is ids of elements
    #  @param StepVector vector, defining the direction and value of extrusion 
    #  @param NbOfSteps the number of steps
    #  @param ExtrFlags set flags for performing extrusion
    #  @param SewTolerance uses for comparing locations of nodes if flag
    #         EXTRUSION_FLAG_SEW is set
    def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps, ExtrFlags, SewTolerance):
        if ( isinstance( StepVector, geompy.GEOM._objref_GEOM_Object)):
            StepVector = GetDirStruct(StepVector)
        self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps, ExtrFlags, SewTolerance)

    ## Generate new elements by extrusion of the elements belong to object
    #  @param theObject object wich elements should be processed
    #  @param StepVector vector, defining the direction and value of extrusion 
    #  @param NbOfSteps the number of steps
    def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps):
        if ( isinstance( StepVector, geompy.GEOM._objref_GEOM_Object)):
            StepVector = GetDirStruct(StepVector)
        self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)

    ## Generate new elements by extrusion of the elements belong to object
    #  @param theObject object wich elements should be processed
    #  @param StepVector vector, defining the direction and value of extrusion 
    #  @param NbOfSteps the number of steps
    def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps):
        if ( isinstance( StepVector, geompy.GEOM._objref_GEOM_Object)):
            StepVector = GetDirStruct(StepVector)
        self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps)
    
    ## Generate new elements by extrusion of the elements belong to object
    #  @param theObject object wich elements should be processed
    #  @param StepVector vector, defining the direction and value of extrusion 
    #  @param NbOfSteps the number of steps    
    def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps):
        if ( isinstance( StepVector, geompy.GEOM._objref_GEOM_Object)):
            StepVector = GetDirStruct(StepVector)
        self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps)

    ## Generate new elements by extrusion of the given elements
    #  A path of extrusion must be a meshed edge.
    #  @param IDsOfElements is ids of elements
    #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
    #  @param PathShape is shape(edge); as the mesh can be complex, the edge is used to define the sub-mesh for the path
    #  @param NodeStart the first or the last node on the edge. It is used to define the direction of extrusion
    #  @param HasAngles allows the shape to be rotated around the path to get the resulting mesh in a helical fashion
    #  @param Angles list of angles
    #  @param HasRefPoint allows to use base point 
    #  @param RefPoint point around which the shape is rotated(the mass center of the shape by default).
    #         User can specify any point as the Base Point and the shape will be rotated with respect to this point.
    def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart,
                           HasAngles, Angles, HasRefPoint, RefPoint):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( RefPoint, geompy.GEOM._objref_GEOM_Object)):
            RefPoint = GetPointStruct(RefPoint) 
        return self.editor.ExtrusionAlongPath(IDsOfElements, PathMesh, PathShape, NodeStart,
                                              HasAngles, Angles, HasRefPoint, RefPoint)

    ## Generate new elements by extrusion of the elements belong to object
    #  A path of extrusion must be a meshed edge.
    #  @param IDsOfElements is ids of elements
    #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
    #  @param PathShape is shape(edge); as the mesh can be complex, the edge is used to define the sub-mesh for the path
    #  @param NodeStart the first or the last node on the edge. It is used to define the direction of extrusion
    #  @param HasAngles allows the shape to be rotated around the path to get the resulting mesh in a helical fashion
    #  @param Angles list of angles
    #  @param HasRefPoint allows to use base point 
    #  @param RefPoint point around which the shape is rotated(the mass center of the shape by default).
    #         User can specify any point as the Base Point and the shape will be rotated with respect to this point.
    def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart,
                                 HasAngles, Angles, HasRefPoint, RefPoint):
        if ( isinstance( RefPoint, geompy.GEOM._objref_GEOM_Object)):
            RefPoint = GetPointStruct(RefPoint) 
        return self.editor.ExtrusionAlongPathObject(theObject, PathMesh, PathShape, NodeStart,
                                                    HasAngles, Angles, HasRefPoint, RefPoint)
    
    ## Symmetrical copy of mesh elements
    #  @param IDsOfElements list of elements ids
    #  @param Mirror is AxisStruct or geom object(point, line, plane)
    #  @param theMirrorType is  POINT, AXIS or PLANE
    #  If the Mirror is geom object this parameter is unnecessary
    #  @param Copy allows to copy element(Copy is 1) or to replace with its mirroring(Copy is 0)
    def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( Mirror, geompy.GEOM._objref_GEOM_Object)):
            Mirror = GetAxisStruct(Mirror)
        self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)

    ## Symmetrical copy of object
    #  @param theObject mesh, submesh or group
    #  @param Mirror is AxisStruct or geom object(point, line, plane)
    #  @param theMirrorType is  POINT, AXIS or PLANE
    #  If the Mirror is geom object this parameter is unnecessary
    #  @param Copy allows to copy element(Copy is 1) or to replace with its mirroring(Copy is 0)
    def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0):
        if ( isinstance( Mirror, geompy.GEOM._objref_GEOM_Object)):
            Mirror = GetAxisStruct(Mirror)
        self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)

    ## Translates the elements
    #  @param IDsOfElements list of elements ids
    #  @param Vector direction of translation(DirStruct or vector)
    #  @param Copy allows to copy the translated elements
    def Translate(self, IDsOfElements, Vector, Copy):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( Vector, geompy.GEOM._objref_GEOM_Object)):
            Vector = GetDirStruct(Vector)
        self.editor.Translate(IDsOfElements, Vector, Copy)

    ## Translates the object
    #  @param theObject object to translate(mesh, submesh, or group)
    #  @param Vector direction of translation(DirStruct or geom vector)
    #  @param Copy allows to copy the translated elements
    def TranslateObject(self, theObject, Vector, Copy):
        if ( isinstance( Vector, geompy.GEOM._objref_GEOM_Object)):
            Vector = GetDirStruct(Vector)
        self.editor.TranslateObject(theObject, Vector, Copy)

    ## Rotates the elements
    #  @param IDsOfElements list of elements ids
    #  @param Axis axis of rotation(AxisStruct or geom line)
    #  @param AngleInRadians angle of rotation(in radians)
    #  @param Copy allows to copy the rotated elements   
    def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy):
        if IDsOfElements == []:
            IDsOfElements = self.GetElementsId()
        if ( isinstance( Axis, geompy.GEOM._objref_GEOM_Object)):
            Axis = GetAxisStruct(Axis)
        self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)

    ## Rotates the object
    #  @param theObject object to rotate(mesh, submesh, or group)
    #  @param Axis axis of rotation(AxisStruct or geom line)
    #  @param AngleInRadians angle of rotation(in radians)
    #  @param Copy allows to copy the rotated elements
    def RotateObject (self, theObject, Axis, AngleInRadians, Copy):
        self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy)

    ## Find group of nodes close to each other within Tolerance.
    #  @param Tolerance tolerance value
    #  @param list of group of nodes
    def FindCoincidentNodes (self, Tolerance):
        return self.editor.FindCoincidentNodes(Tolerance)

    ## Merge nodes
    #  @param list of group of nodes
    def MergeNodes (self, GroupsOfNodes):
        self.editor.MergeNodes(GroupsOfNodes)

    ## Remove all but one of elements built on the same nodes.
    def MergeEqualElements(self):
        self.editor.MergeEqualElements()
        
    ## Sew free borders
    def SewFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
                        FirstNodeID2, SecondNodeID2, LastNodeID2,
                        CreatePolygons, CreatePolyedrs):
        return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
                                          FirstNodeID2, SecondNodeID2, LastNodeID2,
                                          CreatePolygons, CreatePolyedrs)

    ## Sew conform free borders
    def SewConformFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
                               FirstNodeID2, SecondNodeID2):
        return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
                                                 FirstNodeID2, SecondNodeID2)
    
    ## Sew border to side
    def SewBorderToSide (self, FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
                         FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs):
        return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
                                           FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs)

    ## Sew two sides of a mesh. Nodes belonging to Side1 are
    #  merged with nodes of elements of Side2.
    #  Number of elements in theSide1 and in theSide2 must be
    #  equal and they should have similar node connectivity.
    #  The nodes to merge should belong to sides borders and
    #  the first node should be linked to the second.
    def SewSideElements (self, IDsOfSide1Elements, IDsOfSide2Elements,
                         NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
                         NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge):
        return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements,
                                           NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
                                           NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge)

    ## Set new nodes for given element.
    #  @param ide the element id
    #  @param newIDs nodes ids
    #  @return If number of nodes is not corresponded to type of element - returns false
    def ChangeElemNodes(self, ide, newIDs):
        return self.editor.ChangeElemNodes(ide, newIDs)
    
    ## If during last operation of MeshEditor some nodes were
    #  created this method returns list of it's IDs, if new nodes
    #  not created - returns empty list
    def GetLastCreatedNodes(self):
        return self.editor.GetLastCreatedNodes()

    ## If during last operation of MeshEditor some elements were
    #  created this method returns list of it's IDs, if new elements
    #  not creared - returns empty list
    def GetLastCreatedElems(self):
        return self.editor.GetLastCreatedElems()

Lines 85-91 Link Here

(-)SMESH_SRC_3.2.2/src/StdMeshers_I/Makefile.in (-1 / +1 lines)
85	SALOMEDS.idl SALOME_Exception.idl \	85	SALOMEDS.idl SALOME_Exception.idl \
86	GEOM_Gen.idl MED.idl SALOMEDS_Attributes.idl \	86	GEOM_Gen.idl MED.idl SALOMEDS_Attributes.idl \
87	SMESH_Gen.idl SMESH_Hypothesis.idl SMESH_Group.idl \	87	SMESH_Gen.idl SMESH_Hypothesis.idl SMESH_Group.idl \
88	SALOME_Comm.idl	88	SALOME_Comm.idl SALOME_Component.idl SALOME_GenericObj.idl SMESH_Mesh.idl
89		89
90	# Executables targets	90	# Executables targets
91	BIN =	91	BIN =

Return to bug 155974

Lines 374-379 Link Here

(-)SMESH_SRC_3.2.2/idl/SMESH_Mesh.idl (-3 / +33 lines)
374		374
375	/*!	375	/*!
376	* Export Mesh to DAT, UNV and STL Formats	376	* Export Mesh to DAT, UNV and STL Formats
		377	* (UNV supported version is I-DEAS 10)
377	*/	378	*/
378	void ExportDAT( in string file )	379	void ExportDAT( in string file )
379	raises (SALOME::SALOME_Exception);	380	raises (SALOME::SALOME_Exception);
Lines 508-520 Link Here
508		509
509	/*!	510	/*!
510	* If given element is node returns IDs of shape from position	511	* If given element is node returns IDs of shape from position
511	* else - return ID of result shape after ::FindShape()	512	* If there is not node for given ID - returns -1
512	* from SMESH_MeshEditor
513	* If there is not element for given ID - returns -1
514	*/	513	*/
515	long GetShapeID(in long id);	514	long GetShapeID(in long id);
516		515
517	/*!	516	/*!
		517	* For given element returns ID of result shape after
		518	* ::FindShape() from SMESH_MeshEditor
		519	* If there is not element for given ID - returns -1
		520	*/
		521	long GetShapeIDForElem(in long id);
		522
		523	/*!
518	* Returns number of nodes for given element	524	* Returns number of nodes for given element
519	* If there is not element for given ID - returns -1	525	* If there is not element for given ID - returns -1
520	*/	526	*/
Lines 642-653 Link Here
642		648
643	long AddNode(in double x, in double y, in double z);	649	long AddNode(in double x, in double y, in double z);
644		650
		651	/*!
		652	* Create edge both similar and quadratic (this is determed
		653	* by number of given nodes).
		654	* \param IdsOfNodes List of node IDs for creation of element.
		655	* Needed order of nodes in this list corresponds to description
		656	* of MED. This description is located by the following link:
		657	* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
		658	*/
645	long AddEdge(in long_array IDsOfNodes);	659	long AddEdge(in long_array IDsOfNodes);
646		660
		661	/*!
		662	* Create face both similar and quadratic (this is determed
		663	* by number of given nodes).
		664	* \param IdsOfNodes List of node IDs for creation of element.
		665	* Needed order of nodes in this list corresponds to description
		666	* of MED. This description is located by the following link:
		667	* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
		668	*/
647	long AddFace(in long_array IDsOfNodes);	669	long AddFace(in long_array IDsOfNodes);
648		670
649	long AddPolygonalFace(in long_array IdsOfNodes);	671	long AddPolygonalFace(in long_array IdsOfNodes);
650		672
		673	/*!
		674	* Create volume both similar and quadratic (this is determed
		675	* by number of given nodes).
		676	* \param IdsOfNodes List of node IDs for creation of element.
		677	* Needed order of nodes in this list corresponds to description
		678	* of MED. This description is located by the following link:
		679	* http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
		680	*/
651	long AddVolume(in long_array IDsOfNodes);	681	long AddVolume(in long_array IDsOfNodes);
652		682
653	/*!	683	/*!

Lines 468-474 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH/SMESH_subMesh.cxx (-6 / +15 lines)
468		468
469	//=======================================================================	469	//=======================================================================
470	//function : IsApplicableHypotesis	470	//function : IsApplicableHypotesis
471	//purpose :	471	//purpose :
472	//=======================================================================	472	//=======================================================================
473		473
474	bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,	474	bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
Lines 480-490 Link Here
480		480
481	// hypothesis	481	// hypothesis
482	switch ( theShapeType ) {	482	switch ( theShapeType ) {
483	case TopAbs_EDGE:	483	case TopAbs_EDGE:
484	case TopAbs_FACE:	484	case TopAbs_FACE:
485	case TopAbs_SHELL:
486	case TopAbs_SOLID:	485	case TopAbs_SOLID:
487	return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();	486	return SMESH_Gen::GetShapeDim( theShapeType ) == theHypothesis->GetDim();
		487
		488	case TopAbs_SHELL:
		489	// Special case for algorithms, building 2D mesh on a whole shell.
		490	// Before this fix there was a problem after restoring from study,
		491	// because in that case algorithm is assigned before hypothesis
		492	// (on shell in problem case) and hypothesis is checked on faces
		493	// (because it is 2D), where we have NO_ALGO state.
		494	// Now 2D hypothesis is also applicable to shells.
		495	return (theHypothesis->GetDim() == 2 \|\| theHypothesis->GetDim() == 3);
		496
488	// case TopAbs_WIRE:	497	// case TopAbs_WIRE:
489	// case TopAbs_COMPSOLID:	498	// case TopAbs_COMPSOLID:
490	// case TopAbs_COMPOUND:	499	// case TopAbs_COMPOUND:
Lines 842-848 Link Here
842	f.And( SMESH_HypoFilter::IsApplicableTo( _subShape ));	851	f.And( SMESH_HypoFilter::IsApplicableTo( _subShape ));
843	f.AndNot( SMESH_HypoFilter::Is( algo ));	852	f.AndNot( SMESH_HypoFilter::Is( algo ));
844	const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true );	853	const SMESH_Hypothesis * prevAlgo = _father->GetHypothesis( _subShape, f, true );
845	if (prevAlgo &&	854	if (prevAlgo &&
846	string(algo->GetName()) != string(prevAlgo->GetName()) )	855	string(algo->GetName()) != string(prevAlgo->GetName()) )
847	modifiedHyp = true;	856	modifiedHyp = true;
848	}	857	}
Lines 900-906 Link Here
900	f.And( SMESH_HypoFilter::IsApplicableTo( _subShape ));	909	f.And( SMESH_HypoFilter::IsApplicableTo( _subShape ));
901	f.AndNot( SMESH_HypoFilter::Is( algo ));	910	f.AndNot( SMESH_HypoFilter::Is( algo ));
902	const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true );	911	const SMESH_Hypothesis* prevAlgo = _father->GetHypothesis( _subShape, f, true );
903	if (prevAlgo &&	912	if (prevAlgo &&
904	string(algo->GetName()) != string(prevAlgo->GetName()) )	913	string(algo->GetName()) != string(prevAlgo->GetName()) )
905	modifiedHyp = true;	914	modifiedHyp = true;
906	}	915	}

Lines 145-151 Link Here

(-)SMESH_SRC_3.2.2/src/SMESHGUI/SMESHGUI.cxx (-20 / +39 lines)
145		145
146	using namespace std;	146	using namespace std;
147		147
148	namespace{	148	//namespace{
149	// Declarations	149	// Declarations
150	//=============================================================	150	//=============================================================
151	void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,	151	void ImportMeshesFromFile(SMESH::SMESH_Gen_ptr theComponentMesh,
Lines 352-372 Link Here
352	if ( aFile.exists() )	352	if ( aFile.exists() )
353	aFile.remove();	353	aFile.remove();
354	SUIT_OverrideCursor wc;	354	SUIT_OverrideCursor wc;
355	switch ( theCommandID ) {	355
356	case 125:	356	try {
357	case 122:	357	switch ( theCommandID ) {
358	aMesh->ExportToMED( aFilename.latin1(), toCreateGroups, aFormat );	358	case 125:
359	break;	359	case 122:
360	case 124:	360	aMesh->ExportToMED( aFilename.latin1(), toCreateGroups, aFormat );
361	case 121:	361	break;
362	aMesh->ExportDAT( aFilename.latin1() );	362	case 124:
363	break;	363	case 121:
364	case 126:	364	aMesh->ExportDAT( aFilename.latin1() );
365	case 123:	365	break;
366	aMesh->ExportUNV( aFilename.latin1() );	366	case 126:
367	break;	367	case 123:
368	default:	368	aMesh->ExportUNV( aFilename.latin1() );
369	break;	369	break;
		370	default:
		371	break;
		372	}
		373	}
		374	catch (const SALOME::SALOME_Exception& S_ex){
		375	wc.suspend();
		376	SUIT_MessageBox::warn1(SMESHGUI::desktop(),
		377	QObject::tr("SMESH_WRN_WARNING"),
		378	QObject::tr("SMESH_EXPORT_FAILED"),
		379	QObject::tr("SMESH_BUT_OK"));
		380	wc.resume();
370	}	381	}
371	}	382	}
372	}	383	}
Lines 815-821 Link Here
815		826
816	SMESHGUI::GetSMESHGUI()->updateObjBrowser();	827	SMESHGUI::GetSMESHGUI()->updateObjBrowser();
817	}	828	}
818	}	829	//}
819		830
820	extern "C" {	831	extern "C" {
821	Standard_EXPORT CAM_Module* createModule()	832	Standard_EXPORT CAM_Module* createModule()
Lines 1217-1222 Link Here
1217	}	1228	}
1218	}	1229	}
1219	}	1230	}
		1231
		1232	// PAL13338 -->
		1233	if ( ( theCommandID==301 \|\| theCommandID==302 ) && !checkLock(aStudy) && !automaticUpdate() )
		1234	SMESH::UpdateView();
		1235	// PAL13338 <--
1220		1236
1221	if (anAction == SMESH::eErase) {	1237	if (anAction == SMESH::eErase) {
1222	SALOME_ListIO l1;	1238	SALOME_ListIO l1;
Lines 1224-1229 Link Here
1224	}	1240	}
1225	else	1241	else
1226	aSel->setSelectedObjects( to_process );	1242	aSel->setSelectedObjects( to_process );
		1243
1227	break;	1244	break;
1228	}	1245	}
1229		1246
Lines 2155-2166 Link Here
2155	LightApp_SelectionMgr* mgr = selectionMgr();	2172	LightApp_SelectionMgr* mgr = selectionMgr();
2156	SALOME_ListIO selected; mgr->selectedObjects( selected );	2173	SALOME_ListIO selected; mgr->selectedObjects( selected );
2157		2174
2158	if (selected.Extent() == 1) {	2175	SALOME_ListIteratorOfListIO it(selected);
2159	Handle(SALOME_InteractiveObject) anIObject = selected.First();	2176	for(; it.More(); it.Next()) {
2160	if(anIObject->hasEntry())	2177	Handle(SALOME_InteractiveObject) anIObject = it.Value();
		2178	if(anIObject->hasEntry()) {
2161	if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){	2179	if(SMESH_Actor *anActor = SMESH::FindActorByEntry(anIObject->getEntry())){
2162	anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );	2180	anActor->SetPointsLabeled( !anActor->GetPointsLabeled() );
2163	}	2181	}
		2182	}
2164	}	2183	}
2165	break;	2184	break;
2166	}	2185	}

Lines 49-54 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_I/SMESH_Mesh_i.cxx (-4 / +26 lines)
49	//#include "SMDS_ElemIterator.hxx"	49	//#include "SMDS_ElemIterator.hxx"
50	#include "SMDS_VolumeTool.hxx"	50	#include "SMDS_VolumeTool.hxx"
51	#include "SMESH_MesherHelper.hxx"	51	#include "SMESH_MesherHelper.hxx"
		52	#include "SMESH_MeshEditor.hxx"
52		53
53	// OCCT Includes	54	// OCCT Includes
54	#include <OSD_Path.hxx>	55	#include <OSD_Path.hxx>
Lines 1857-1865 Link Here
1857	//=============================================================================	1858	//=============================================================================
1858	/*!	1859	/*!
1859	* If given element is node returns IDs of shape from position	1860	* If given element is node returns IDs of shape from position
1860	* else - return ID of result shape after ::FindShape()	1861	* If there is not node for given ID - returns -1
1861	* from SMESH_MeshEditor
1862	* If there is not element for given ID - returns -1
1863	*/	1862	*/
1864	//=============================================================================	1863	//=============================================================================
1865		1864
Lines 1879-1890 Link Here
1879	return pos->GetShapeId();	1878	return pos->GetShapeId();
1880	}	1879	}
1881		1880
		1881	return -1;
		1882	}
		1883
		1884
		1885	//=============================================================================
		1886	/*!
		1887	* For given element returns ID of result shape after
		1888	* ::FindShape() from SMESH_MeshEditor
		1889	* If there is not element for given ID - returns -1
		1890	*/
		1891	//=============================================================================
		1892
		1893	CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id)
		1894	{
		1895	SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
		1896	if ( aSMESHDS_Mesh == NULL )
		1897	return -1;
		1898
1882	// try to find element	1899	// try to find element
1883	const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);	1900	const SMDS_MeshElement* elem = aSMESHDS_Mesh->FindElement(id);
1884	if(!elem)	1901	if(!elem)
1885	return -1;	1902	return -1;
1886		1903
1887	// need implementation???????????????????????????????????????????????	1904	//SMESH::SMESH_MeshEditor_var aMeshEditor = SMESH_Mesh_i::GetMeshEditor();
		1905	::SMESH_MeshEditor aMeshEditor(_impl);
		1906	int index = aMeshEditor.FindShape( elem );
		1907	if(index>0)
		1908	return index;
		1909
1888	return -1;	1910	return -1;
1889	}	1911	}
1890		1912

Lines 1-18 Link Here

(-)SMESH_SRC_3.2.2/src/SMESHGUI/SMESHGUI_MeshOp.cxx (-19 / +23 lines)
1	// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,	1	// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS	2	// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3	//	3	//
4	// This library is free software; you can redistribute it and/or	4	// This library is free software; you can redistribute it and/or
5	// modify it under the terms of the GNU Lesser General Public	5	// modify it under the terms of the GNU Lesser General Public
6	// License as published by the Free Software Foundation; either	6	// License as published by the Free Software Foundation; either
7	// version 2.1 of the License.	7	// version 2.1 of the License.
8	//	8	//
9	// This library is distributed in the hope that it will be useful	9	// This library is distributed in the hope that it will be useful
10	// but WITHOUT ANY WARRANTY; without even the implied warranty of	10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	// Lesser General Public License for more details.	12	// Lesser General Public License for more details.
13	//	13	//
14	// You should have received a copy of the GNU Lesser General Public	14	// You should have received a copy of the GNU Lesser General Public
15	// License along with this library; if not, write to the Free Software	15	// License along with this library; if not, write to the Free Software
16	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	16	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	//	17	//
18	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com	18	// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
Lines 81-87 Link Here
81	SUBMESH_ON_SHELL_TAG =8,	81	SUBMESH_ON_SHELL_TAG =8,
82	SUBMESH_ON_SOLID_TAG =9,	82	SUBMESH_ON_SOLID_TAG =9,
83	SUBMESH_ON_COMPOUND_TAG=10 };	83	SUBMESH_ON_COMPOUND_TAG=10 };
84		84
85	//================================================================================	85	//================================================================================
86	/*!	86	/*!
87	* \brief Constructor	87	* \brief Constructor
Lines 212-218 Link Here
212	connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));	212	connect( myDlg, SIGNAL( hypoSet( const QString& )), SLOT( onHypoSet( const QString& )));
213	connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));	213	connect( myDlg, SIGNAL( geomSelectionByMesh( bool )), SLOT( onGeomSelectionByMesh( bool )));
214		214
215	if ( myToCreate )	215	if ( myToCreate )
216	if ( myIsMesh ) myHelpFileName = "/files/constructing_meshes.htm";	216	if ( myIsMesh ) myHelpFileName = "/files/constructing_meshes.htm";
217	else myHelpFileName = "/files/constructing_submeshes.htm";	217	else myHelpFileName = "/files/constructing_submeshes.htm";
218	else myHelpFileName = "files/reassigning_hypotheses_and_algorithms.htm";	218	else myHelpFileName = "files/reassigning_hypotheses_and_algorithms.htm";
Lines 379-385 Link Here
379	}	379	}
380	}	380	}
381	}	381	}
382	}	382	}
383	}	383	}
384	return _PTR(SObject)();	384	return _PTR(SObject)();
385	}	385	}
Lines 421-427 Link Here
421	case GEOM::SOLID:	421	case GEOM::SOLID:
422	case GEOM::SHELL: shapeDim = 3; break;	422	case GEOM::SHELL: shapeDim = 3; break;
423	case GEOM::FACE: shapeDim = 2; break;	423	case GEOM::FACE: shapeDim = 2; break;
424	case GEOM::WIRE:	424	case GEOM::WIRE:
425	case GEOM::EDGE: shapeDim = 1; break;	425	case GEOM::EDGE: shapeDim = 1; break;
426	case GEOM::VERTEX: shapeDim = 0; break;	426	case GEOM::VERTEX: shapeDim = 0; break;
427	default:	427	default:
Lines 464-470 Link Here
464	{	464	{
465	// if a submesh on the selected shape already exist, pass to submesh edition mode	465	// if a submesh on the selected shape already exist, pass to submesh edition mode
466	if ( _PTR(SObject) pSubmesh = getSubmeshByGeom() ) {	466	if ( _PTR(SObject) pSubmesh = getSubmeshByGeom() ) {
467	SMESH::SMESH_subMesh_var sm =	467	SMESH::SMESH_subMesh_var sm =
468	SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( pSubmesh );	468	SMESH::SObjectToInterface<SMESH::SMESH_subMesh>( pSubmesh );
469	bool editSubmesh = ( !sm->_is_nil() &&	469	bool editSubmesh = ( !sm->_is_nil() &&
470	SUIT_MessageBox::question2( myDlg, tr( "SMESH_WARNING" ),	470	SUIT_MessageBox::question2( myDlg, tr( "SMESH_WARNING" ),
Lines 586-592 Link Here
586	}	586	}
587	}	587	}
588	}	588	}
589		589
590	return true;	590	return true;
591	}	591	}
592		592
Lines 756-762 Link Here
756	const int nbColonsInMeshEntry = 3;	756	const int nbColonsInMeshEntry = 3;
757	bool isSubMesh = myToCreate ?	757	bool isSubMesh = myToCreate ?
758	!myIsMesh :	758	!myIsMesh :
759	myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ).contains(':') > nbColonsInMeshEntry;	759	myDlg->selectedObject( SMESHGUI_MeshDlg::Obj ).contains(':') > nbColonsInMeshEntry;
760		760
761	if ( isSubMesh )	761	if ( isSubMesh )
762	{	762	{
Lines 797-803 Link Here
797		797
798	//================================================================================	798	//================================================================================
799	/*!	799	/*!
800	* \Brief Returns tab dimention	800	* \Brief Returns tab dimention
801	* \param tab - the tab in the dlg	801	* \param tab - the tab in the dlg
802	* \param dlg - my dialogue	802	* \param dlg - my dialogue
803	* \retval int - dimention	803	* \retval int - dimention
Lines 852-857 Link Here
852	const int theType,	852	const int theType,
853	const QString& theTypeName)	853	const QString& theTypeName)
854	{	854	{
		855	// During a hypothesis creation we might need to select some objects.
		856	// Main dialog must not update it's own selected objects in this case.
		857	dlg()->deactivateAll();
		858
855	HypothesisData* aData = SMESH::GetHypothesisData(theTypeName.latin1());	859	HypothesisData* aData = SMESH::GetHypothesisData(theTypeName.latin1());
856	if (!aData)	860	if (!aData)
857	return;	861	return;
Lines 922-928 Link Here
922		926
923	//================================================================================	927	//================================================================================
924	/*!	928	/*!
925	* \brief access to hypothesis data	929	* \brief access to hypothesis data
926	* \param theDim - hyp dimension	930	* \param theDim - hyp dimension
927	* \param theHypType - hyp type (Algo,MainHyp or AddHyp)	931	* \param theHypType - hyp type (Algo,MainHyp or AddHyp)
928	* \param theIndex - index in the list	932	* \param theIndex - index in the list
Lines 1105-1111 Link Here
1105		1109
1106	//================================================================================	1110	//================================================================================
1107	/*!	1111	/*!
1108	* \brief Creates and selects hypothesis of hypotheses set	1112	* \brief Creates and selects hypothesis of hypotheses set
1109	* \param theSetName - The name of hypotheses set	1113	* \param theSetName - The name of hypotheses set
1110	*/	1114	*/
1111	//================================================================================	1115	//================================================================================
Lines 1201-1207 Link Here
1201		1205
1202	for ( int aDim = SMESH::DIM_1D; aDim <= SMESH::DIM_3D; aDim++ ) {	1206	for ( int aDim = SMESH::DIM_1D; aDim <= SMESH::DIM_3D; aDim++ ) {
1203	if ( !isAccessibleDim( aDim )) continue;	1207	if ( !isAccessibleDim( aDim )) continue;
1204		1208
1205	// assign hypotheses	1209	// assign hypotheses
1206	for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ ) {	1210	for ( int aHypType = MainHyp; aHypType <= AddHyp; aHypType++ ) {
1207	int aHypIndex = currentHyp( aDim, aHypType );	1211	int aHypIndex = currentHyp( aDim, aHypType );

Lines 17-26 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/PAL_MESH_041_mesh.py (-45 / +21 lines)
17	#	17	#
18	# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com	18	# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19	#	19	#
20	import geompy
21	import salome	20	import salome
		21	import geompy
		22	import smesh
22		23
23	import StdMeshers
24		24
25	#-----------------------------GEOM----------------------------------------	25	#-----------------------------GEOM----------------------------------------
26		26
Lines 51-122 Link Here
51		51
52		52
53	#-----------------------------SMESH-------------------------------------------	53	#-----------------------------SMESH-------------------------------------------
54	smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
55
56	# -- Init --
57	plane_mesh = salome.IDToObject( Id_face1)
58	smesh.SetCurrentStudy(salome.myStudy)
59
60	mesh = smesh.CreateMesh(plane_mesh)
61
62	smeshgui = salome.ImportComponentGUI("SMESH")
63	smeshgui.Init(salome.myStudyId)
64		54
65	id_mesh = salome.ObjectToID(mesh)
66	smeshgui.SetName( id_mesh, "Mesh_1")
67		55
		56	# -- Init mesh --
		57	plane_mesh = salome.IDToObject( Id_face1)
68		58
69	print"---------------------Hypothesis"	59	mesh = smesh.Mesh(plane_mesh, "Mesh_1")
70		60
		61	print"---------------------Hypothesis and Algorithms"
71		62
72	#---------------- NumberOfSegments	63	#---------------- NumberOfSegments
		64
73	numberOfSegment = 9	65	numberOfSegment = 9
74		66
75	hypNbSeg = smesh.CreateHypothesis( "NumberOfSegments", "libStdMeshersEngine.so" )	67	algoWireDes = mesh.Segment()
76	hypNbSeg.SetNumberOfSegments( numberOfSegment )	68	listHyp = algoWireDes.GetCompatibleHypothesis()
		69	print algoWireDes.GetName()
		70	algoWireDes.SetName("Ware descritisation")
77		71
		72	hypNbSeg = algoWireDes.NumberOfSegments(numberOfSegment)
78	print hypNbSeg.GetName()	73	print hypNbSeg.GetName()
79	print hypNbSeg.GetNumberOfSegments()	74	print hypNbSeg.GetNumberOfSegments()
80	smeshgui.SetName(salome.ObjectToID(hypNbSeg), "Nb. Segments")	75	smesh.SetName(hypNbSeg, "Nb. Segments")
81		76
82		77
83	#--------------------------Max. Element Area	78	#--------------------------Max. Element Area
84	maxElementArea = 200	79	maxElementArea = 200
85		80
86	hypArea200 = smesh.CreateHypothesis("MaxElementArea","libStdMeshersEngine.so")	81	algoMef = mesh.Triangle()
87	hypArea200.SetMaxElementArea( maxElementArea )
88	print hypArea200.GetName()
89	print hypArea200.GetMaxElementArea()
90
91	smeshgui.SetName(salome.ObjectToID(hypArea200), "Max. Element Area")
92
93	print"---------------------Algorithms"
94
95	#----------------------------Wire discretisation
96	algoWireDes = smesh.CreateHypothesis( "Regular_1D", "libStdMeshersEngine.so" )
97	listHyp = algoWireDes.GetCompatibleHypothesis()
98
99	print algoWireDes.GetName()
100	smeshgui.SetName(salome.ObjectToID(algoWireDes), "Ware descritisation")
101
102	#----------------------------Triangle (Mefisto)
103	algoMef = smesh.CreateHypothesis( "MEFISTO_2D", "libStdMeshersEngine.so" )
104	listHyp = algoMef.GetCompatibleHypothesis()	82	listHyp = algoMef.GetCompatibleHypothesis()
105
106	print algoMef.GetName()	83	print algoMef.GetName()
		84	algoMef.SetName("Triangle (Mefisto)")
107		85
108	#----------------------------Add hipothesis to the plane	86	hypArea200 = algoMef.MaxElementArea(maxElementArea)
109	mesh.AddHypothesis( plane_mesh, hypNbSeg ) # nb segments	87	print hypArea200.GetName()
110	mesh.AddHypothesis( plane_mesh, hypArea200 ) # max area	88	print hypArea200.GetMaxElementArea()
111		89	smesh.SetName(hypArea200, "Max. Element Area")
112	mesh.AddHypothesis( plane_mesh, algoWireDes ) # Regular 1D/wire discretisation
113	mesh.AddHypothesis( plane_mesh, algoMef ) # MEFISTO 2D
114		90
115	smeshgui.SetName(salome.ObjectToID(algoMef), "Triangle (Mefisto)")
116		91
117	print "---------------------Compute the mesh"	92	print "---------------------Compute the mesh"
118		93
119	smesh.Compute(mesh, plane_mesh)	94	ret = mesh.Compute()
		95	print ret
120		96
121	salome.sg.updateObjBrowser(1)	97	salome.sg.updateObjBrowser(1)
122		98

Lines 23-33 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_GroupFromGeom.py (-4 / +3 lines)
23	# Module : SMESH	23	# Module : SMESH
24		24
25	from SMESH_test1 import *	25	from SMESH_test1 import *
26	import SMESH
27		26
28	# Compute the mesh created in SMESH_test1	27	# Compute the mesh created in SMESH_test1
29		28
30	smesh.Compute(mesh, box)	29	mesh.Compute()
31		30
32	# Create geometry groups on plane:	31	# Create geometry groups on plane:
33	aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])	32	aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])
Lines 43-49 Link Here
43	geompy.addToStudy(aGeomGroup1, "Group on Faces")	42	geompy.addToStudy(aGeomGroup1, "Group on Faces")
44	geompy.addToStudy(aGeomGroup2, "Group on Edges")	43	geompy.addToStudy(aGeomGroup2, "Group on Edges")
45		44
46	aSmeshGroup1 = mesh.CreateGroupFromGEOM(SMESH.FACE, "SMESHGroup1", aGeomGroup1)	45	aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
47	aSmeshGroup2 = mesh.CreateGroupFromGEOM(SMESH.EDGE, "SMESHGroup2", aGeomGroup2)	46	aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)
48		47
49	salome.sg.updateObjBrowser(1);	48	salome.sg.updateObjBrowser(1);

Lines 25-35 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_GroupFromGeom2.py (-6 / +6 lines)
25	# Project : PAL/SALOME	25	# Project : PAL/SALOME
26	#==============================================================================	26	#==============================================================================
27	from SMESH_test1 import *	27	from SMESH_test1 import *
28	import SMESH	28
29		29
30	# Compute the mesh created in SMESH_test1	30	# Compute the mesh created in SMESH_test1
31		31
32	smesh.Compute(mesh, box)	32	mesh.Compute()
33		33
34	# Create geometry groups on plane:	34	# Create geometry groups on plane:
35	aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])	35	aGeomGroup1 = geompy.CreateGroup(face , geompy.ShapeType["FACE"])
Lines 45-55 Link Here
45	geompy.addToStudy(aGeomGroup1, "Group on Faces")	45	geompy.addToStudy(aGeomGroup1, "Group on Faces")
46	geompy.addToStudy(aGeomGroup2, "Group on Edges")	46	geompy.addToStudy(aGeomGroup2, "Group on Edges")
47		47
48	aSmeshGroup1 = mesh.CreateGroupFromGEOM(SMESH.FACE, "SMESHGroup1", aGeomGroup1)	48	aSmeshGroup1 = mesh.GroupOnGeom(aGeomGroup1, "SMESHGroup1", smesh.FACE)
49	aSmeshGroup2 = mesh.CreateGroupFromGEOM(SMESH.EDGE, "SMESHGroup2", aGeomGroup2)	49	aSmeshGroup2 = mesh.GroupOnGeom(aGeomGroup2, "SMESHGroup2", smesh.EDGE)
50		50
51	print "Create aGroupOnShell - a group linked to a shell"	51	print "Create aGroupOnShell - a group linked to a shell"
52	aGroupOnShell = mesh.CreateGroupFromGEOM(SMESH.EDGE, "GroupOnShell", shell)	52	aGroupOnShell = mesh.GroupOnGeom(shell, "GroupOnShell", smesh.EDGE)
53	print "aGroupOnShell type =", aGroupOnShell.GetType()	53	print "aGroupOnShell type =", aGroupOnShell.GetType()
54	print "aGroupOnShell size =", aGroupOnShell.Size()	54	print "aGroupOnShell size =", aGroupOnShell.Size()
55	print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()	55	print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
Lines 65-71 Link Here
65	print " "	65	print " "
66		66
67	print "Re-compute mesh, contents of aGroupOnShell changes again:"	67	print "Re-compute mesh, contents of aGroupOnShell changes again:"
68	smesh.Compute(mesh, box)	68	mesh.Compute()
69	print "aGroupOnShell size =", aGroupOnShell.Size()	69	print "aGroupOnShell size =", aGroupOnShell.Size()
70	print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()	70	print "aGroupOnShell ids :", aGroupOnShell.GetListOfID()
71		71

Lines 24-31 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_fixation_hexa.py (-40 / +16 lines)
24	#	24	#
25		25
26	import SMESH_fixation	26	import SMESH_fixation
27		27	import smesh
28	import StdMeshers
29		28
30	compshell = SMESH_fixation.compshell	29	compshell = SMESH_fixation.compshell
31	idcomp = SMESH_fixation.idcomp	30	idcomp = SMESH_fixation.idcomp
Lines 45-109 Link Here
45	print " check status ", status	44	print " check status ", status
46		45
47	### ---------------------------- SMESH --------------------------------------	46	### ---------------------------- SMESH --------------------------------------
48	smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
49		47
50	smeshgui = salome.ImportComponentGUI("SMESH")	48	# ---- init a Mesh with the compshell
51	smeshgui.Init(salome.myStudyId)	49	shape_mesh = salome.IDToObject( idcomp )
		50
		51	mesh = smesh.Mesh(shape_mesh, "MeshCompShell")
		52
52		53
53	print "-------------------------- create Hypothesis"	54	# ---- set Hypothesis and Algorithm
54		55
55	print "-------------------------- NumberOfSegments"	56	print "-------------------------- NumberOfSegments"
56		57
57	numberOfSegments = 5	58	numberOfSegments = 5
58		59
59	hypNbSeg = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")	60	regular1D = mesh.Segment()
60	hypNbSeg.SetNumberOfSegments(numberOfSegments)	61	regular1D.SetName("Wire Discretisation")
61		62	hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
62	print hypNbSeg.GetName()	63	print hypNbSeg.GetName()
63	print hypNbSeg.GetId()	64	print hypNbSeg.GetId()
64	print hypNbSeg.GetNumberOfSegments()	65	print hypNbSeg.GetNumberOfSegments()
65		66	smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
66	smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_5")
67
68	print "-------------------------- create Algorithms"
69
70	print "-------------------------- Regular_1D"
71
72	regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
73
74	smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")
75		67
76	print "-------------------------- Quadrangle_2D"	68	print "-------------------------- Quadrangle_2D"
77		69
78	quad2D = smesh.CreateHypothesis("Quadrangle_2D", "libStdMeshersEngine.so")	70	quad2D = mesh.Quadrangle()
79		71	quad2D.SetName("Quadrangle_2D")
80	smeshgui.SetName(salome.ObjectToID(quad2D), "Quadrangle_2D")
81		72
82	print "-------------------------- Hexa_3D"	73	print "-------------------------- Hexa_3D"
83		74
84	hexa3D = smesh.CreateHypothesis("Hexa_3D", "libStdMeshersEngine.so")	75	hexa3D = mesh.Hexahedron()
85		76	hexa3D.SetName("Hexa_3D")
86	smeshgui.SetName(salome.ObjectToID(hexa3D), "Hexa_3D")
87
88	# ---- init a Mesh with the compshell
89	shape_mesh = salome.IDToObject( idcomp )
90
91	mesh = smesh.CreateMesh(shape_mesh)
92	smeshgui.SetName(salome.ObjectToID(mesh), "MeshCompShell")
93
94
95	print "-------------------------- add hypothesis to compshell"
96
97	mesh.AddHypothesis(shape_mesh,regular1D)
98	mesh.AddHypothesis(shape_mesh,hypNbSeg)
99		77
100	mesh.AddHypothesis(shape_mesh,quad2D)
101	mesh.AddHypothesis(shape_mesh,hexa3D)
102		78
103	salome.sg.updateObjBrowser(1)	79	salome.sg.updateObjBrowser(1)
104		80
105	print "-------------------------- compute compshell"	81	print "-------------------------- compute compshell"
106	ret = smesh.Compute(mesh, shape_mesh)	82	ret = mesh.Compute()
107	print ret	83	print ret
108	if ret != 0:	84	if ret != 0:
109	log = mesh.GetLog(0) # no erase trace	85	log = mesh.GetLog(0) # no erase trace

Lines 23-30 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_fixation_netgen.py (-8 / +5 lines)
23	# The new Netgen algorithm is used that discretizes baoundaries itself	23	# The new Netgen algorithm is used that discretizes baoundaries itself
24	#	24	#
25		25
26	import StdMeshers
27	import NETGENPlugin
28	import SMESH_fixation	26	import SMESH_fixation
29	import smesh	27	import smesh
30		28
Lines 50-61 Link Here
50	print "-------------------------- create Mesh, algorithm, hypothesis"	48	print "-------------------------- create Mesh, algorithm, hypothesis"
51		49
52	mesh = smesh.Mesh(compshell, "MeshcompShel");	50	mesh = smesh.Mesh(compshell, "MeshcompShel");
53	netgen = mesh.Netgen(1)	51	netgen = mesh.Tetrahedron(smesh.FULL_NETGEN)
54	hyp = netgen.Parameters()	52	netgen.SetMaxSize( 50 )
55	hyp.SetMaxSize( 50 )	53	#netgen.SetSecondOrder( 0 )
56	#hyp.SetSecondOrder( 0 )	54	netgen.SetFineness( smesh.Fine )
57	hyp.SetFineness( 3 )	55	#netgen.SetOptimize( 1 )
58	#hyp.SetOptimize( 1 )
59		56
60	salome.sg.updateObjBrowser(1)	57	salome.sg.updateObjBrowser(1)
61		58

Lines 23-31 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_fixation_tetra.py (-58 / +28 lines)
23	# Hypothesis and algorithms for the mesh generation are global	23	# Hypothesis and algorithms for the mesh generation are global
24	#	24	#
25		25
26	import StdMeshers
27	import NETGENPlugin
28	import SMESH_fixation	26	import SMESH_fixation
		27	import smesh
29		28
30	compshell = SMESH_fixation.compshell	29	compshell = SMESH_fixation.compshell
31	idcomp = SMESH_fixation.idcomp	30	idcomp = SMESH_fixation.idcomp
Lines 45-138 Link Here
45	print " check status ", status	44	print " check status ", status
46		45
47	### ---------------------------- SMESH --------------------------------------	46	### ---------------------------- SMESH --------------------------------------
48	smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
49		47
50	smeshgui = salome.ImportComponentGUI("SMESH")	48	# ---- init a Mesh with the compshell
51	smeshgui.Init(salome.myStudyId)	49
		50	mesh = smesh.Mesh(compshell, "MeshcompShell")
		51
52		52
53	print "-------------------------- create Hypothesis"	53	# ---- set Hypothesis and Algorithm
54		54
55	print "-------------------------- NumberOfSegments"	55	print "-------------------------- NumberOfSegments"
56		56
57	numberOfSegments = 5	57	numberOfSegments = 5
58		58
59	hypNbSeg = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")	59	regular1D = mesh.Segment()
60	hypNbSeg.SetNumberOfSegments(numberOfSegments)	60	regular1D.SetName("Wire Discretisation")
61		61	hypNbSeg = regular1D.NumberOfSegments(numberOfSegments)
62	print hypNbSeg.GetName()	62	print hypNbSeg.GetName()
63	print hypNbSeg.GetId()	63	print hypNbSeg.GetId()
64	print hypNbSeg.GetNumberOfSegments()	64	print hypNbSeg.GetNumberOfSegments()
		65	smesh.SetName(hypNbSeg, "NumberOfSegments_" + str(numberOfSegments))
65		66
66	smeshgui.SetName(salome.ObjectToID(hypNbSeg), "NumberOfSegments_5")	67	## print "-------------------------- MaxElementArea"
67
68	print "-------------------------- MaxElementArea"
69		68
70	## maxElementArea = 80	69	## maxElementArea = 80
71		70
72	## hypArea=smesh.CreateHypothesis("MaxElementArea")	71	## mefisto2D = mesh.Triangle()
73	## hypArea.SetMaxElementArea(maxElementArea)	72	## mefisto2D.SetName("MEFISTO_2D")
		73	## hypArea = mefisto2D.MaxElementArea(maxElementArea)
74	## print hypArea.GetName()	74	## print hypArea.GetName()
75	## print hypArea.GetId()	75	## print hypArea.GetId()
76	## print hypArea.GetMaxElementArea()	76	## print hypArea.GetMaxElementArea()
77	## smeshgui.SetName(salome.ObjectToID(hypArea), "MaxElementArea_160")	77	## smesh.SetName(hypArea, "MaxElementArea_" + str(maxElementArea))
		78
		79	print "-------------------------- LengthFromEdges"
78		80
79	hypLengthFromEdges = smesh.CreateHypothesis("LengthFromEdges", "libStdMeshersEngine.so")	81	mefisto2D = mesh.Triangle()
80	smeshgui.SetName(salome.ObjectToID(hypLengthFromEdges), "LengthFromEdges")	82	mefisto2D.SetName("MEFISTO_2D")
		83	hypLengthFromEdges = mefisto2D.LengthFromEdges()
		84	print hypLengthFromEdges.GetName()
		85	print hypLengthFromEdges.GetId()
		86	smesh.SetName(hypLengthFromEdges, "LengthFromEdges")
81		87
82		88
83	print "-------------------------- MaxElementVolume"	89	print "-------------------------- MaxElementVolume"
84		90
85	maxElementVolume = 1000	91	maxElementVolume = 1000
86		92
87	hypVolume = smesh.CreateHypothesis("MaxElementVolume", "libStdMeshersEngine.so")	93	netgen3D = mesh.Tetrahedron(smesh.NETGEN)
88	hypVolume.SetMaxElementVolume(maxElementVolume)	94	netgen3D.SetName("NETGEN_3D")
89		95	hypVolume = netgen3D.MaxElementVolume(maxElementVolume)
90	print hypVolume.GetName()	96	print hypVolume.GetName()
91	print hypVolume.GetId()	97	print hypVolume.GetId()
92	print hypVolume.GetMaxElementVolume()	98	print hypVolume.GetMaxElementVolume()
		99	smesh.SetName(hypVolume, "MaxElementVolume_" + str(maxElementVolume))
93		100
94	smeshgui.SetName(salome.ObjectToID(hypVolume), "MaxElementVolume_1000")
95
96	print "-------------------------- create Algorithms"
97
98	print "-------------------------- Regular_1D"
99
100	regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
101
102	smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")
103
104	print "-------------------------- MEFISTO_2D"
105
106	mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
107
108	smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")
109
110	print "-------------------------- NETGEN_3D"
111
112	netgen3D = smesh.CreateHypothesis("NETGEN_3D", "libNETGENEngine.so")
113
114	smeshgui.SetName(salome.ObjectToID(netgen3D), "NETGEN_3D")
115
116	# ---- init a Mesh with the compshell
117
118	mesh = smesh.CreateMesh(compshell)
119	smeshgui.SetName(salome.ObjectToID(mesh), "MeshcompShel")
120
121	print "-------------------------- add hypothesis to compshell"
122
123	mesh.AddHypothesis(compshell,regular1D)
124	mesh.AddHypothesis(compshell,hypNbSeg)
125
126	mesh.AddHypothesis(compshell,mefisto2D)
127	mesh.AddHypothesis(compshell,hypLengthFromEdges)
128
129	mesh.AddHypothesis(compshell,netgen3D)
130	mesh.AddHypothesis(compshell,hypVolume)
131		101
132	salome.sg.updateObjBrowser(1)	102	salome.sg.updateObjBrowser(1)
133		103
134	print "-------------------------- compute compshell"	104	print "-------------------------- compute compshell"
135	ret = smesh.Compute(mesh,compshell)	105	ret = mesh.Compute(mesh)
136	print ret	106	print ret
137	if ret != 0:	107	if ret != 0:
138	log = mesh.GetLog(0) # no erase trace	108	log = mesh.GetLog(0) # no erase trace

Lines 26-37 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_flight_skin.py (-45 / +15 lines)
26	import os	26	import os
27	import salome	27	import salome
28	import geompy	28	import geompy
29	import StdMeshers	29	import smesh
30
31	smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
32
33	smeshgui = salome.ImportComponentGUI("SMESH")
34	smeshgui.Init(salome.myStudyId)
35		30
36		31
37	# ---------------------------- GEOM --------------------------------------	32	# ---------------------------- GEOM --------------------------------------
Lines 61-124 Link Here
61		56
62	### ---------------------------- SMESH --------------------------------------	57	### ---------------------------- SMESH --------------------------------------
63		58
64	print "-------------------------- create Hypothesis"	59	# ---- init a Mesh with the shell
		60	shape_mesh = salome.IDToObject( idShape )
		61
		62	mesh = smesh.Mesh(shape_mesh, "MeshFlight")
		63
		64
		65	# ---- set Hypothesis and Algorithm
65		66
66	print "-------------------------- LocalLength"	67	print "-------------------------- LocalLength"
67		68
68	lengthOfSegments = 0.3	69	lengthOfSegments = 0.3
69		70
70	hypLength = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")	71	regular1D = mesh.Segment()
71	hypLength.SetLength(lengthOfSegments)	72	hypLength = regular1D.LocalLength(lengthOfSegments)
72
73	print hypLength.GetName()	73	print hypLength.GetName()
74	print hypLength.GetId()	74	print hypLength.GetId()
75	print hypLength.GetLength()	75	print hypLength.GetLength()
76		76	smesh.SetName(hypLength, "LocalLength_" + str(lengthOfSegments))
77	smeshgui.SetName(salome.ObjectToID(hypLength), "LocalLength_0.3")
78		77
79	print "-------------------------- LengthFromEdges"	78	print "-------------------------- LengthFromEdges"
80		79
81	hypLengthFromEdge = smesh.CreateHypothesis("LengthFromEdges", "libStdMeshersEngine.so")	80	mefisto2D = mesh.Triangle()
82		81	hypLengthFromEdge = mefisto2D.LengthFromEdges()
83	print hypLengthFromEdge.GetName()	82	print hypLengthFromEdge.GetName()
84	print hypLengthFromEdge.GetId()	83	print hypLengthFromEdge.GetId()
		84	smesh.SetName(hypLengthFromEdge,"LengthFromEdge")
85		85
86	smeshgui.SetName(salome.ObjectToID(hypLengthFromEdge), "LengthFromEdge")
87
88	print "-------------------------- create Algorithms"
89
90	print "-------------------------- Regular_1D"
91
92	regular1D = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
93
94	smeshgui.SetName(salome.ObjectToID(regular1D), "Wire Discretisation")
95
96	print "-------------------------- MEFISTO_2D"
97
98	mefisto2D = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
99
100	smeshgui.SetName(salome.ObjectToID(mefisto2D), "MEFISTO_2D")
101
102	# ---- init a Mesh with the shell
103	shape_mesh = salome.IDToObject( idShape )
104
105	mesh = smesh.CreateMesh(shape_mesh)
106	smeshgui.SetName(salome.ObjectToID(mesh), "MeshFlight")
107
108	# ---- add hypothesis to flight
109
110	print "-------------------------- add hypothesis to flight"
111
112	mesh.AddHypothesis(shape_mesh,regular1D)
113	mesh.AddHypothesis(shape_mesh,hypLength)
114	mesh.AddHypothesis(shape_mesh,mefisto2D)
115	mesh.AddHypothesis(shape_mesh,hypLengthFromEdge)
116		86
117	salome.sg.updateObjBrowser(1)	87	salome.sg.updateObjBrowser(1)
118		88
119		89
120	print "-------------------------- compute the skin flight"	90	print "-------------------------- compute the skin flight"
121	ret = smesh.Compute(mesh,shape_mesh)	91	ret = mesh.Compute()
122	print ret	92	print ret
123	if ret != 0:	93	if ret != 0:
124	log = mesh.GetLog(0) # no erase trace	94	log = mesh.GetLog(0) # no erase trace

Lines 28-35 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_mechanic_netgen.py (-16 / +13 lines)
28		28
29	geom = geompy.geom	29	geom = geompy.geom
30		30
31	import StdMeshers
32	import NETGENPlugin
33	import smesh	31	import smesh
34		32
35	# ---------------------------- GEOM --------------------------------------	33	# ---------------------------- GEOM --------------------------------------
Lines 109-121 Link Here
109	print "-------------------------- create Mesh, algorithm, hypothesis"	107	print "-------------------------- create Mesh, algorithm, hypothesis"
110		108
111	mesh = smesh.Mesh(mechanic, "Mesh_mechanic");	109	mesh = smesh.Mesh(mechanic, "Mesh_mechanic");
112	netgen = mesh.Netgen(0)	110	netgen = mesh.Triangle(smesh.NETGEN)
113	hyp = netgen.Parameters()	111	netgen.SetMaxSize( 50 )
114	hyp.SetMaxSize( 50 )	112	#netgen.SetSecondOrder( 0 )
115	#hyp.SetSecondOrder( 0 )	113	netgen.SetFineness( smesh.Fine )
116	hyp.SetFineness( 3 )	114	netgen.SetQuadAllowed( 1 )
117	hyp.SetQuadAllowed( 1 )	115	#netgen.SetOptimize( 1 )
118	#hyp.SetOptimize( 1 )
119		116
120	salome.sg.updateObjBrowser(1)	117	salome.sg.updateObjBrowser(1)
121		118
Lines 124-136 Link Here
124	print ret	121	print ret
125	if ret != 0:	122	if ret != 0:
126	print "Information about the MeshcompShel:"	123	print "Information about the MeshcompShel:"
127	print "Number of nodes : ", mesh.GetMesh().NbNodes()	124	print "Number of nodes : ", mesh.NbNodes()
128	print "Number of edges : ", mesh.GetMesh().NbEdges()	125	print "Number of edges : ", mesh.NbEdges()
129	print "Number of faces : ", mesh.GetMesh().NbFaces()	126	print "Number of faces : ", mesh.NbFaces()
130	print "Number of triangles : ", mesh.GetMesh().NbTriangles()	127	print "Number of triangles : ", mesh.NbTriangles()
131	print "Number of quadrangles : ", mesh.GetMesh().NbQuadrangles()	128	print "Number of quadrangles : ", mesh.NbQuadrangles()
132	print "Number of volumes : ", mesh.GetMesh().NbVolumes()	129	print "Number of volumes : ", mesh.NbVolumes()
133	print "Number of tetrahedrons : ", mesh.GetMesh().NbTetras()	130	print "Number of tetrahedrons : ", mesh.NbTetras()
134		131
135	else:	132	else:
136	print "problem when computing the mesh"	133	print "problem when computing the mesh"

Lines 27-65 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_test2.py (-31 / +2 lines)
27	# ---- compute box	27	# ---- compute box
28		28
29	print "-------------------------- compute box"	29	print "-------------------------- compute box"
30	ret = smesh.Compute(mesh,box)	30	ret = mesh.Compute()
31	print ret	31	print ret
32	log = mesh.GetLog(0); # no erase trace	32	log = mesh.GetLog(0); # no erase trace
33	for linelog in log:	33	for linelog in log:
34	print linelog	34	print linelog
35		35
36	salome.sg.updateObjBrowser(1);	36	salome.sg.updateObjBrowser(1)
37
38	# ---- compute edge
39
40	##print "-------------------------- compute edge"
41	##ret=gen.Compute(mesh,idedge)
42	##print ret
43	##log=mesh.GetLog(1);
44	##for a in log:
45	## print a
46
47	# ---- add hypothesis to face
48
49	# ---- compute face
50
51	#print "-------------------------- compute face"
52	#ret=gen.Compute(mesh,idface)
53	#print ret
54	#log=mesh.GetLog(1);
55	#for a in log:
56	# print a
57
58	##shell=salome.IDToObject(ids)
59	##submesh=mesh.GetElementsOnShape(shell)
60	##ret=mesh.AddHypothesis(shell,algoReg)
61	##print ret
62	##ret=mesh.AddHypothesis(shell,hypLen1)
63	##print ret
64	##ret=gen.Compute(mesh,ids)
65	##print ret

Lines 19-29 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/SMESH_test5.py (-13 / +8 lines)
19	#	19	#
20	#	20	#
21	#	21	#
22	# File : SMESH_test1.py	22	# File : SMESH_test5.py
23	# Module : SMESH	23	# Module : SMESH
24		24
25	import salome	25	import salome
26	import SMESH	26	import smesh
27	import SALOMEDS	27	import SALOMEDS
28	import CORBA	28	import CORBA
29	import os	29	import os
Lines 43-68 Link Here
43		43
44	for iMesh in range(len(aMeshes)) :	44	for iMesh in range(len(aMeshes)) :
45	aMesh = aMeshes[iMesh]	45	aMesh = aMeshes[iMesh]
46	anSObj = salome.ObjectToSObject(aMesh)	46	print aMesh.GetName(),
47	print anSObj.GetName(),
48	aFileName = anInitFileName	47	aFileName = anInitFileName
49	aFileName = os.path.basename(aFileName)	48	aFileName = os.path.basename(aFileName)
50	SetSObjName(anSObj,aFileName)	49	aMesh.SetName(aFileName)
51	print anSObj.GetName()	50	print aMesh.GetName()
52		51
53	aOutPath = '/tmp/'	52	aOutPath = '/tmp/'
54	aFileName = aOutPath + theFile + "." + str(iMesh) + ".unv"	53	aFileName = aOutPath + theFile + "." + str(iMesh) + ".unv"
55	aMesh.ExportUNV(aFileName)	54	aMesh.ExportUNV(aFileName)
56	aMesh = smesh.CreateMeshesFromUNV(aFileName)	55	aMesh = smesh.CreateMeshesFromUNV(aFileName)
57	anSObj = salome.ObjectToSObject(aMesh)	56	print aMesh.GetName(),
58	print anSObj.GetName(),
59	os.remove(aFileName)	57	os.remove(aFileName)
60	aFileName = os.path.basename(aFileName)	58	aFileName = os.path.basename(aFileName)
61	SetSObjName(anSObj,aFileName)	59	aMesh.SetName(aFileName)
62	print anSObj.GetName()	60	print aMesh.GetName()
63
64	smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
65	smesh.SetCurrentStudy(salome.myStudy)
66		61
67	aPath = os.getenv('DATA_DIR') + '/MedFiles/'	62	aPath = os.getenv('DATA_DIR') + '/MedFiles/'
68	aListDir = os.listdir(aPath)	63	aListDir = os.listdir(aPath)

Lines 49-92 Link Here

(-)SMESH_SRC_3.2.2/src/SMESH_SWIG/batchmode_mefisto.py (-43 / +11 lines)
49		49
50		50
51	# ---- SMESH	51	# ---- SMESH
		52	print "-------------------------- create mesh"
		53	mesh = smesh.Mesh(shape_mesh)
52		54
53	print "-------------------------- create Hypothesis"	55	print "-------------------------- create Hypothesis"
54	if (len is not None):	56	if (len is not None):
55	print "-------------------------- LocalLength"	57	print "-------------------------- LocalLength"
56	hypLength1 = smesh.CreateHypothesis("LocalLength", "libStdMeshersEngine.so")	58	algoReg = mesh.Segment()
57	hypLength1.SetLength(len)	59	hypLength1 = algoReg.LocalLength(len)
58	print "Hypothesis type : ", hypLength1.GetName()	60	print "Hypothesis type : ", hypLength1.GetName()
59	print "Hypothesis ID : ", hypLength1.GetId()	61	print "Hypothesis ID : ", hypLength1.GetId()
60	print "Hypothesis Value: ", hypLength1.GetLength()	62	print "Hypothesis Value: ", hypLength1.GetLength()
61		63
62	if (nbseg is not None):	64	if (nbseg is not None):
63	print "-------------------------- NumberOfSegments"	65	print "-------------------------- NumberOfSegments"
64	hypNbSeg1 = smesh.CreateHypothesis("NumberOfSegments", "libStdMeshersEngine.so")	66	algoReg = mesh.Segment()
65	hypNbSeg1.SetNumberOfSegments(nbseg)	67	hypNbSeg1 = algoReg.NumberOfSegments(nbseg)
66	print "Hypothesis type : ", hypNbSeg1.GetName()	68	print "Hypothesis type : ", hypNbSeg1.GetName()
67	print "Hypothesis ID : ", hypNbSeg1.GetId()	69	print "Hypothesis ID : ", hypNbSeg1.GetId()
68	print "Hypothesis Value: ", hypNbSeg1.GetNumberOfSegments()	70	print "Hypothesis Value: ", hypNbSeg1.GetNumberOfSegments()
69		71
70	if (area == "LengthFromEdges"):	72	if (area == "LengthFromEdges"):
71	print "-------------------------- LengthFromEdges"	73	print "-------------------------- LengthFromEdges"
72	hypLengthFromEdges = smesh.CreateHypothesis("LengthFromEdges", "libStdMeshersEngine.so")	74	algoMef = mesh.Triangle()
73	hypLengthFromEdges.SetMode(1)	75	hypLengthFromEdges = algoMef.LengthFromEdges(1)
74	print "Hypothesis type : ", hypLengthFromEdges.GetName()	76	print "Hypothesis type : ", hypLengthFromEdges.GetName()
75	print "Hypothesis ID : ", hypLengthFromEdges.GetId()	77	print "Hypothesis ID : ", hypLengthFromEdges.GetId()
76	print "LengthFromEdges Mode: ", hypLengthFromEdges.GetMode()	78	print "LengthFromEdges Mode: ", hypLengthFromEdges.GetMode()
77		79
78	else:	80	else:
79	print "-------------------------- MaxElementArea"	81	print "-------------------------- MaxElementArea"
80	hypArea1 = smesh.CreateHypothesis("MaxElementArea", "libStdMeshersEngine.so")	82	algoMef = mesh.Triangle()
81	hypArea1.SetMaxElementArea(area)	83	hypArea1 = algoMef.MaxElementArea(area)
82	print "Hypothesis type : ", hypArea1.GetName()	84	print "Hypothesis type : ", hypArea1.GetName()
83	print "Hypothesis ID : ", hypArea1.GetId()	85	print "Hypothesis ID : ", hypArea1.GetId()
84	print "Hypothesis Value: ", hypArea1.GetMaxElementArea()	86	print "Hypothesis Value: ", hypArea1.GetMaxElementArea()
85		87
86		88
87	print "-------------------------- Regular_1D"	89	print "-------------------------- Regular_1D"
88	algoReg = smesh.CreateHypothesis("Regular_1D", "libStdMeshersEngine.so")
89
90	listHyp = algoReg.GetCompatibleHypothesis()	90	listHyp = algoReg.GetCompatibleHypothesis()
91	for hyp in listHyp:	91	for hyp in listHyp:
92	print hyp	92	print hyp
Lines 95-102 Link Here
95	print "Algo ID : ", algoReg.GetId()	95	print "Algo ID : ", algoReg.GetId()
96		96
97	print "-------------------------- MEFISTO_2D"	97	print "-------------------------- MEFISTO_2D"
98	algoMef = smesh.CreateHypothesis("MEFISTO_2D", "libStdMeshersEngine.so")
99
100	listHyp = algoMef.GetCompatibleHypothesis()	98	listHyp = algoMef.GetCompatibleHypothesis()
101	for hyp in listHyp:	99	for hyp in listHyp:
102	print hyp	100	print hyp
Lines 107-144 Link Here
107		105
108	# ---- add hypothesis to shape	106	# ---- add hypothesis to shape
109		107
110	print "-------------------------- add hypothesis to shape"
111	mesh = smesh.CreateMesh(shape_mesh)
112
113	ret = mesh.AddHypothesis(shape_mesh, algoReg)
114	print "Add Regular_1D algo .... ",
115	print ret
116
117	if (nbseg is not None):
118	ret = mesh.AddHypothesis(shape_mesh, hypNbSeg1)
119	print "Add Number Of Segements algo .... ",
120	print ret
121
122	if (len is not None):
123	ret = mesh.AddHypothesis(shape_mesh,hypLength1)
124	print "Add Local Length algo .... ",
125	print ret
126
127	ret = mesh.AddHypothesis(shape_mesh, algoMef)
128	print "Add MEFISTO_2D algo....",
129	print ret
130
131	if (area == "LengthFromEdges"):
132	ret = mesh.AddHypothesis( shape_mesh, hypLengthFromEdges) # length from edge
133	print "Add Length From Edges algo .... ",
134	print ret
135	else:
136	ret = mesh.AddHypothesis(shape_mesh, hypArea1)
137	print "Add Max Triangle Area algo .... ",
138	print ret
139
140	print "-------------------------- compute mesh"	108	print "-------------------------- compute mesh"
141	ret = smesh.Compute(mesh,shape_mesh)	109	ret = mesh.Compute()
142	print "Compute Mesh .... ",	110	print "Compute Mesh .... ",
143	print ret	111	print ret
144	log = mesh.GetLog(0); # no erase trace	112	log = mesh.GetLog(0); # no erase trace