]> SALOME platform Git repositories - modules/smesh.git/blob - src/StdMeshers/StdMeshers_Import_1D.cxx
Salome HOME
Fix memory leaks
[modules/smesh.git] / src / StdMeshers / StdMeshers_Import_1D.cxx
1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 //  SMESH SMESH : implementaion of SMESH idl descriptions
24 //  File   : StdMeshers_Import_1D.cxx
25 //  Module : SMESH
26 //
27 #include "StdMeshers_Import_1D.hxx"
28 #include "StdMeshers_ImportSource.hxx"
29
30 #include "SMDS_MeshElement.hxx"
31 #include "SMDS_MeshNode.hxx"
32 #include "SMESHDS_Group.hxx"
33 #include "SMESHDS_Mesh.hxx"
34 #include "SMESH_Comment.hxx"
35 #include "SMESH_Gen.hxx"
36 #include "SMESH_Group.hxx"
37 #include "SMESH_HypoFilter.hxx"
38 #include "SMESH_Mesh.hxx"
39 #include "SMESH_MesherHelper.hxx"
40 #include "SMESH_subMesh.hxx"
41 #include "SMESH_subMeshEventListener.hxx"
42
43 #include "Utils_SALOME_Exception.hxx"
44 #include "utilities.h"
45
46 #include <BRep_Builder.hxx>
47 #include <BRep_Tool.hxx>
48 #include <TopExp.hxx>
49 #include <TopExp_Explorer.hxx>
50 #include <TopoDS.hxx>
51 #include <TopoDS_Compound.hxx>
52 #include <TopoDS_Edge.hxx>
53 #include <TopoDS_Vertex.hxx>
54
55 using namespace std;
56
57 //=============================================================================
58 /*!
59  * Creates StdMeshers_Import_1D
60  */
61 //=============================================================================
62
63 StdMeshers_Import_1D::StdMeshers_Import_1D(int hypId, int studyId, SMESH_Gen * gen)
64   :SMESH_1D_Algo(hypId, studyId, gen), _sourceHyp(0)
65 {
66   MESSAGE("StdMeshers_Import_1D::StdMeshers_Import_1D");
67   _name = "Import_1D";
68   _shapeType = (1 << TopAbs_EDGE);
69
70   _compatibleHypothesis.push_back("ImportSource1D");
71 }
72
73 //=============================================================================
74 /*!
75  * Check presence of a hypothesis
76  */
77 //=============================================================================
78
79 bool StdMeshers_Import_1D::CheckHypothesis
80                          (SMESH_Mesh&                          aMesh,
81                           const TopoDS_Shape&                  aShape,
82                           SMESH_Hypothesis::Hypothesis_Status& aStatus)
83 {
84   _sourceHyp = 0;
85
86   const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(aMesh, aShape);
87   if ( hyps.size() == 0 )
88   {
89     aStatus = SMESH_Hypothesis::HYP_MISSING;
90     return false;  // can't work with no hypothesis
91   }
92
93   if ( hyps.size() > 1 )
94   {
95     aStatus = SMESH_Hypothesis::HYP_ALREADY_EXIST;
96     return false;
97   }
98
99   const SMESHDS_Hypothesis *theHyp = hyps.front();
100
101   string hypName = theHyp->GetName();
102
103   if (hypName == _compatibleHypothesis.front())
104   {
105     _sourceHyp = (StdMeshers_ImportSource1D *)theHyp;
106     aStatus = SMESH_Hypothesis::HYP_OK;
107     return true;
108   }
109
110   aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
111   return true;
112 }
113
114 //================================================================================
115 namespace // INTERNAL STUFF
116 //================================================================================
117 {
118   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS, SMESH_Mesh* tgtMesh);
119
120   enum _ListenerDataType
121     {
122       WAIT_HYP_MODIF=1, // data indicating awaiting for valid parameters of src hyp
123       LISTEN_SRC_MESH, // data storing submesh depending on source mesh state
124       SRC_HYP // data storing ImportSource hyp
125     };
126   //================================================================================
127   /*!
128    * \brief _ListenerData holding ImportSource hyp holding in its turn
129    *  imported groups
130    */
131   struct _ListenerData : public SMESH_subMeshEventListenerData
132   {
133     const StdMeshers_ImportSource1D* _srcHyp;
134     _ListenerData(const StdMeshers_ImportSource1D* h, _ListenerDataType type=SRC_HYP):
135       SMESH_subMeshEventListenerData(/*isDeletable=*/true), _srcHyp(h)
136     {
137       myType = type;
138     }
139   };
140   //================================================================================
141   /*!
142    * \brief Comparator of sub-meshes
143    */
144   struct _SubLess
145   {
146     bool operator()(const SMESH_subMesh* sm1, const SMESH_subMesh* sm2 ) const
147     {
148       if ( sm1 == sm2 ) return false;
149       if ( !sm1 || !sm2 ) return sm1 < sm2;
150       const TopoDS_Shape& s1 = sm1->GetSubShape();
151       const TopoDS_Shape& s2 = sm2->GetSubShape();
152       TopAbs_ShapeEnum t1 = s1.IsNull() ? TopAbs_SHAPE : s1.ShapeType();
153       TopAbs_ShapeEnum t2 = s2.IsNull() ? TopAbs_SHAPE : s2.ShapeType();
154       if ( t1 == t2)
155         return (sm1 < sm2);
156       return t1 < t2; // to have: face < edge
157     }
158   };
159   //================================================================================
160   /*!
161    * \brief Container of data dedicated to one source mesh
162    */
163   struct _ImportData
164   {
165     const SMESH_Mesh* _srcMesh;
166     StdMeshers_Import_1D::TNodeNodeMap _n2n;
167     StdMeshers_Import_1D::TElemElemMap _e2e;
168
169     set< SMESH_subMesh*, _SubLess > _subM; // submeshes relating to this srcMesh
170     set< SMESH_subMesh*, _SubLess > _copyMeshSubM; // submeshes requesting mesh copying
171     set< SMESH_subMesh*, _SubLess > _copyGroupSubM; // submeshes requesting group copying
172     set< SMESH_subMesh*, _SubLess > _computedSubM;
173
174     SMESHDS_SubMesh*     _importMeshSubDS; // submesh storing a copy of _srcMesh
175     int                  _importMeshSubID; // id of _importMeshSubDS
176
177     _ImportData(const SMESH_Mesh* srcMesh=0):
178       _srcMesh(srcMesh), _importMeshSubDS(0),_importMeshSubID(-1) {}
179
180     void removeImportedMesh( SMESHDS_Mesh* meshDS )
181     {
182       if ( !_importMeshSubDS ) return;
183       SMDS_ElemIteratorPtr eIt = _importMeshSubDS->GetElements();
184       while ( eIt->more() )
185         meshDS->RemoveFreeElement( eIt->next(), 0, /*fromGroups=*/false );
186       SMDS_NodeIteratorPtr nIt = _importMeshSubDS->GetNodes();
187       while ( nIt->more() )
188         meshDS->RemoveFreeNode( nIt->next(), 0, /*fromGroups=*/false );
189       _importMeshSubDS->Clear();
190       _n2n.clear();
191       _e2e.clear();
192     }
193     void removeGroups( SMESH_subMesh* subM, const StdMeshers_ImportSource1D* srcHyp )
194     {
195       if ( !srcHyp ) return;
196       SMESH_Mesh*           tgtMesh = subM->GetFather();
197       const SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
198       const SMESHDS_Mesh* srcMeshDS = _srcMesh->GetMeshDS();
199       vector<SMESH_Group*>*  groups =
200         const_cast<StdMeshers_ImportSource1D*>(srcHyp)->GetResultGroups(*srcMeshDS,*tgtMeshDS);
201       if ( groups )
202       {
203         for ( unsigned i = 0; i < groups->size(); ++i )
204           tgtMesh->RemoveGroup( groups->at(i)->GetGroupDS()->GetID() );
205         groups->clear();
206       }
207     }
208     void trackHypParams( SMESH_subMesh* sm, const StdMeshers_ImportSource1D* srcHyp )
209     {
210       if ( !srcHyp ) return;
211       bool toCopyMesh, toCopyGroups;
212       srcHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
213
214       if ( toCopyMesh )_copyMeshSubM.insert( sm );
215       else             _copyMeshSubM.erase( sm );
216
217       if ( toCopyGroups ) _copyGroupSubM.insert( sm );
218       else                _copyGroupSubM.erase( sm );
219     }
220     void addComputed( SMESH_subMesh* sm )
221     {
222       SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true,
223                                                                /*complexShapeFirst=*/true);
224       while ( smIt->more() )
225       {
226         sm = smIt->next();
227         switch ( sm->GetSubShape().ShapeType() )
228         {
229         case TopAbs_EDGE:
230           if ( SMESH_Algo::isDegenerated( TopoDS::Edge( sm->GetSubShape() )))
231             continue;
232         case TopAbs_FACE:
233           _subM.insert( sm );
234           if ( !sm->IsEmpty() )
235             _computedSubM.insert( sm );
236         case TopAbs_VERTEX:
237           break;
238         default:;
239         }
240       }
241     }
242   };
243   //================================================================================
244   /*!
245    * Listener notified on events relating to imported submesh
246    */
247   class _Listener : public SMESH_subMeshEventListener
248   {
249     typedef map< SMESH_Mesh*, list< _ImportData > > TMesh2ImpData;
250     TMesh2ImpData _tgtMesh2ImportData;
251
252     _Listener():SMESH_subMeshEventListener(/*isDeletable=*/false,
253                                            "StdMeshers_Import_1D::_Listener") {}
254
255   public:
256     // return poiter to a static listener
257     static _Listener* get() { static _Listener theListener; return &theListener; }
258
259     static _ImportData* getImportData(const SMESH_Mesh* srcMesh, SMESH_Mesh* tgtMesh);
260
261     static void storeImportSubmesh(SMESH_subMesh*                   importSub,
262                                    const SMESH_Mesh*                srcMesh,
263                                    const StdMeshers_ImportSource1D* srcHyp);
264
265     virtual void ProcessEvent(const int                       event,
266                               const int                       eventType,
267                               SMESH_subMesh*                  subMesh,
268                               SMESH_subMeshEventListenerData* data,
269                               const SMESH_Hypothesis*         hyp);
270     void removeSubmesh( SMESH_subMesh* sm, _ListenerData* data );
271     void clearSubmesh ( SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub );
272     void clearN2N     ( SMESH_Mesh* tgtMesh );
273
274     // mark sm as missing src hyp with valid groups
275     static void waitHypModification(SMESH_subMesh* sm)
276     {
277       sm->SetEventListener
278         (get(), SMESH_subMeshEventListenerData::MakeData( sm, WAIT_HYP_MODIF ), sm);
279     }
280   };
281   //--------------------------------------------------------------------------------
282   /*!
283    * \brief Find or create ImportData for given meshes
284    */
285   _ImportData* _Listener::getImportData(const SMESH_Mesh* srcMesh,
286                                         SMESH_Mesh*       tgtMesh)
287   {
288     list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
289     list< _ImportData >::iterator d = dList.begin();
290     for ( ; d != dList.end(); ++d )
291       if ( d->_srcMesh == srcMesh )
292         return &*d;
293     dList.push_back(_ImportData(srcMesh));
294     return &dList.back();
295   }
296
297   //--------------------------------------------------------------------------------
298   /*!
299    * \brief Remember an imported sub-mesh and set needed even listeners
300    *  \param importSub - submesh computed by Import algo
301    *  \param srcMesh - source mesh
302    *  \param srcHyp - ImportSource hypothesis
303    */
304   void _Listener::storeImportSubmesh(SMESH_subMesh*                   importSub,
305                                      const SMESH_Mesh*                srcMesh,
306                                      const StdMeshers_ImportSource1D* srcHyp)
307   {
308     // set listener to hear events of the submesh computed by "Import" algo
309     importSub->SetEventListener( get(), new _ListenerData(srcHyp), importSub );
310
311     // set listeners to hear events of the source mesh
312     SMESH_subMesh* smToNotify = importSub;
313     vector<SMESH_subMesh*> smToListen = srcHyp->GetSourceSubMeshes( srcMesh );
314     for ( size_t i = 0; i < smToListen.size(); ++i )
315     {
316       SMESH_subMeshEventListenerData* data = new _ListenerData(srcHyp, LISTEN_SRC_MESH);
317       data->mySubMeshes.push_back( smToNotify );
318       importSub->SetEventListener( get(), data, smToListen[i] );
319     }
320     // remember the submesh importSub and its sub-submeshes
321     _ImportData* iData = _Listener::getImportData( srcMesh, importSub->GetFather());
322     iData->trackHypParams( importSub, srcHyp );
323     iData->addComputed( importSub );
324     if ( !iData->_copyMeshSubM.empty() && iData->_importMeshSubID < 1 )
325     {
326       SMESH_Mesh* tgtMesh = importSub->GetFather();
327       iData->_importMeshSubID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(),tgtMesh);
328       iData->_importMeshSubDS = tgtMesh->GetMeshDS()->NewSubMesh( iData->_importMeshSubID );
329     }
330   }
331   //--------------------------------------------------------------------------------
332   /*!
333    * \brief Remove imported mesh and/or groups if needed
334    *  \param sm - submesh loosing Import algo
335    *  \param data - data holding imported groups
336    */
337   void _Listener::removeSubmesh( SMESH_subMesh* sm, _ListenerData* data )
338   {
339     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
340     list< _ImportData >::iterator d = dList.begin();
341     for ( ; d != dList.end(); ++d )
342       if ( (*d)._subM.erase( sm ))
343       {
344         d->_computedSubM.erase( sm );
345         bool rmMesh   = d->_copyMeshSubM.erase( sm ) && d->_copyMeshSubM.empty();
346         bool rmGroups = (d->_copyGroupSubM.erase( sm ) && d->_copyGroupSubM.empty()) || rmMesh;
347         if ( rmMesh )
348           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
349         if ( rmGroups && data )
350           d->removeGroups( sm, data->_srcHyp );
351       }
352   }
353   //--------------------------------------------------------------------------------
354   /*!
355    * \brief Clear _ImportData::_n2n.
356    *        _n2n is usefull within one mesh.Compute() only
357    */
358   void _Listener::clearN2N( SMESH_Mesh* tgtMesh )
359   {
360     list< _ImportData >& dList = get()->_tgtMesh2ImportData[tgtMesh];
361     list< _ImportData >::iterator d = dList.begin();
362     for ( ; d != dList.end(); ++d )
363       d->_n2n.clear();
364   }
365   //--------------------------------------------------------------------------------
366   /*!
367    * \brief Clear submeshes and remove imported mesh and/or groups if necessary
368    *  \param sm - cleared submesh
369    *  \param data - data holding imported groups
370    */
371   void _Listener::clearSubmesh(SMESH_subMesh* sm, _ListenerData* data, bool clearAllSub)
372   {
373     list< _ImportData > &  dList = _tgtMesh2ImportData[ sm->GetFather() ];
374     list< _ImportData >::iterator d = dList.begin();
375     for ( ; d != dList.end(); ++d )
376     {
377       if ( !d->_subM.count( sm )) continue;
378       if ( (*d)._computedSubM.erase( sm ) )
379       {
380         bool copyMesh = !d->_copyMeshSubM.empty();
381         if ( copyMesh || clearAllSub )
382         {
383           // remove imported mesh and groups
384           d->removeImportedMesh( sm->GetFather()->GetMeshDS() );
385
386           if ( data )
387             d->removeGroups( sm, data->_srcHyp );
388
389           // clear the rest submeshes
390           if ( !d->_computedSubM.empty() )
391           {
392             d->_computedSubM.clear();
393             set< SMESH_subMesh*, _SubLess>::iterator sub = d->_subM.begin();
394             for ( ; sub != d->_subM.end(); ++sub )
395             {
396               SMESH_subMesh* subM = *sub;
397               _ListenerData* hypData = (_ListenerData*) subM->GetEventListenerData( get() );
398               if ( hypData )
399                 d->removeGroups( sm, hypData->_srcHyp );
400
401               subM->ComputeStateEngine( SMESH_subMesh::CLEAN );
402               if ( subM->GetSubShape().ShapeType() == TopAbs_FACE )
403                 subM->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
404             }
405           }
406         }
407         sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
408         if ( sm->GetSubShape().ShapeType() == TopAbs_FACE )
409           sm->ComputeSubMeshStateEngine( SMESH_subMesh::CLEAN );
410       }
411       if ( data )
412         d->trackHypParams( sm, data->_srcHyp );
413       d->_n2n.clear();
414       d->_e2e.clear();
415     }
416   }
417   //--------------------------------------------------------------------------------
418   /*!
419    * \brief Remove imported mesh and/or groups
420    */
421   void _Listener::ProcessEvent(const int                       event,
422                                const int                       eventType,
423                                SMESH_subMesh*                  subMesh,
424                                SMESH_subMeshEventListenerData* data,
425                                const SMESH_Hypothesis*         /*hyp*/)
426   {
427     if ( data && data->myType == WAIT_HYP_MODIF )
428     {
429       // event of Import submesh
430       if ( SMESH_subMesh::MODIF_HYP  == event &&
431            SMESH_subMesh::ALGO_EVENT == eventType )
432       {
433         // re-call SetEventListener() to take into account valid parameters
434         // of ImportSource hypothesis
435         if ( SMESH_Algo* algo = subMesh->GetAlgo() )
436           algo->SetEventListener( subMesh );
437       }
438     }
439     else if ( data && data->myType == LISTEN_SRC_MESH )
440     {
441       // event of source mesh
442       if ( SMESH_subMesh::COMPUTE_EVENT == eventType )
443       {
444         switch ( event ) {
445         case SMESH_subMesh::CLEAN:
446           // source mesh cleaned -> clean target mesh
447           clearSubmesh( data->mySubMeshes.front(), (_ListenerData*) data, /*all=*/true );
448           break;
449         case SMESH_subMesh::SUBMESH_COMPUTED: {
450           // source mesh computed -> reset FAILED state of Import submeshes to
451           // READY_TO_COMPUTE
452           SMESH_Mesh* srcMesh = subMesh->GetFather();
453           if ( srcMesh->NbEdges() > 0 || srcMesh->NbFaces() > 0 )
454           {
455             SMESH_Mesh* m = data->mySubMeshes.front()->GetFather();
456             if ( SMESH_subMesh* sm1 = m->GetSubMeshContaining(1))
457             {
458               sm1->ComputeStateEngine(SMESH_subMesh::SUBMESH_COMPUTED );
459               sm1->ComputeSubMeshStateEngine( SMESH_subMesh::SUBMESH_COMPUTED );
460             }
461           }
462           break;
463         }
464         default:;
465         }
466       }
467       if ( !data->mySubMeshes.empty() )
468         clearN2N( data->mySubMeshes.front()->GetFather() );
469     }
470     else // event of Import submesh
471     {
472       // find out what happens: import hyp modified or removed
473       bool removeImport = false, modifHyp = false;
474       if ( SMESH_subMesh::ALGO_EVENT == eventType )
475         modifHyp = true;
476       if ( subMesh->GetAlgoState() != SMESH_subMesh::HYP_OK )
477       {
478         removeImport = true;
479       }
480       else if (( SMESH_subMesh::REMOVE_ALGO == event ||
481                  SMESH_subMesh::REMOVE_FATHER_ALGO == event ) &&
482                SMESH_subMesh::ALGO_EVENT == eventType )
483       {
484         SMESH_Algo* algo = subMesh->GetAlgo();
485         removeImport = ( strncmp( "Import", algo->GetName(), 6 ) != 0 );
486       }
487
488       if ( removeImport )
489       {
490         // treate removal of Import algo from subMesh
491         removeSubmesh( subMesh, (_ListenerData*) data );
492       }
493       else if ( modifHyp ||
494                 ( SMESH_subMesh::CLEAN         == event &&
495                   SMESH_subMesh::COMPUTE_EVENT == eventType))
496       {
497         // treate modification of ImportSource hypothesis
498         clearSubmesh( subMesh, (_ListenerData*) data, /*all=*/false );
499       }
500       else if ( SMESH_subMesh::CHECK_COMPUTE_STATE == event &&
501                 SMESH_subMesh::COMPUTE_EVENT       == eventType )
502       {
503         // check compute state of all submeshes impoting from same src mesh;
504         // this is to take into account 1D computed submeshes hidden by 2D import algo;
505         // else source mesh is not copied as _subM.size != _computedSubM.size()
506         list< _ImportData > &  dList = _tgtMesh2ImportData[ subMesh->GetFather() ];
507         list< _ImportData >::iterator d = dList.begin();
508         for ( ; d != dList.end(); ++d )
509           if ( d->_subM.count( subMesh ))
510           {
511             set<SMESH_subMesh*,_SubLess>::iterator smIt = d->_subM.begin();
512             for( ; smIt != d->_subM.end(); ++smIt )
513               if ( (*smIt)->IsMeshComputed() )
514                 d->_computedSubM.insert( *smIt);
515           }
516       }
517       // Clear _ImportData::_n2n if it's no more useful, i.e. when
518       // the event is not within mesh.Compute()
519       if ( SMESH_subMesh::ALGO_EVENT == eventType )
520         clearN2N( subMesh->GetFather() );
521     }
522   }
523
524   //================================================================================
525   /*!
526    * \brief Return an ID of submesh to store nodes and elements of a copied mesh
527    */
528   //================================================================================
529
530   int getSubmeshIDForCopiedMesh(const SMESHDS_Mesh* srcMeshDS,
531                                 SMESH_Mesh*         tgtMesh)
532   {
533     // To get SMESH_subMesh corresponding to srcMeshDS we need to have a shape
534     // for which SMESHDS_Mesh::IsGroupOfSubShapes() returns true.
535     // And this shape must be different from sub-shapes of the main shape.
536     // So we create a compound containing
537     // 1) some sub-shapes of SMESH_Mesh::PseudoShape() corresponding to
538     //    srcMeshDS->GetPersistentId()
539     // 2) the 1-st vertex of the main shape to assure
540     //    SMESHDS_Mesh::IsGroupOfSubShapes(shape)==true
541     TopoDS_Shape shapeForSrcMesh;
542     TopTools_IndexedMapOfShape pseudoSubShapes;
543     TopExp::MapShapes( SMESH_Mesh::PseudoShape(), pseudoSubShapes );
544
545     // index of pseudoSubShapes corresponding to srcMeshDS
546     int    subIndex = 1 + srcMeshDS->GetPersistentId() % pseudoSubShapes.Extent();
547     int nbSubShapes = 1 + srcMeshDS->GetPersistentId() / pseudoSubShapes.Extent();
548
549     // try to find already present shapeForSrcMesh
550     SMESHDS_Mesh* tgtMeshDS = tgtMesh->GetMeshDS();
551     for ( int i = tgtMeshDS->MaxShapeIndex(); i > 0 && shapeForSrcMesh.IsNull(); --i )
552     {
553       const TopoDS_Shape& s = tgtMeshDS->IndexToShape(i);
554       if ( s.ShapeType() != TopAbs_COMPOUND ) break;
555       TopoDS_Iterator sSubIt( s );
556       for ( int iSub = 0; iSub < nbSubShapes && sSubIt.More(); ++iSub, sSubIt.Next() )
557         if ( pseudoSubShapes( subIndex+iSub ).IsSame( sSubIt.Value()))
558           if ( iSub+1 == nbSubShapes )
559           {
560             shapeForSrcMesh = s;
561             break;
562           }
563     }
564     if ( shapeForSrcMesh.IsNull() )
565     {
566       // make a new shapeForSrcMesh
567       BRep_Builder aBuilder;
568       TopoDS_Compound comp;
569       aBuilder.MakeCompound( comp );
570       shapeForSrcMesh = comp;
571       for ( int iSub = 0; iSub < nbSubShapes; ++iSub )
572         aBuilder.Add( comp, pseudoSubShapes( subIndex+iSub ));
573       TopExp_Explorer vExp( tgtMeshDS->ShapeToMesh(), TopAbs_VERTEX );
574       aBuilder.Add( comp, vExp.Current() );
575     }
576     SMESH_subMesh* sm = tgtMesh->GetSubMesh( shapeForSrcMesh );
577     SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
578     if ( !smDS )
579       smDS = tgtMeshDS->NewSubMesh( sm->GetId() );
580
581     // make ordinary submesh from a complex one
582     if ( smDS->IsComplexSubmesh() )
583     {
584       list< const SMESHDS_SubMesh* > subSM;
585       SMESHDS_SubMeshIteratorPtr smIt = smDS->GetSubMeshIterator();
586       while ( smIt->more() ) subSM.push_back( smIt->next() );
587       list< const SMESHDS_SubMesh* >::iterator sub = subSM.begin();
588       for ( ; sub != subSM.end(); ++sub)
589         smDS->RemoveSubMesh( *sub );
590     }
591     return sm->GetId();
592   }
593
594   //================================================================================
595   /*!
596    * \brief Return a submesh to store nodes and elements of a copied mesh
597    * and set event listeners in order to clear
598    * imported mesh and groups as soon as submesh state requires it
599    */
600   //================================================================================
601
602   SMESHDS_SubMesh* getSubmeshForCopiedMesh(const SMESH_Mesh*                    srcMesh,
603                                            SMESH_Mesh*                          tgtMesh,
604                                            const TopoDS_Shape&                  tgtShape,
605                                            StdMeshers_Import_1D::TNodeNodeMap*& n2n,
606                                            StdMeshers_Import_1D::TElemElemMap*& e2e,
607                                            bool &                               toCopyGroups)
608   {
609     StdMeshers_Import_1D::getMaps( srcMesh, tgtMesh, n2n,e2e );
610
611     _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
612
613     SMESH_subMesh* importedSM = tgtMesh->GetSubMesh( tgtShape );
614     iData->addComputed( importedSM );
615     if ( iData->_computedSubM.size() != iData->_subM.size() )
616       return 0; // not all submeshes computed yet
617
618     toCopyGroups = !iData->_copyGroupSubM.empty();
619
620     if ( !iData->_copyMeshSubM.empty())
621     {
622       // make submesh to store a copied mesh
623       int smID = getSubmeshIDForCopiedMesh( srcMesh->GetMeshDS(), tgtMesh );
624       SMESHDS_SubMesh* subDS = tgtMesh->GetMeshDS()->NewSubMesh( smID );
625
626       iData->_importMeshSubID = smID;
627       iData->_importMeshSubDS = subDS;
628       return subDS;
629     }
630     return 0;
631   }
632
633 } // namespace
634
635
636 //=============================================================================
637 /*!
638  * Import elements from the other mesh
639  */
640 //=============================================================================
641
642 bool StdMeshers_Import_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
643 {
644   if ( !_sourceHyp ) return false;
645
646   //MESSAGE("---------> StdMeshers_Import_1D::Compute");
647   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups(/*loaded=*/true);
648   if ( srcGroups.empty() )
649     return error("Invalid source groups");
650
651   SMESH_MesherHelper helper(theMesh);
652   helper.SetSubShape(theShape);
653   SMESHDS_Mesh* tgtMesh = theMesh.GetMeshDS();
654
655   const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
656   const double edgeTol = BRep_Tool::Tolerance( geomEdge );
657   const int shapeID = tgtMesh->ShapeToIndex( geomEdge );
658
659   set<int> subShapeIDs;
660   subShapeIDs.insert( shapeID );
661
662   // get nodes on vertices
663   list < SMESH_TNodeXYZ > vertexNodes;
664   list < SMESH_TNodeXYZ >::iterator vNIt;
665   TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
666   for ( ; vExp.More(); vExp.Next() )
667   {
668     const TopoDS_Vertex& v = TopoDS::Vertex( vExp.Current() );
669     if ( !subShapeIDs.insert( tgtMesh->ShapeToIndex( v )).second )
670       continue; // closed edge
671     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
672     if ( !n )
673     {
674       _gen->Compute(theMesh,v,/*anUpward=*/true);
675       n = SMESH_Algo::VertexNode( v, tgtMesh );
676       //MESSAGE("_gen->Compute " << n);
677       if ( !n ) return false; // very strange
678     }
679     vertexNodes.push_back( SMESH_TNodeXYZ( n ));
680     //MESSAGE("SMESH_Algo::VertexNode " << n->GetID() << " " << n->X() << " " << n->Y() << " " << n->Z() );
681   }
682
683   // import edges from groups
684   TNodeNodeMap* n2n;
685   TElemElemMap* e2e;
686   for ( int iG = 0; iG < srcGroups.size(); ++iG )
687   {
688     const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
689
690     const int meshID = srcGroup->GetMesh()->GetPersistentId();
691     const SMESH_Mesh* srcMesh = GetMeshByPersistentID( meshID );
692     if ( !srcMesh ) continue;
693     getMaps( srcMesh, &theMesh, n2n, e2e );
694
695     SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
696     vector<const SMDS_MeshNode*> newNodes;
697     SMDS_MeshNode *tmpNode = helper.AddNode(0,0,0);
698     double u = 0.314159; // "random" value between 0 and 1, avoid 0 and 1, false detection possible on edge restrictions
699     while ( srcElems->more() ) // loop on group contents
700     {
701       const SMDS_MeshElement* edge = srcElems->next();
702       // find or create nodes of a new edge
703       newNodes.resize( edge->NbNodes() );
704       //MESSAGE("edge->NbNodes " << edge->NbNodes());
705       newNodes.back() = 0;
706       SMDS_MeshElement::iterator node = edge->begin_nodes();
707       SMESH_TNodeXYZ a(edge->GetNode(0));
708       // --- define a tolerance relative to the length of an edge
709       double mytol = a.Distance(edge->GetNode(edge->NbNodes()-1))/25;
710       //mytol = max(1.E-5, 10*edgeTol); // too strict and not necessary
711       //MESSAGE("mytol = " << mytol);
712       for ( unsigned i = 0; i < newNodes.size(); ++i, ++node )
713       {
714         TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
715         if ( n2nIt->second )
716         {
717           if ( !subShapeIDs.count( n2nIt->second->getshapeId() ))
718             break;
719         }
720         else
721         {
722           // find an existing vertex node
723           double checktol = max(1.E-10, 10*edgeTol*edgeTol);
724           for ( vNIt = vertexNodes.begin(); vNIt != vertexNodes.end(); ++vNIt)
725             if ( vNIt->SquareDistance( *node ) < checktol)
726             {
727               //MESSAGE("SquareDistance " << vNIt->SquareDistance( *node ) << " checktol " << checktol <<" "<<vNIt->X()<<" "<<vNIt->Y()<<" "<<vNIt->Z());
728               (*n2nIt).second = vNIt->_node;
729               vertexNodes.erase( vNIt );
730               break;
731             }
732             else if ( vNIt->SquareDistance( *node ) < 10*checktol)
733               MESSAGE("SquareDistance missed" << vNIt->SquareDistance( *node ) << " checktol " << checktol <<" "<<vNIt->X()<<" "<<vNIt->Y()<<" "<<vNIt->Z());
734         }
735         if ( !n2nIt->second )
736         {
737           // find out if node lies on theShape
738           //double dxyz[4];
739           tmpNode->setXYZ( (*node)->X(), (*node)->Y(), (*node)->Z());
740           if ( helper.CheckNodeU( geomEdge, tmpNode, u, mytol, /*force=*/true)) // , dxyz )) // dxyz used for debug purposes
741           {
742             SMDS_MeshNode* newNode = tgtMesh->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
743             n2nIt->second = newNode;
744             tgtMesh->SetNodeOnEdge( newNode, shapeID, u );
745             //MESSAGE("u=" << u << " " << newNode->X()<< " " << newNode->Y()<< " " << newNode->Z());
746             //MESSAGE("d=" << dxyz[0] << " " << dxyz[1] << " " << dxyz[2] << " " << dxyz[3]);
747           }
748         }
749         if ( !(newNodes[i] = n2nIt->second ))
750           break;
751       }
752       if ( !newNodes.back() )
753       {
754         //MESSAGE("not all nodes of edge lie on theShape");
755         continue; // not all nodes of edge lie on theShape
756       }
757
758       // make a new edge
759       SMDS_MeshElement * newEdge;
760       if ( newNodes.size() == 3 )
761         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1], newNodes[2] );
762       else
763         newEdge = tgtMesh->AddEdge( newNodes[0], newNodes[1]);
764       //MESSAGE("add Edge " << newNodes[0]->GetID() << " " << newNodes[1]->GetID());
765       tgtMesh->SetMeshElementOnShape( newEdge, shapeID );
766       e2e->insert( make_pair( edge, newEdge ));
767     }
768     helper.GetMeshDS()->RemoveNode(tmpNode);
769   }
770   if ( n2n->empty())
771     return error("Empty source groups");
772
773   // check if the whole geom edge is covered by imported segments;
774   // the check consist in passing by segments from one vetrex node to another
775   bool isEdgeMeshed = false;
776   if ( SMESHDS_SubMesh* tgtSM = tgtMesh->MeshElements( theShape ))
777   {
778     const TopoDS_Vertex& v = ( vExp.ReInit(), TopoDS::Vertex( vExp.Current() ));
779     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, tgtMesh );
780     const SMDS_MeshElement* seg = 0;
781     SMDS_ElemIteratorPtr segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
782     while ( segIt->more() && !seg )
783       if ( !tgtSM->Contains( seg = segIt->next()))
784         seg = 0;
785     int nbPassedSegs = 0;
786     while ( seg )
787     {
788       ++nbPassedSegs;
789       const SMDS_MeshNode* n2 = seg->GetNode(0);
790       n = ( n2 == n ? seg->GetNode(1) : n2 );
791       if ( n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
792         break;
793       const SMDS_MeshElement* seg2 = 0;
794       segIt = n->GetInverseElementIterator(SMDSAbs_Edge);
795       while ( segIt->more() && !seg2 )
796         if ( seg == ( seg2 = segIt->next()))
797           seg2 = 0;
798       seg = seg2;
799     }
800     if (nbPassedSegs > 0 && tgtSM->NbElements() > nbPassedSegs )
801       return error( "Source elements overlap one another");
802
803     isEdgeMeshed = ( tgtSM->NbElements() == nbPassedSegs &&
804                      n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX );
805   }
806   if ( !isEdgeMeshed )
807     return error( "Source elements don't cover totally the geometrical edge" );
808
809   // copy meshes
810   vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
811   for ( unsigned i = 0; i < srcMeshes.size(); ++i )
812     importMesh( srcMeshes[i], theMesh, _sourceHyp, theShape );
813
814   return true;
815 }
816
817 //================================================================================
818 /*!
819  * \brief Copy mesh and groups
820  */
821 //================================================================================
822
823 void StdMeshers_Import_1D::importMesh(const SMESH_Mesh*          srcMesh,
824                                       SMESH_Mesh &               tgtMesh,
825                                       StdMeshers_ImportSource1D* srcHyp,
826                                       const TopoDS_Shape&        tgtShape)
827 {
828   // get submesh to store the imported mesh
829   TNodeNodeMap* n2n;
830   TElemElemMap* e2e;
831   bool toCopyGroups;
832   SMESHDS_SubMesh* tgtSubMesh =
833     getSubmeshForCopiedMesh( srcMesh, &tgtMesh, tgtShape, n2n, e2e, toCopyGroups );
834   if ( !tgtSubMesh || tgtSubMesh->NbNodes() + tgtSubMesh->NbElements() > 0 )
835     return; // not to copy srcMeshDS twice
836
837   SMESHDS_Mesh* tgtMeshDS = tgtMesh.GetMeshDS();
838   SMESH_MeshEditor additor( &tgtMesh );
839
840   // 1. Copy mesh
841
842   vector<const SMDS_MeshNode*> newNodes;
843   const SMESHDS_Mesh* srcMeshDS = srcMesh->GetMeshDS();
844   SMDS_ElemIteratorPtr eIt = srcMeshDS->elementsIterator();
845   while ( eIt->more() )
846   {
847     const SMDS_MeshElement* elem = eIt->next();
848     TElemElemMap::iterator e2eIt = e2e->insert( make_pair( elem, (SMDS_MeshElement*)0 )).first;
849     if ( e2eIt->second ) continue; // already copied by Compute()
850     newNodes.resize( elem->NbNodes() );
851     SMDS_MeshElement::iterator node = elem->begin_nodes();
852     for ( unsigned i = 0; i < newNodes.size(); ++i, ++node )
853     {
854       TNodeNodeMap::iterator n2nIt = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first;
855       if ( !n2nIt->second )
856       {
857         (*n2nIt).second = tgtMeshDS->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z());
858         tgtSubMesh->AddNode( n2nIt->second );
859       }
860       newNodes[i] = n2nIt->second;
861     }
862     const SMDS_MeshElement* newElem =
863       tgtMeshDS->FindElement( newNodes, elem->GetType(), /*noMedium=*/false );
864     if ( !newElem )
865     {
866       newElem = additor.AddElement( newNodes, elem->GetType(), elem->IsPoly());
867       tgtSubMesh->AddElement( newElem );
868     }
869     if ( toCopyGroups )
870       (*e2eIt).second = newElem;
871   }
872   // copy free nodes
873   if ( srcMeshDS->NbNodes() > n2n->size() )
874   {
875     SMDS_NodeIteratorPtr nIt = srcMeshDS->nodesIterator();
876     while( nIt->more() )
877     {
878       const SMDS_MeshNode* node = nIt->next();
879       if ( node->NbInverseElements() == 0 )
880       {
881         const SMDS_MeshNode* newNode = tgtMeshDS->AddNode( node->X(), node->Y(), node->Z());
882         n2n->insert( make_pair( node, newNode ));
883         tgtSubMesh->AddNode( newNode );
884       }
885     }
886   }
887
888   // 2. Copy groups
889
890   vector<SMESH_Group*> resultGroups;
891   if ( toCopyGroups )
892   {
893     // collect names of existing groups to assure uniqueness of group names within a type
894     map< SMDSAbs_ElementType, set<string> > namesByType;
895     SMESH_Mesh::GroupIteratorPtr groupIt = tgtMesh.GetGroups();
896     while ( groupIt->more() )
897     {
898       SMESH_Group* tgtGroup = groupIt->next();
899       namesByType[ tgtGroup->GetGroupDS()->GetType() ].insert( tgtGroup->GetName() );
900     }
901     if (srcMesh)
902     {
903       SMESH_Mesh::GroupIteratorPtr groupIt = srcMesh->GetGroups();
904       while ( groupIt->more() )
905       {
906         SMESH_Group* srcGroup = groupIt->next();
907         SMESHDS_GroupBase* srcGroupDS = srcGroup->GetGroupDS();
908         string name = srcGroup->GetName();
909         int nb = 1;
910         while ( !namesByType[ srcGroupDS->GetType() ].insert( name ).second )
911           name = SMESH_Comment(srcGroup->GetName()) << "_imported_" << nb++;
912         SMESH_Group* newGroup = tgtMesh.AddGroup( srcGroupDS->GetType(), name.c_str(), nb );
913         SMESHDS_Group* newGroupDS = (SMESHDS_Group*)newGroup->GetGroupDS();
914         resultGroups.push_back( newGroup );
915
916         eIt = srcGroupDS->GetElements();
917         if ( srcGroupDS->GetType() == SMDSAbs_Node )
918           while (eIt->more())
919           {
920             TNodeNodeMap::iterator n2nIt = n2n->find((const SMDS_MeshNode*) eIt->next() );
921             if ( n2nIt != n2n->end() && n2nIt->second )
922               newGroupDS->SMDSGroup().Add((*n2nIt).second );
923           }
924         else
925           while (eIt->more())
926           {
927             TElemElemMap::iterator e2eIt = e2e->find( eIt->next() );
928             if ( e2eIt != e2e->end() && e2eIt->second )
929               newGroupDS->SMDSGroup().Add((*e2eIt).second );
930           }
931       }
932     }
933   }
934   n2n->clear();
935   e2e->clear();
936
937   // Remember created groups in order to remove them as soon as the srcHyp is
938   // modified or something other similar happens. This imformation must be persistent,
939   // for that store them in a hypothesis as it stores its values in the file anyway
940   srcHyp->StoreResultGroups( resultGroups, *srcMeshDS, *tgtMeshDS );
941 }
942
943 //=============================================================================
944 /*!
945  * \brief Set needed event listeners and create a submesh for a copied mesh
946  *
947  * This method is called only if a submesh has HYP_OK algo_state.
948  */
949 //=============================================================================
950
951 void StdMeshers_Import_1D::setEventListener(SMESH_subMesh*             subMesh,
952                                             StdMeshers_ImportSource1D* sourceHyp)
953 {
954   if ( sourceHyp )
955   {
956     vector<SMESH_Mesh*> srcMeshes = sourceHyp->GetSourceMeshes();
957     if ( srcMeshes.empty() )
958       _Listener::waitHypModification( subMesh );
959     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
960       // set a listener to remove the imported mesh and groups
961       _Listener::storeImportSubmesh( subMesh, srcMeshes[i], sourceHyp );
962   }
963 }
964 void StdMeshers_Import_1D::SetEventListener(SMESH_subMesh* subMesh)
965 {
966   if ( !_sourceHyp )
967   {
968     const TopoDS_Shape& tgtShape = subMesh->GetSubShape();
969     SMESH_Mesh*         tgtMesh  = subMesh->GetFather();
970     Hypothesis_Status aStatus;
971     CheckHypothesis( *tgtMesh, tgtShape, aStatus );
972   }
973   setEventListener( subMesh, _sourceHyp );
974 }
975
976 void StdMeshers_Import_1D::SubmeshRestored(SMESH_subMesh* subMesh)
977 {
978   SetEventListener(subMesh);
979 }
980
981 //=============================================================================
982 /*!
983  * Predict nb of mesh entities created by Compute()
984  */
985 //=============================================================================
986
987 bool StdMeshers_Import_1D::Evaluate(SMESH_Mesh &         theMesh,
988                                     const TopoDS_Shape & theShape,
989                                     MapShapeNbElems&     aResMap)
990 {
991   if ( !_sourceHyp ) return false;
992
993   const vector<SMESH_Group*>& srcGroups = _sourceHyp->GetGroups();
994   if ( srcGroups.empty() )
995     return error("Invalid source groups");
996
997   vector<int> aVec(SMDSEntity_Last,0);
998
999   bool toCopyMesh, toCopyGroups;
1000   _sourceHyp->GetCopySourceMesh(toCopyMesh, toCopyGroups);
1001   if ( toCopyMesh ) // the whole mesh is copied
1002   {
1003     vector<SMESH_Mesh*> srcMeshes = _sourceHyp->GetSourceMeshes();
1004     for ( unsigned i = 0; i < srcMeshes.size(); ++i )
1005     {
1006       SMESH_subMesh* sm = getSubMeshOfCopiedMesh( theMesh, *srcMeshes[i]);
1007       if ( !sm || aResMap.count( sm )) continue; // already counted
1008       aVec.assign( SMDSEntity_Last, 0);
1009       const SMDS_MeshInfo& aMeshInfo = srcMeshes[i]->GetMeshDS()->GetMeshInfo();
1010       for (int i = 0; i < SMDSEntity_Last; i++)
1011         aVec[i] = aMeshInfo.NbEntities((SMDSAbs_EntityType)i);
1012     }
1013   }
1014   else
1015   {
1016     SMESH_MesherHelper helper(theMesh);
1017
1018     const TopoDS_Edge& geomEdge = TopoDS::Edge( theShape );
1019     const double edgeTol = helper.MaxTolerance( geomEdge );
1020
1021     // take into account nodes on vertices
1022     TopExp_Explorer vExp( theShape, TopAbs_VERTEX );
1023     for ( ; vExp.More(); vExp.Next() )
1024       theMesh.GetSubMesh( vExp.Current())->Evaluate( aResMap );
1025
1026     // count edges imported from groups
1027     int nbEdges = 0, nbQuadEdges = 0;
1028     for ( int iG = 0; iG < srcGroups.size(); ++iG )
1029     {
1030       const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS();
1031       SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
1032       SMDS_MeshNode *tmpNode = helper.AddNode(0,0,0);
1033       while ( srcElems->more() ) // loop on group contents
1034       {
1035         const SMDS_MeshElement* edge = srcElems->next();
1036         // find out if edge is located on geomEdge by projecting
1037         // a middle of edge to geomEdge
1038         SMESH_TNodeXYZ p1( edge->GetNode(0));
1039         SMESH_TNodeXYZ p2( edge->GetNode(1));
1040         gp_XYZ middle = ( p1 + p2 ) / 2.;
1041         tmpNode->setXYZ( middle.X(), middle.Y(), middle.Z());
1042         double u = 0;
1043         if ( helper.CheckNodeU( geomEdge, tmpNode, u, 10 * edgeTol, /*force=*/true ))
1044           ++( edge->IsQuadratic() ? nbQuadEdges : nbEdges);
1045       }
1046       helper.GetMeshDS()->RemoveNode(tmpNode);
1047     }
1048
1049     int nbNodes = nbEdges + 2 * nbQuadEdges - 1;
1050
1051     aVec[SMDSEntity_Node     ] = nbNodes;
1052     aVec[SMDSEntity_Edge     ] = nbEdges;
1053     aVec[SMDSEntity_Quad_Edge] = nbQuadEdges;
1054   }
1055
1056   SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
1057   aResMap.insert(make_pair(sm,aVec));
1058
1059   return true;
1060 }
1061
1062 //================================================================================
1063 /*!
1064  * \brief Return node-node and element-element maps for import of geiven source mesh
1065  */
1066 //================================================================================
1067
1068 void StdMeshers_Import_1D::getMaps(const SMESH_Mesh* srcMesh,
1069                                    SMESH_Mesh*       tgtMesh,
1070                                    TNodeNodeMap*&    n2n,
1071                                    TElemElemMap*&    e2e)
1072 {
1073   _ImportData* iData = _Listener::getImportData(srcMesh,tgtMesh);
1074   n2n = &iData->_n2n;
1075   e2e = &iData->_e2e;
1076   if ( iData->_copyMeshSubM.empty() )
1077   {
1078     // n2n->clear(); -- for sharing nodes on EDGEs
1079     e2e->clear();
1080   }
1081 }
1082
1083 //================================================================================
1084 /*!
1085  * \brief Return submesh corresponding to the copied mesh
1086  */
1087 //================================================================================
1088
1089 SMESH_subMesh* StdMeshers_Import_1D::getSubMeshOfCopiedMesh( SMESH_Mesh& tgtMesh,
1090                                                              SMESH_Mesh& srcMesh )
1091 {
1092   _ImportData* iData = _Listener::getImportData(&srcMesh,&tgtMesh);
1093   if ( iData->_copyMeshSubM.empty() ) return 0;
1094   SMESH_subMesh* sm = tgtMesh.GetSubMeshContaining( iData->_importMeshSubID );
1095   return sm;
1096 }
1097