//  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
//
//  Copyright (C) 2003  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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
//
//
//
//  File   : SMESH_Gen_i.cxx
//  Author : Paul RASCLE, EDF
//  Module : SMESH
//  $Header$

#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_CompSolid.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
#include <TCollection_AsciiString.hxx>

#include "SMESH_Gen_i.hxx"
#include "SMESH_Mesh_i.hxx"
#include "SMESH_LocalLength_i.hxx"
#include "SMESH_NumberOfSegments_i.hxx"
#include "SMESH_MaxElementArea_i.hxx"
#include "SMESH_MaxElementVolume_i.hxx"

#include "SMESHDriver.h"

#include "Utils_CorbaException.hxx"
#include "utilities.h"

#include "SALOMEDS_Tool.hxx"
#include "SALOME_NamingService.hxx"
#include "SALOME_LifeCycleCORBA.hxx"
#include "Utils_SINGLETON.hxx"
#include "OpUtil.hxx"

//#include <TopAbs_ShapeEnum.hxx>

#include "GEOM_Client.hxx"

#include <map>
#include <fstream>
#include <stdio.h>
using namespace std;

#define NUM_TMP_FILES 4

// Tags definition 
long Tag_HypothesisRoot = 1;
long Tag_AlgorithmsRoot = 2;

long Tag_RefOnShape = 1;
long Tag_RefOnAppliedHypothesis = 2;
long Tag_RefOnAppliedAlgorithms = 3;

long Tag_SubMeshOnVertex = 4;
long Tag_SubMeshOnEdge = 5;
long Tag_SubMeshOnFace = 6;
long Tag_SubMeshOnSolid = 7;
long Tag_SubMeshOnCompound = 8;

//=============================================================================
/*!
 *  default constructor: not for use
 */
//=============================================================================

SMESH_Gen_i::SMESH_Gen_i()
{
	MESSAGE("SMESH_Gen_i default constructor");
	// ****
}

//=============================================================================
/*!
 *  Standard constructor, used with Container.
 */
//=============================================================================

SMESH_Gen_i::SMESH_Gen_i(CORBA::ORB_ptr orb,
	PortableServer::POA_ptr poa,
	PortableServer::ObjectId * contId,
	const char *instanceName,
	const char *interfaceName):Engines_Component_i(orb, poa, contId,
	instanceName, interfaceName)
{
	MESSAGE("activate object");
	_thisObj = this;
	_id = _poa->activate_object(_thisObj);

	_ShapeReader = NULL;

}

//=============================================================================
/*!
 *  Standard destructor
 */
//=============================================================================

SMESH_Gen_i::~SMESH_Gen_i()
{
	MESSAGE("~SMESH_Gen_i");
	// ****
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis(const char *anHyp,
	CORBA::Long studyId) throw(SALOME::SALOME_Exception)
{
	MESSAGE("CreateHypothesis");

	// create a new hypothesis object servant

	SMESH_Hypothesis_i *myHypothesis_i = 0;
	try
	{
		myHypothesis_i = _hypothesisFactory_i.Create(anHyp, studyId, &_impl);
	}
	catch(SALOME_Exception & S_ex)
	{
		THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
	}

	// activate the CORBA servant of hypothesis

	SMESH::SMESH_Hypothesis_var hypothesis_i
		= SMESH::SMESH_Hypothesis::_narrow(myHypothesis_i->_this());
	return SMESH::SMESH_Hypothesis::_duplicate(hypothesis_i);
}

/**
 * CORBA implementation of SMESH_Gen::Init. See SMESH_Gen.idl.
 */
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Init(GEOM::GEOM_Gen_ptr geomEngine,
	CORBA::Long studyId,
	GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
{
	return Init(geomEngine, studyId, aShape, -1);
}

/**
 * This is NOT a CORBA implementation. Differ from the Init CORBA method
 * by allowing to specify the ID of the created mesh.
 */
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Init(GEOM::GEOM_Gen_ptr geomEngine,
	CORBA::Long studyId, GEOM::GEOM_Shape_ptr aShape, int meshID)
	throw(SALOME::SALOME_Exception)
{
	MESSAGE("Init");
	// _narrow() duplicates the reference and checks the type
	GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
	GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);

	if (CORBA::is_nil(geom))
		THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
	if (CORBA::is_nil(myShape))
		THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);

	// Get or create the GEOM_Client instance

	SMESH_Mesh_i *meshServant = 0;
	try
	{
		if (!_ShapeReader)
			_ShapeReader = new GEOM_Client();
		ASSERT(_ShapeReader);

		// explore main Shape, get local TopoDS_Shapes of all subShapes
		//  SMESH_topo* myTopo = ExploreMainShape(geom, studyId, myShape);

		// Get studyContext_i, create it if it does'nt exist

		if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
		{
			_mapStudyContext_i[studyId] = new StudyContext_iStruct;
		}
		StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];

		// create a new mesh object
		TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom, myShape);
		SMESH_Mesh * meshImpl=_impl.Init(studyId, myLocShape, meshID);

		// create a new mesh object servant, store it in a map in study context
		meshServant = new SMESH_Mesh_i(this, geom, studyId, meshImpl);
		myStudyContext->mapMesh_i[meshServant->GetId()] = meshServant;
	}
	catch(SALOME_Exception & S_ex)
	{
		THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
	}

	// activate the CORBA servant of Mesh

	SMESH::SMESH_Mesh_var mesh
		= SMESH::SMESH_Mesh::_narrow(meshServant->_this());

	meshServant->SetIor(mesh);

	return SMESH::SMESH_Mesh::_duplicate(mesh);
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

CORBA::Boolean SMESH_Gen_i::IsReadyToCompute(SMESH::SMESH_Mesh_ptr aMesh,
	GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
{
	MESSAGE("SMESH_Gen_i::IsReadyToCompute");
	return true;
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

SMESH::long_array *
	SMESH_Gen_i::GetSubShapesId(GEOM::GEOM_Gen_ptr geomEngine,
	CORBA::Long studyId,
	GEOM::GEOM_Shape_ptr mainShape,
	const SMESH::shape_array & listOfSubShape)throw(SALOME::SALOME_Exception)
{
	MESSAGE("SMESH_Gen_i::GetSubShapesId");
	SMESH::long_array_var shapesId = new SMESH::long_array;
	set < int >setId;

	GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
	GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(mainShape);

	if (CORBA::is_nil(geom))
		THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
	if (CORBA::is_nil(myShape))
		THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);

	try
	{
		if (!_ShapeReader)
			_ShapeReader = new GEOM_Client();
		ASSERT(_ShapeReader);
		TopoDS_Shape myMainShape = _ShapeReader->GetShape(geom, myShape);
		TopTools_IndexedMapOfShape myIndexToShape;
		TopExp::MapShapes(myMainShape, myIndexToShape);

		for (unsigned int i = 0; i < listOfSubShape.length(); i++)
		{
			GEOM::GEOM_Shape_var aShape
				= GEOM::GEOM_Shape::_narrow(listOfSubShape[i]);
			if (CORBA::is_nil(aShape))
				THROW_SALOME_CORBA_EXCEPTION("bad shape reference",
					SALOME::BAD_PARAM);
			TopoDS_Shape locShape = _ShapeReader->GetShape(geom, aShape);
			for (TopExp_Explorer exp(locShape, TopAbs_FACE); exp.More();
				exp.Next())
			{
				const TopoDS_Face & F = TopoDS::Face(exp.Current());
				setId.insert(myIndexToShape.FindIndex(F));
				SCRUTE(myIndexToShape.FindIndex(F));
			}
			for (TopExp_Explorer exp(locShape, TopAbs_EDGE); exp.More();
				exp.Next())
			{
				const TopoDS_Edge & E = TopoDS::Edge(exp.Current());
				setId.insert(myIndexToShape.FindIndex(E));
				SCRUTE(myIndexToShape.FindIndex(E));
			}
			for (TopExp_Explorer exp(locShape, TopAbs_VERTEX); exp.More();
				exp.Next())
			{
				const TopoDS_Vertex & V = TopoDS::Vertex(exp.Current());
				setId.insert(myIndexToShape.FindIndex(V));
				SCRUTE(myIndexToShape.FindIndex(V));
			}
		}
		shapesId->length(setId.size());
		set < int >::iterator iind;
		int i = 0;
		for (iind = setId.begin(); iind != setId.end(); iind++)
		{
			SCRUTE((*iind));
			shapesId[i] = (*iind);
			SCRUTE(shapesId[i]);
			i++;
		}
	}
	catch(SALOME_Exception & S_ex)
	{
		THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
	}

	return shapesId._retn();
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

CORBA::Boolean SMESH_Gen_i::Compute(SMESH::SMESH_Mesh_ptr aMesh,
	GEOM::GEOM_Shape_ptr aShape) throw(SALOME::SALOME_Exception)
{
	MESSAGE("SMESH_Gen_i::Compute");
	GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);
	if (CORBA::is_nil(myShape))
		THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);

	SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow(aMesh);
	if (CORBA::is_nil(myMesh))
		THROW_SALOME_CORBA_EXCEPTION("bad Mesh reference", SALOME::BAD_PARAM);

	bool ret = false;
	try
	{

		// get study context from studyId given by CORBA mesh object

		int studyId = myMesh->GetStudyId();
		ASSERT(_mapStudyContext_i.find(studyId) != _mapStudyContext_i.end());
		StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];

		// get local Mesh_i object with Id and study context 

		int meshId = myMesh->GetId();
		ASSERT(myStudyContext->mapMesh_i.find(meshId) !=
			myStudyContext->mapMesh_i.end());
		SMESH_Mesh_i *meshServant = myStudyContext->mapMesh_i[meshId];
		ASSERT(meshServant);

		// get local TopoDS_Shape

		GEOM::GEOM_Gen_var geom = meshServant->GetGeomEngine();
		TopoDS_Shape myLocShape = _ShapeReader->GetShape(geom, myShape);

		// implementation compute

		::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
		ret = _impl.Compute(myLocMesh, myLocShape);
	}
	catch(SALOME_Exception & S_ex)
	{
		MESSAGE("catch exception " << S_ex.what());
		return false;
//       THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
	}

	return ret;
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

SALOMEDS::TMPFile * SMESH_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
	const char *theURL, bool isMultiFile)
{
	MESSAGE("SMESH_Gen_i::SAVE");
	SALOMEDS::Study_var Study = theComponent->GetStudy();
	int studyId;

	// Declare a byte stream
	SALOMEDS::TMPFile_var aStreamFile;

	// Obtain a temporary dir
	TCollection_AsciiString tmpDir =
		(isMultiFile) ? TCollection_AsciiString((char *)theURL) :
		SALOMEDS_Tool::GetTmpDir();

	// Create a sequence of files processed
	SALOMEDS::ListOfFileNames_var aFileSeq = new SALOMEDS::ListOfFileNames;
	aFileSeq->length(NUM_TMP_FILES);

	TCollection_AsciiString aStudyName("");

	if (isMultiFile)
		aStudyName =
			(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));

	// Set names of temporary files
	TCollection_AsciiString filename =
		aStudyName + TCollection_AsciiString("_SMESH.hdf");
	TCollection_AsciiString hypofile =
		aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
	TCollection_AsciiString algofile =
		aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
	TCollection_AsciiString meshfile =
		aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");
	aFileSeq[0] = CORBA::string_dup(filename.ToCString());
	aFileSeq[1] = CORBA::string_dup(hypofile.ToCString());
	aFileSeq[2] = CORBA::string_dup(algofile.ToCString());
	aFileSeq[3] = CORBA::string_dup(meshfile.ToCString());
	filename = tmpDir + filename;
	hypofile = tmpDir + hypofile;
	algofile = tmpDir + algofile;
	meshfile = tmpDir + meshfile;

	HDFfile *hdf_file;
	map < int, HDFgroup * >hdf_group, hdf_subgroup;
	map < int, HDFdataset * >hdf_dataset;
	FILE *destFile;

	SALOMEDS::ChildIterator_var itBig, it, itSM;
	SALOMEDS::SObject_var mySObject, myBranch, mySObjectChild;
	hdf_size size[1];
	int longueur, cmpt_ds = 0, cmpt_it;
	char *name_group, name_dataset[30], name_meshgroup[30];
	bool ok, _found;
	int cmpt_sm = 0, myTag;

//************* HDF file creation
	hdf_file = new HDFfile(filename.ToCString());
	hdf_file->CreateOnDisk();
//****************************

	itBig = Study->NewChildIterator(theComponent);
	SCRUTE(Tag_HypothesisRoot);
	SCRUTE(Tag_AlgorithmsRoot);
	for (; itBig->More(); itBig->Next())
	{
		SALOMEDS::SObject_var gotBranch = itBig->Value();
		SCRUTE(gotBranch->Name());
		SCRUTE(gotBranch->Tag());
		SCRUTE(gotBranch->GetID());

//************branch 1 : hypothesis
		if (gotBranch->Tag() == Tag_HypothesisRoot)
		{						//hypothesis = tag 1
			double length, maxElementsArea, maxElementsVolume;
			int numberOfSegments;

			destFile = fopen(hypofile.ToCString(), "w");
			it = Study->NewChildIterator(gotBranch);
			for (; it->More(); it->Next())
			{
				mySObject = it->Value();
				SALOMEDS::GenericAttribute_var anAttr;
				SALOMEDS::AttributeIOR_var anIOR;
				if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
				{
					anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);

					SMESH::SMESH_Hypothesis_var myHyp =
						SMESH::SMESH_Hypothesis::_narrow(_orb->
						string_to_object(anIOR->Value()));
					SCRUTE(myHyp->GetName());
					fprintf(destFile, "%li\n", myHyp->GetId());
					fprintf(destFile, "%s\n", myHyp->GetName());
					if (strcmp(myHyp->GetName(), "LocalLength") == 0)
					{
						SMESH::SMESH_LocalLength_var LL =
							SMESH::SMESH_LocalLength::_narrow(myHyp);
						length = LL->GetLength();
						fprintf(destFile, "%f\n", length);
					}
					else if (strcmp(myHyp->GetName(), "NumberOfSegments") == 0)
					{
						SMESH::SMESH_NumberOfSegments_var NOS =
							SMESH::SMESH_NumberOfSegments::_narrow(myHyp);
						numberOfSegments = NOS->GetNumberOfSegments();
						fprintf(destFile, "%d\n", numberOfSegments);
					}
					else if (strcmp(myHyp->GetName(), "MaxElementArea") == 0)
					{
						SMESH::SMESH_MaxElementArea_var MEA =
							SMESH::SMESH_MaxElementArea::_narrow(myHyp);
						maxElementsArea = MEA->GetMaxElementArea();
						fprintf(destFile, "%f\n", maxElementsArea);
					}
					else if (strcmp(myHyp->GetName(), "MaxElementVolume") == 0)
					{
						SMESH::SMESH_MaxElementVolume_var MEV =
							SMESH::SMESH_MaxElementVolume::_narrow(myHyp);
						maxElementsVolume = MEV->GetMaxElementVolume();
						fprintf(destFile, "%f\n", maxElementsVolume);
					}
				}
			}
			fclose(destFile);

//writes the file name in the hdf file
			longueur = hypofile.Length() + 1;
			name_group = "Hypothesis";
			//SCRUTE(name_group);

			size[0] = longueur;
			hdf_group[1] = new HDFgroup(name_group, hdf_file);
			hdf_group[1]->CreateOnDisk();

			hdf_dataset[cmpt_ds] =
				new HDFdataset(name_group, hdf_group[1], HDF_STRING, size, 1);
			hdf_dataset[cmpt_ds]->CreateOnDisk();
			hdf_dataset[cmpt_ds]->WriteOnDisk(hypofile.ToCString());
			hdf_dataset[cmpt_ds]->CloseOnDisk();
			cmpt_ds++;

			hdf_group[1]->CloseOnDisk();
			MESSAGE("End of Hypothesis Save");

		}
//************branch 2 : algorithms
		else if (gotBranch->Tag() == Tag_AlgorithmsRoot)
		{						//algos = tag 2
			destFile = fopen(algofile.ToCString(), "w");
			it = Study->NewChildIterator(gotBranch);
			for (; it->More(); it->Next())
			{
				mySObject = it->Value();
				SALOMEDS::GenericAttribute_var anAttr;
				SALOMEDS::AttributeIOR_var anIOR;
				if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
				{
					anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
					SMESH::SMESH_Algo_var myAlgo =
						SMESH::SMESH_Algo::_narrow(_orb->
						string_to_object(anIOR->Value()));
					SCRUTE(anIOR->Value());
					SCRUTE(myAlgo->_is_nil());
					fprintf(destFile, "%li\n", myAlgo->GetId());
					fprintf(destFile, "%s\n", myAlgo->GetName());
				}
			}

			fclose(destFile);

//writes the file name in the hdf file
			longueur = algofile.Length() + 1;
			name_group = "Algorithms";
			//SCRUTE(name_group);

			size[0] = longueur;
			hdf_group[2] = new HDFgroup(name_group, hdf_file);
			hdf_group[2]->CreateOnDisk();

			hdf_dataset[cmpt_ds] =
				new HDFdataset(name_group, hdf_group[2], HDF_STRING, size, 1);
			hdf_dataset[cmpt_ds]->CreateOnDisk();
			hdf_dataset[cmpt_ds]->WriteOnDisk(algofile.ToCString());
			hdf_dataset[cmpt_ds]->CloseOnDisk();
			cmpt_ds++;

			hdf_group[2]->CloseOnDisk();
			MESSAGE("End of Algos Save");

		}
//************branch 3 : meshes
		else if (gotBranch->Tag() >= 3)
		{						//meshes = tag > 3

			SALOMEDS::GenericAttribute_var anAttr;
			SALOMEDS::AttributeIOR_var anIOR;
			if (gotBranch->FindAttribute(anAttr, "AttributeIOR"))
			{
				anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);

				SMESH::SMESH_Mesh_var myMesh =
					SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(anIOR->
						Value()));
				studyId = myMesh->GetStudyId();
				SCRUTE(studyId);

				StudyContext_iStruct *myStudyContext =
					_mapStudyContext_i[studyId];
				int meshId = myMesh->GetId();
				SMESH_Mesh_i *meshServant = myStudyContext->mapMesh_i[meshId];
				::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
				SMESHDS_Mesh *mySMESHDSMesh = myLocMesh.GetMeshDS();

				SCRUTE(mySMESHDSMesh->NbNodes());
				if (mySMESHDSMesh->NbNodes() > 0)
				{
					//checks if the mesh is not empty   
					Mesh_Writer *myWriter = SMESHDriver::GetMeshWriter("MED");
					myWriter->SetFile(meshfile.ToCString());
					myWriter->SetMesh(mySMESHDSMesh);
					myWriter->SetMeshId(gotBranch->Tag());
					myWriter->Add();
				}
				else
					meshfile = "No data";

				//********** opening of the HDF group
				sprintf(name_meshgroup, "Mesh %d", meshId);
				SCRUTE(name_meshgroup);
				hdf_group[gotBranch->Tag()] =
					new HDFgroup(name_meshgroup, hdf_file);
				hdf_group[gotBranch->Tag()]->CreateOnDisk();
				//********** 

				//********** file where the data are stored
				longueur = strlen(meshfile.ToCString()) + 1;
				size[0] = longueur;
				strcpy(name_dataset, "Mesh data");
				hdf_dataset[cmpt_ds] =
					new HDFdataset(name_dataset, hdf_group[gotBranch->Tag()],
					HDF_STRING, size, 1);
				hdf_dataset[cmpt_ds]->CreateOnDisk();
				hdf_dataset[cmpt_ds]->WriteOnDisk(meshfile.ToCString());
				hdf_dataset[cmpt_ds]->CloseOnDisk();
				cmpt_ds++;
				//********** 

				//********** ref on shape
				Standard_CString myRefOnObject = "";
				SALOMEDS::SObject_var myRef, myShape;
				_found = gotBranch->FindSubObject(Tag_RefOnShape, myRef);
				if (_found)
				{
					ok = myRef->ReferencedObject(myShape);
					myRefOnObject = myShape->GetID();
					SCRUTE(myRefOnObject);

					longueur = strlen(myRefOnObject) + 1;
					if (longueur > 1)
					{
						size[0] = longueur;
						strcpy(name_dataset, "Ref on shape");
						hdf_dataset[cmpt_ds] =
							new HDFdataset(name_dataset,
							hdf_group[gotBranch->Tag()], HDF_STRING, size, 1);
						hdf_dataset[cmpt_ds]->CreateOnDisk();
						hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
						hdf_dataset[cmpt_ds]->CloseOnDisk();
						cmpt_ds++;

					}
				}
				//********** 

				//********** ref on applied hypothesis
				_found =
					gotBranch->FindSubObject(Tag_RefOnAppliedHypothesis,
					myBranch);
				if (_found)
				{

					strcpy(name_meshgroup, "Applied Hypothesis");
					hdf_subgroup[Tag_RefOnAppliedHypothesis] =
						new HDFgroup(name_meshgroup,
						hdf_group[gotBranch->Tag()]);
					hdf_subgroup[Tag_RefOnAppliedHypothesis]->CreateOnDisk();

					it = Study->NewChildIterator(myBranch);
					cmpt_it = 0;
					for (; it->More(); it->Next())
					{
						mySObject = it->Value();
						ok = mySObject->ReferencedObject(myRef);
						myRefOnObject = myRef->GetID();

						longueur = strlen(myRefOnObject) + 1;
						if (longueur > 1)
						{
							size[0] = longueur;
							sprintf(name_dataset, "Hyp %d", cmpt_it);
							hdf_dataset[cmpt_ds] =
								new HDFdataset(name_dataset,
								hdf_subgroup[Tag_RefOnAppliedHypothesis],
								HDF_STRING, size, 1);
							hdf_dataset[cmpt_ds]->CreateOnDisk();
							hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
							hdf_dataset[cmpt_ds]->CloseOnDisk();
						}
						cmpt_ds++;
						cmpt_it++;
					}
					hdf_subgroup[Tag_RefOnAppliedHypothesis]->CloseOnDisk();
				}
				//********** 

				//********** ref on applied algorithms
				_found =
					gotBranch->FindSubObject(Tag_RefOnAppliedAlgorithms,
					myBranch);
				if (_found)
				{

					strcpy(name_meshgroup, "Applied Algorithms");
					hdf_subgroup[Tag_RefOnAppliedAlgorithms] =
						new HDFgroup(name_meshgroup,
						hdf_group[gotBranch->Tag()]);
					hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CreateOnDisk();

					it = Study->NewChildIterator(myBranch);
					cmpt_it = 0;
					for (; it->More(); it->Next())
					{
						mySObject = it->Value();
						ok = mySObject->ReferencedObject(myRef);
						myRefOnObject = myRef->GetID();

						longueur = strlen(myRefOnObject) + 1;
						if (longueur > 1)
						{
							size[0] = longueur;
							sprintf(name_dataset, "Algo %d", cmpt_it);
							hdf_dataset[cmpt_ds] =
								new HDFdataset(name_dataset,
								hdf_subgroup[Tag_RefOnAppliedAlgorithms],
								HDF_STRING, size, 1);
							hdf_dataset[cmpt_ds]->CreateOnDisk();
							hdf_dataset[cmpt_ds]->WriteOnDisk(myRefOnObject);
							hdf_dataset[cmpt_ds]->CloseOnDisk();
						}
						cmpt_ds++;
						cmpt_it++;
					}
					hdf_subgroup[Tag_RefOnAppliedAlgorithms]->CloseOnDisk();
				}
				MESSAGE("end of algo applied");
				//********** 

				//********** submeshes on subshapes
				int myLevel1Tag;
				for (int i = Tag_SubMeshOnVertex; i <= Tag_SubMeshOnCompound;
					i++)
				{
					_found = gotBranch->FindSubObject(i, myBranch);
					if (_found)
					{
						if (i == Tag_SubMeshOnVertex)
							strcpy(name_meshgroup, "SubMeshes On Vertex");
						else if (i == Tag_SubMeshOnEdge)
							strcpy(name_meshgroup, "SubMeshes On Edge");
						else if (i == Tag_SubMeshOnFace)
							strcpy(name_meshgroup, "SubMeshes On Face");
						else if (i == Tag_SubMeshOnSolid)
							strcpy(name_meshgroup, "SubMeshes On Solid");
						else if (i == Tag_SubMeshOnCompound)
							strcpy(name_meshgroup, "SubMeshes On Compound");

						cmpt_sm++;
						myLevel1Tag = 10 + cmpt_sm;
						hdf_subgroup[myLevel1Tag] =
							new HDFgroup(name_meshgroup,
							hdf_group[gotBranch->Tag()]);
						hdf_subgroup[myLevel1Tag]->CreateOnDisk();

						itSM = Study->NewChildIterator(myBranch);
						for (; itSM->More(); itSM->Next())
						{		//Loop on all submeshes
							mySObject = itSM->Value();
							cmpt_sm++;
							myTag = 10 + cmpt_sm;
							mySObject->FindAttribute(anAttr, "AttributeIOR");
							anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
							SMESH::SMESH_subMesh_var mySubMesh =
								SMESH::SMESH_subMesh::_narrow(_orb->
								string_to_object(anIOR->Value()));

							//sprintf(name_meshgroup,"SubMesh %d",myTag);
							sprintf(name_meshgroup, "SubMesh %ld",
								mySubMesh->GetId());
							SCRUTE(name_meshgroup);

							hdf_subgroup[myTag] =
								new HDFgroup(name_meshgroup,
								hdf_subgroup[myLevel1Tag]);
							hdf_subgroup[myTag]->CreateOnDisk();

							//********** ref on shape
							Standard_CString myRefOnObject = "";
							SALOMEDS::SObject_var myRef, myShape;
							bool _found2;
							_found2 =
								mySObject->FindSubObject(Tag_RefOnShape, myRef);
							if (_found2)
							{
								ok = myRef->ReferencedObject(myShape);
								myRefOnObject = myShape->GetID();
								SCRUTE(myRefOnObject);

								longueur = strlen(myRefOnObject) + 1;
								if (longueur > 1)
								{
									size[0] = longueur;
									strcpy(name_dataset, "Ref on shape");
									hdf_dataset[cmpt_ds] =
										new HDFdataset(name_dataset,
										hdf_subgroup[myTag], HDF_STRING, size,
										1);
									hdf_dataset[cmpt_ds]->CreateOnDisk();
									hdf_dataset[cmpt_ds]->
										WriteOnDisk(myRefOnObject);
									hdf_dataset[cmpt_ds]->CloseOnDisk();
									cmpt_ds++;
								}
							}
							//********** 

							//********** ref on applied hypothesis
							_found2 =
								mySObject->
								FindSubObject(Tag_RefOnAppliedHypothesis,
								myBranch);
							if (_found2)
							{

								strcpy(name_meshgroup, "Applied Hypothesis");
								cmpt_sm++;
								hdf_subgroup[10 + cmpt_sm] =
									new HDFgroup(name_meshgroup,
									hdf_subgroup[myTag]);
								hdf_subgroup[10 + cmpt_sm]->CreateOnDisk();

								it = Study->NewChildIterator(myBranch);
								cmpt_it = 0;
								for (; it->More(); it->Next())
								{
									mySObjectChild = it->Value();
									ok = mySObjectChild->
										ReferencedObject(myRef);
									myRefOnObject = myRef->GetID();

									longueur = strlen(myRefOnObject) + 1;
									if (longueur > 1)
									{
										size[0] = longueur;
										sprintf(name_dataset, "Hyp %d",
											cmpt_it);
										SCRUTE(cmpt_it);
										hdf_dataset[cmpt_ds] =
											new HDFdataset(name_dataset,
											hdf_subgroup[10 + cmpt_sm],
											HDF_STRING, size, 1);
										hdf_dataset[cmpt_ds]->CreateOnDisk();
										hdf_dataset[cmpt_ds]->
											WriteOnDisk(myRefOnObject);
										hdf_dataset[cmpt_ds]->CloseOnDisk();
									}
									cmpt_ds++;
									cmpt_it++;
								}
								hdf_subgroup[10 + cmpt_sm]->CloseOnDisk();
							}
							//********** 

							//********** ref on applied algorithms
							_found2 =
								mySObject->
								FindSubObject(Tag_RefOnAppliedAlgorithms,
								myBranch);
							SCRUTE(_found2);
							if (_found2)
							{

								strcpy(name_meshgroup, "Applied Algorithms");
								cmpt_sm++;
								hdf_subgroup[10 + cmpt_sm] =
									new HDFgroup(name_meshgroup,
									hdf_subgroup[myTag]);
								hdf_subgroup[10 + cmpt_sm]->CreateOnDisk();

								it = Study->NewChildIterator(myBranch);
								cmpt_it = 0;
								for (; it->More(); it->Next())
								{
									mySObjectChild = it->Value();
									ok = mySObjectChild->
										ReferencedObject(myRef);
									myRefOnObject = myRef->GetID();

									longueur = strlen(myRefOnObject) + 1;
									if (longueur > 1)
									{
										size[0] = longueur;
										sprintf(name_dataset, "Algo %d",
											cmpt_it);
										hdf_dataset[cmpt_ds] =
											new HDFdataset(name_dataset,
											hdf_subgroup[10 + cmpt_sm],
											HDF_STRING, size, 1);
										hdf_dataset[cmpt_ds]->CreateOnDisk();
										hdf_dataset[cmpt_ds]->
											WriteOnDisk(myRefOnObject);
										hdf_dataset[cmpt_ds]->CloseOnDisk();
									}
									cmpt_ds++;
									cmpt_it++;
								}
								hdf_subgroup[10 + cmpt_sm]->CloseOnDisk();
							}
							//MESSAGE("end of algo applied");
							//********** 

							hdf_subgroup[myTag]->CloseOnDisk();
						}

						hdf_subgroup[myLevel1Tag]->CloseOnDisk();
					}

				}
				//********** 

				//********** closing of the HDF group
				hdf_group[gotBranch->Tag()]->CloseOnDisk();
				MESSAGE("End of Mesh Save");
				//********** 
			}
		}
		MESSAGE("End of Meshes Save");
	}

	MESSAGE("hdf_file->CloseOnDisk()");
	hdf_file->CloseOnDisk();

	MESSAGE("delete hdf_file");
	delete hdf_file;
	hdf_file = 0;

	// Convert temporary files to stream
	MESSAGE("Convert temporary files to stream");
	aStreamFile =
		SALOMEDS_Tool::PutFilesToStream(tmpDir.ToCString(), aFileSeq.in(),
		isMultiFile);

	// Remove temporary files and directory
	MESSAGE("Remove temporary files and directory");
	if (!isMultiFile)
		SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(),
			true);

	MESSAGE("End SMESH_Gen_i::Save");

	return aStreamFile._retn();
}

SALOMEDS::TMPFile *
	SMESH_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
	const char *theURL, bool isMultiFile)
{
	SALOMEDS::TMPFile_var aStreamFile = Save(theComponent, theURL, isMultiFile);
	return aStreamFile._retn();
}

void SMESH_Gen_i::loadHypothesis(char * name, HDFfile * hdf_file,
	char * hypofile, int studyId)
{
	char name_of_group[HDF_NAME_MAX_LEN + 1];
	char objectId[10];

	HDFgroup * hdfGroup = new HDFgroup(name, hdf_file);
	hdfGroup->OpenOnDisk();

	hdfGroup->InternalObjectIndentify(0, name_of_group);
	HDFdataset * dataset = new HDFdataset(name_of_group, hdfGroup);
	dataset->OpenOnDisk();
	char *name_of_file = new char[dataset->GetSize()];
	dataset->ReadFromDisk(name_of_file);
	SCRUTE(name_of_file);
	dataset->CloseOnDisk();
	hdfGroup->CloseOnDisk();
	delete[]name_of_file;
	
	ifstream loadedFile(hypofile);
	while (!loadedFile.eof())
	{
		int hypothesisID;
		string hypothesisName;
		loadedFile >> hypothesisID;
		loadedFile >> hypothesisName;
		if(hypothesisName.length()==0) break;
		SMESH_Hypothesis_i * corbaHyp =
			_hypothesisFactory_i.Create(hypothesisName.c_str(), studyId, &_impl);
		SMESH_Hypothesis * localHyp = corbaHyp->getImpl();
		localHyp->SetID(hypothesisID);
		localHyp->LoadFrom(loadedFile);
		
		SMESH::SMESH_Hypothesis_var varHyp = corbaHyp->_this();
		string iorString = _orb->object_to_string(varHyp);
		sprintf(objectId, "%ld", varHyp->GetId());
		_SMESHCorbaObj[string("Hypo_") + string(objectId)] =
			iorString;
	}
	MESSAGE("End of Hypos Load");
}

void SMESH_Gen_i::loadAlgorithms(char * name, HDFfile * hdf_file,
	char* algofile, int studyId)
{
	char name_of_group[HDF_NAME_MAX_LEN + 1];
	char objectId[10];
	HDFgroup * hdfGroup = new HDFgroup(name, hdf_file);
	hdfGroup->OpenOnDisk();

	hdfGroup->InternalObjectIndentify(0, name_of_group);
	HDFdataset * dataset =
		new HDFdataset(name_of_group, hdfGroup);
	dataset->OpenOnDisk();

	char *name_of_file = new char[dataset->GetSize()];
	dataset->ReadFromDisk(name_of_file);
	dataset->CloseOnDisk();
	hdfGroup->CloseOnDisk();	
	delete[]name_of_file;

	char * aLine = new char[100];
	FILE * loadedFile = fopen(algofile, "r");
	while (!feof(loadedFile))
	{
		int hypothesisID;
		fscanf(loadedFile, "%i", &hypothesisID);
		fscanf(loadedFile, "%s\n", aLine);
		//SCRUTE(aLine);
		if (strcmp(aLine, "") != 0)
		{
			SMESH_Hypothesis_i * corbaHyp =
				_hypothesisFactory_i.Create(aLine, studyId, &_impl);
			SMESH_Hypothesis * localHyp = corbaHyp->getImpl();
			localHyp->SetID(hypothesisID);
			
			SMESH::SMESH_Hypothesis_var myHyp = corbaHyp->_this();
			
			SMESH::SMESH_Algo_var myAlgo =
				SMESH::SMESH_Algo::_narrow(myHyp);
			string iorString = _orb->object_to_string(myAlgo);
			sprintf(objectId, "%ld", myAlgo->GetId());
			_SMESHCorbaObj[string("Hypo_") + string(objectId)] =
				iorString;
		}
	}
	fclose(loadedFile);
	delete[]aLine;
	aLine = 0;
	MESSAGE("End of Algos Load");
}

/**
 * @param hdfGroupMeshId The group where to read the hypothesis
 * @param _found ???
 * @param Study The study where to create the hypothesis
 * @param myNewMesh The mesh on which the hypothesis is applied
 * @param aShape The shape with which this mesh is linked
 */
void SMESH_Gen_i::loadAppliedHypothesis(HDFgroup * hdfGroupMeshId, 
	bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
	GEOM::GEOM_Shape_var aShape)
{
	HDFgroup * hdf_subgroup = new HDFgroup("Applied Hypothesis", hdfGroupMeshId);
	hdf_subgroup->OpenOnDisk();
	int nb_datasets = hdf_subgroup->nInternalObjects();
	char name_dataset[10];
	
	for (int j = 0; j < nb_datasets; j++)
	{
		sprintf(name_dataset, "Hyp %d", j);
		HDFdataset * hdf_dataset = new HDFdataset(name_dataset, hdf_subgroup);
		hdf_dataset->OpenOnDisk();

		char *refFromFile = new char[hdf_dataset->GetSize()];
		hdf_dataset->ReadFromDisk(refFromFile);
		hdf_dataset->CloseOnDisk();
		delete hdf_dataset;

		if (_found)
		{
			SALOMEDS::SObject_var HypSO =
				Study->FindObjectID(refFromFile);
			if (!CORBA::is_nil(HypSO))
			{
				SALOMEDS::GenericAttribute_var anAttr;
				HypSO->FindAttribute(anAttr, "AttributeIOR");
				SALOMEDS::AttributeIOR_var anIOR =
					SALOMEDS::AttributeIOR::_narrow(anAttr);
				if (!CORBA::is_nil(anIOR))
				{
					char *HypIOR = anIOR->Value();
					SMESH::SMESH_Hypothesis_var anHyp =
						SMESH::SMESH_Hypothesis::_narrow(_orb->
						string_to_object(HypIOR));
					if (!CORBA::is_nil(anHyp))
					{
						myNewMesh->AddHypothesis(aShape, anHyp);
						MESSAGE("Hypothesis added ...");
					}
				}
			}
		}
	}
	hdf_subgroup->CloseOnDisk();
}

/**
 * @param hdfGroupMeshId The group where to read the hypothesis
 * @param _found ???
 * @param Study The study where to create the hypothesis
 * @param myNewMesh The mesh on which the hypothesis is applied
 * @param aShape The shape with which this mesh is linked
 */
void SMESH_Gen_i::loadAppliedAlgorithms(HDFgroup * hdfGroupMeshId, 
	bool _found, SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh, 
	GEOM::GEOM_Shape_var aShape)
{
	HDFgroup * hdf_subgroup = new HDFgroup("Applied Algorithms", hdfGroupMeshId);
	hdf_subgroup->OpenOnDisk();

	int nb_datasets = hdf_subgroup->nInternalObjects();
	SCRUTE(nb_datasets);
	char name_dataset[10];
	
	for (int j = 0; j < nb_datasets; j++)
	{
		sprintf(name_dataset, "Algo %d", j);
		HDFdataset * dataset =
			new HDFdataset(name_dataset, hdf_subgroup);
		dataset->OpenOnDisk();

		char *refFromFile = new char[dataset->GetSize()];
		dataset->ReadFromDisk(refFromFile);
		dataset->CloseOnDisk();

		if (_found)
		{
			SALOMEDS::SObject_var AlgoSO =
				Study->FindObjectID(refFromFile);
			if (!CORBA::is_nil(AlgoSO))
			{
				SALOMEDS::GenericAttribute_var anAttr;
				AlgoSO->FindAttribute(anAttr, "AttributeIOR");
				SALOMEDS::AttributeIOR_var anIOR =
					SALOMEDS::AttributeIOR::_narrow(anAttr);
				if (!CORBA::is_nil(anIOR))
				{
					char *AlgoIOR = anIOR->Value();
					//SCRUTE(AlgoIOR);
					SMESH::SMESH_Hypothesis_var myHyp =
						SMESH::SMESH_Hypothesis::_narrow(_orb->
						string_to_object(AlgoIOR));
					SMESH::SMESH_Algo_var anAlgo =
						SMESH::SMESH_Algo::_narrow(myHyp);
											
					if (!CORBA::is_nil(anAlgo))
					{
						myNewMesh->AddHypothesis(aShape, anAlgo);	//essayer avec _SMESHCorbaObj
						MESSAGE("Algorithms added ...");
					}
				}
			}
		}
	}
	hdf_subgroup->CloseOnDisk();
}

/**
 * @param hdfGroupMeshId The group where to read the hypothesis
 * @param msgname ???
 * @param Study The study where to create the hypothesis
 * @param myNewMesh The mesh on which the hypothesis is applied
 */
void SMESH_Gen_i::loadSubMeshes(HDFgroup * hdfGroupMeshId, char * msgname,
	SALOMEDS::Study_var Study, SMESH::SMESH_Mesh_var myNewMesh)
{
	MESSAGE("SMESH_Gen_i::loadSubMeshes");
	HDFgroup * hdf_subgroupmyLevel1Tag = new HDFgroup(msgname, hdfGroupMeshId);
	hdf_subgroupmyLevel1Tag->OpenOnDisk();

	int nb_submeshes = hdf_subgroupmyLevel1Tag->nInternalObjects();
	char name_meshgroup[30];
	//SCRUTE(nb_submeshes);

	for (int j = 0; j < nb_submeshes; j++)
	{
		//cmpt_sm++;
		//myTag = 10 + cmpt_sm;
		hdf_subgroupmyLevel1Tag->InternalObjectIndentify(j, name_meshgroup);				

		HDFgroup * hdf_subgroupmyTag = new HDFgroup(name_meshgroup, 
			hdf_subgroupmyLevel1Tag);
		hdf_subgroupmyTag->OpenOnDisk();
		int subMeshId = atoi((string(name_meshgroup).substr(8, 18)).c_str());

		MESSAGE("Ref on shape");
		//********** ref on shape		
		HDFdataset * hdf_dataset =
			new HDFdataset("Ref on shape", hdf_subgroupmyTag);
		hdf_dataset->OpenOnDisk();

		char *refFromFile = new char[hdf_dataset->GetSize()];
		hdf_dataset->ReadFromDisk(refFromFile);
		hdf_dataset->CloseOnDisk();

		bool _found3 = false;
		SALOMEDS::SObject_var GSO = Study->FindObjectID(refFromFile);
		SMESH::SMESH_subMesh_var aSubMesh;
		GEOM::GEOM_Shape_var aSubShape;

		if (!CORBA::is_nil(GSO))
		{
			SALOMEDS::GenericAttribute_var anAttr;
			GSO->FindAttribute(anAttr, "AttributeIOR");
			SALOMEDS::AttributeIOR_var anIOR = 
				SALOMEDS::AttributeIOR::_narrow(anAttr);
				
			char *SubShapeIOR = anIOR->Value();
			aSubShape =
				GEOM::GEOM_Shape::_narrow(_orb-> string_to_object(SubShapeIOR));

			if (!CORBA::is_nil(aSubShape))
			{
				aSubMesh = myNewMesh->GetElementsOnShape(aSubShape);
				string iorString = _orb->object_to_string(aSubMesh);
				char objectId[10];
				sprintf(objectId, "%d", subMeshId);
				_SMESHCorbaObj[string("SubMesh_") + string(objectId)] =
					 iorString;
				_found3 = true;
			}
		}

		int nb_subgroup = hdf_subgroupmyTag->nInternalObjects();
		SCRUTE(nb_subgroup);
		char sgname[HDF_NAME_MAX_LEN + 1];
		for (int k = 0; k < nb_subgroup; k++)
		{
			hdf_subgroupmyTag->InternalObjectIndentify(k, sgname);
			if (strcmp(sgname, "Ref on shape") == 0)
			{
				//nothing
			}
			else if (strcmp(sgname, "Applied Hypothesis") == 0)
			{
				//********** ref on applied hypothesis
				MESSAGE("Applied Hypothesis");
				strcpy(name_meshgroup, "Applied Hypothesis");
				//cmpt_sm++;
				HDFgroup * hdf_subgroup10cmpt_sm = new HDFgroup(name_meshgroup,
					hdf_subgroupmyTag);
					
				hdf_subgroup10cmpt_sm->OpenOnDisk();
				int nb_datasets = hdf_subgroup10cmpt_sm->nInternalObjects();
				// SCRUTE(nb_datasets);

				char name_dataset[30];
				for (int l = 0; l < nb_datasets; l++)
				{
					sprintf(name_dataset, "Hyp %d", l);
					HDFdataset * hdf_datasetcmpt_ds =
						new HDFdataset(name_dataset, hdf_subgroup10cmpt_sm);
					hdf_datasetcmpt_ds->OpenOnDisk();
					int size = hdf_datasetcmpt_ds->GetSize();

					char *refFromFile = new char[size];
					hdf_datasetcmpt_ds->ReadFromDisk(refFromFile);
					hdf_datasetcmpt_ds->CloseOnDisk();
					//cmpt_ds++;

					if (_found3)
					{
						SALOMEDS::SObject_var HypSO =
							Study->FindObjectID(refFromFile);
						if (!CORBA::is_nil(HypSO))
						{
							SALOMEDS::GenericAttribute_var anAttr;
							SALOMEDS::AttributeIOR_var anIOR;
							HypSO->FindAttribute(anAttr, "AttributeIOR");
							anIOR = SALOMEDS::AttributeIOR:: _narrow(anAttr);
							if (!CORBA::is_nil(anIOR))
							{
								char *HypIOR = anIOR->Value();
								SMESH::SMESH_Hypothesis_var anHyp =
									SMESH::SMESH_Hypothesis::_narrow(_orb->
									string_to_object(HypIOR));
								if (!CORBA::is_nil(anHyp))
								{
									SMESH::SMESH_Mesh_var aMesh = 
										aSubMesh->GetFather();
									aMesh->AddHypothesis(aSubShape, anHyp); //essayer avec _SMESHCorbaObj
									MESSAGE("Hypothesis added ...");
								}
							}
						}
					}
				}
			}
			else if (strcmp(sgname, "Applied Algorithms") == 0)
			{
				//********** ref on applied algorithms
				MESSAGE("Applied Algorithms");
				strcpy(name_meshgroup, "Applied Algorithms");
				//cmpt_sm++;
				HDFgroup * hdf_subgroup10cmpt_sm = new HDFgroup(name_meshgroup,
					hdf_subgroupmyTag);
				hdf_subgroup10cmpt_sm->OpenOnDisk();
				int nb_datasets = hdf_subgroup10cmpt_sm->nInternalObjects();
				SCRUTE(nb_datasets);

				char name_dataset[30];
				for (int l = 0; l < nb_datasets; l++)
				{
					sprintf(name_dataset, "Algo %d", l);
					HDFdataset * hdf_datasetcmpt_ds = new HDFdataset(
						name_dataset, hdf_subgroup10cmpt_sm);
					hdf_datasetcmpt_ds->OpenOnDisk();
					int size = hdf_datasetcmpt_ds->GetSize();

					char *refFromFile = new char[size];
					hdf_datasetcmpt_ds->ReadFromDisk(refFromFile);
					hdf_datasetcmpt_ds->CloseOnDisk();
					delete hdf_datasetcmpt_ds;
					//cmpt_ds++;

					if (_found3)
					{
						SALOMEDS::SObject_var AlgoSO =
							Study->FindObjectID(refFromFile);
						if (!CORBA::is_nil(AlgoSO))
						{
							SALOMEDS::GenericAttribute_var anAttr;
							SALOMEDS::AttributeIOR_var anIOR;
							AlgoSO->FindAttribute(anAttr, "AttributeIOR");
							anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
							if (!CORBA::is_nil(anIOR))
							{
								char *AlgoIOR = anIOR->Value();
								//SCRUTE(AlgoIOR);
								SMESH::SMESH_Hypothesis_var myHyp =
									SMESH::SMESH_Hypothesis::_narrow(_orb->
									string_to_object(AlgoIOR));
								SMESH::SMESH_Algo_var anAlgo =
									SMESH::SMESH_Algo::_narrow(myHyp);
								//SMESH::SMESH_Algo_var anAlgo = SMESH::SMESH_Algo::_narrow(_orb->string_to_object(AlgoIOR));
								if (!CORBA::is_nil(anAlgo))
								{
									SMESH::SMESH_Mesh_var aMesh =
										aSubMesh->GetFather();
									aMesh->AddHypothesis(aSubShape, anAlgo);	//essayer avec _SMESHCorbaObj
									MESSAGE("Algorithms added ...");
								}
							}
						}
					}
				}
			}
		}
		hdf_subgroupmyTag->CloseOnDisk();
	}
	hdf_subgroupmyLevel1Tag->CloseOnDisk();
}

GEOM::GEOM_Gen_var SMESH_Gen_i::getGeomEngine()
{
	MESSAGE("SMESH_Gen_i::getGeomEngine");
	SALOME_NamingService *_NS = SINGLETON_ < SALOME_NamingService >::Instance();
	ASSERT(SINGLETON_ < SALOME_NamingService >::IsAlreadyExisting());
	_NS->init_orb(_orb);
	SALOME_LifeCycleCORBA *myEnginesLifeCycle = new SALOME_LifeCycleCORBA(_NS);
	Engines::Component_var geomEngine =
	myEnginesLifeCycle->FindOrLoad_Component("FactoryServer", "GEOM");
	GEOM::GEOM_Gen_var myGeomEngine = GEOM::GEOM_Gen::_narrow(geomEngine);
	return myGeomEngine;	
}

GEOM::GEOM_Shape_var SMESH_Gen_i::getShape(SALOMEDS::Study_var Study, char * refFromFile)
{
	MESSAGE("SMESH_Gen_i::getShape("<<Study<<","<<refFromFile<<")");
	SCRUTE(CORBA::is_nil(Study));
	SALOMEDS::SObject_var CSO = Study->FindObjectID(refFromFile);
	GEOM::GEOM_Shape_var aShape;

	if (!CORBA::is_nil(CSO))
	{
		SALOMEDS::GenericAttribute_var anAttr;
		CSO->FindAttribute(anAttr, "AttributeIOR");
		if (!CORBA::is_nil(CSO))
		{
			MESSAGE("The shape was not loaded. Try to load it.");
			SALOMEDS::Driver_var driver = SALOMEDS::Driver::_narrow(getGeomEngine());
			SALOMEDS::SComponent_var SCO = SALOMEDS::SComponent::_narrow(Study->FindObject("Geometry"));
			SALOMEDS::StudyBuilder_var B = Study->NewBuilder();	
			B->LoadWith(SCO,driver);
			CSO->FindAttribute(anAttr, "AttributeIOR");
		}

		SALOMEDS::AttributeIOR_var anIOR =
			SALOMEDS::AttributeIOR::_narrow(anAttr);
		
		char *ShapeIOR = anIOR->Value();
		aShape =
			GEOM::GEOM_Shape::_narrow(_orb->string_to_object(ShapeIOR));
	}
	return aShape;
}

void SMESH_Gen_i::loadMesh(char * name, HDFfile * hdf_file,
	char* meshfile, SALOMEDS::Study_var Study)
{
	MESSAGE("SMESH_Gen_i::loadMesh("<<name<<","<<meshfile<<")");

	char msgname[HDF_NAME_MAX_LEN + 1];	
	char objectId[10];
	char name_of_group[HDF_NAME_MAX_LEN + 1];
	
	int myMeshId =
		atoi((string(name).substr(5, 5)).c_str());
	SCRUTE(myMeshId);

	HDFgroup * hdfGroupMeshId = new HDFgroup(name, hdf_file);
	hdfGroupMeshId->OpenOnDisk();

	int nb_meshsubgroup = hdfGroupMeshId->nInternalObjects();
	SCRUTE(nb_meshsubgroup);

	//********** Loading of the file name where the data are stored
	strcpy(name_of_group, "Mesh data");
	HDFdataset * dataset =
		new HDFdataset(name_of_group, hdfGroupMeshId);
	dataset->OpenOnDisk();

	char *datafilename = new char[dataset->GetSize()];
	dataset->ReadFromDisk(datafilename);
	dataset->CloseOnDisk();	
	MESSAGE("datafilename="<<datafilename<<" but this is ignored. We will read from "<<meshfile);
	datafilename=meshfile;

	//********** Loading of the reference on the shape
	//********** and mesh initialization
	strcpy(name_of_group, "Ref on shape");
	dataset =
		new HDFdataset(name_of_group, hdfGroupMeshId);
	dataset->OpenOnDisk();
	
	char *refFromFile = new char[dataset->GetSize()];
	dataset->ReadFromDisk(refFromFile);
	dataset->CloseOnDisk();	

	bool _found = false;
	SCRUTE(refFromFile);
	SMESH::SMESH_Mesh_var myNewMesh;
	GEOM::GEOM_Shape_var aShape=getShape(Study, refFromFile);

	if (!CORBA::is_nil(aShape))
	{
		_found = true;
		myNewMesh = Init(getGeomEngine(), Study->StudyId(), aShape, myMeshId);
		string iorString = _orb->object_to_string(myNewMesh);
		sprintf(objectId, "%ld", myNewMesh->GetId());
		string key=string("Mesh_")+string(objectId);
		MESSAGE("IOR of "<<key<<" is "<< iorString)
		_SMESHCorbaObj[key] = iorString;

		
		//********** 
		//********** Loading of mesh data
		if (strcmp(datafilename, "No data") != 0)
		{			
			StudyContext_iStruct *myStudyContext =
				_mapStudyContext_i[Study->StudyId()];
			int meshId = myNewMesh->GetId();
			SMESH_Mesh_i *meshServant =
				myStudyContext->mapMesh_i[meshId];
			::SMESH_Mesh & myLocMesh = meshServant->GetImpl();
			SMESHDS_Mesh *mySMESHDSMesh = myLocMesh.GetMeshDS();

			Mesh_Reader *myReader = SMESHDriver::GetMeshReader("MED");
			myReader->SetMesh(mySMESHDSMesh);
			myReader->SetMeshId(myMeshId);
			myReader->SetFile(datafilename);
			myReader->Read();
			mySMESHDSMesh->logFullUpdate();
			MESSAGE("Loaded a mesh with " << mySMESHDSMesh->NbNodes() <<" nodes");
		}
	}
	//********** 
	//}
	//else if (strcmp(msgname,"Applied Hypothesis")==0) {
	for (int ii = 0; ii < nb_meshsubgroup; ii++)
	{
		hdfGroupMeshId->InternalObjectIndentify(ii, msgname);
		if (strcmp(msgname, "Mesh data") == 0)
		{
			//nothing
		}
		else if (strcmp(msgname, "Ref on shape") == 0)
		{
			//nothing
		}
		else if (strcmp(msgname, "Applied Hypothesis") == 0)
		{
			loadAppliedHypothesis(hdfGroupMeshId, _found, Study, myNewMesh,
				aShape);
		}
		else if (strcmp(msgname, "Applied Algorithms") == 0)
		{
			loadAppliedAlgorithms(hdfGroupMeshId, _found, Study, myNewMesh,
				aShape);
		}
		else if (string(msgname).substr(0, 9) == string("SubMeshes"))
		{
			loadSubMeshes(hdfGroupMeshId, msgname, Study, myNewMesh);
		}
	}
	hdfGroupMeshId->CloseOnDisk();
}

/**
 * Load the part of the study related to SMESH.
 */
bool SMESH_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
	const SALOMEDS::TMPFile & theStream, const char *theURL, bool isMultiFile)
{
	MESSAGE("SMESH_Gen_i::Load");	
	// Get temporary files location
	TCollection_AsciiString tmpDir =
		isMultiFile ? TCollection_AsciiString((char *)theURL) : SALOMEDS_Tool::
		GetTmpDir();

	// Convert the stream into sequence of files to process
	SALOMEDS::ListOfFileNames_var aFileSeq =
		SALOMEDS_Tool::PutStreamToFiles(theStream, tmpDir.ToCString(),
		isMultiFile);

	TCollection_AsciiString aStudyName("");
	if (isMultiFile)
		aStudyName =
			(SALOMEDS_Tool::GetNameFromPath(theComponent->GetStudy()->URL()));

	// Set names of temporary files
	TCollection_AsciiString filename =
		tmpDir + aStudyName + TCollection_AsciiString("_SMESH.hdf");
	TCollection_AsciiString hypofile =
		tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Hypo.txt");
	TCollection_AsciiString algofile =
		tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Algo.txt");
	TCollection_AsciiString meshfile =
		tmpDir + aStudyName + TCollection_AsciiString("_SMESH_Mesh.med");

	SALOMEDS::Study_var Study = theComponent->GetStudy();
	int studyId = Study->StudyId();
	SCRUTE(studyId);

	SALOMEDS::AttributeName_var aName;
	
	SALOMEDS::SComponent_var fathergeom = Study->FindComponent("GEOM");
	SALOMEDS::SComponent_var myGeomSComp =
		SALOMEDS::SComponent::_narrow(fathergeom);
	SCRUTE(fathergeom);

	char name[HDF_NAME_MAX_LEN + 1];
	map < int, HDFgroup * > hdf_subgroup;	


	//************* HDF file opening
	HDFfile *hdf_file = new HDFfile(filename.ToCString());
	try
	{
		hdf_file->OpenOnDisk(HDF_RDONLY);
	}
	catch(HDFexception)
	{
		MESSAGE("Load(): " << filename << " not found!");
		return false;
	}

	//****************************

	int nb_group = hdf_file->nInternalObjects();
	SCRUTE(nb_group);
	for (int i = 0; i < nb_group; i++)
	{
		hdf_file->InternalObjectIndentify(i, name);
		if (strcmp(name, "Hypothesis") == 0)
			loadHypothesis(name, hdf_file, hypofile.ToCString(), studyId);
		else if (strcmp(name, "Algorithms") == 0)
			loadAlgorithms(name, hdf_file, algofile.ToCString(), studyId);
		else if (string(name).substr(0, 4) == string("Mesh"))
			loadMesh(name, hdf_file, meshfile.ToCString(), Study);
	}

	MESSAGE("End of SMESH_Gen::Load");

	hdf_file->CloseOnDisk();

	// Remove temporary files created from the stream
	if (isMultiFile)
		SALOMEDS_Tool::RemoveTemporaryFiles(tmpDir.ToCString(), aFileSeq.in(),
			true);

	return true;
}

bool SMESH_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
	const SALOMEDS::TMPFile & theStream, const char *theURL, bool isMultiFile)
{
	return Load(theComponent, theStream, theURL, isMultiFile);
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

void SMESH_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent)
{
	MESSAGE("Close");
	SALOMEDS::Study_var aStudy = theComponent->GetStudy();
	SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent);
	for (; itBig->More(); itBig->Next())
	{
		SALOMEDS::SObject_var gotBranch = itBig->Value();

		// branch 1 : hypothesis
		if (gotBranch->Tag() == Tag_HypothesisRoot ||
			gotBranch->Tag() == Tag_AlgorithmsRoot)
		{
			SALOMEDS::ChildIterator_var it =
				aStudy->NewChildIterator(gotBranch);
			for (; it->More(); it->Next())
			{
				SALOMEDS::SObject_var mySObject = it->Value();
				SALOMEDS::GenericAttribute_var anAttr;
				SALOMEDS::AttributeIOR_var anIOR;
				if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
				{
					anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
					SMESH::SMESH_Hypothesis_var myHyp =
						SMESH::SMESH_Hypothesis::_narrow(_orb->
						string_to_object(anIOR->Value()));
					char objectId[10];
					sprintf(objectId, "%ld", myHyp->GetId());
//        cout<<"********** delete Hyp "<<objectId<<endl;
					_SMESHCorbaObj.erase(string("Hypo_") + string(objectId));
					myHyp =
						SMESH::SMESH_Hypothesis::_narrow(_orb->
						string_to_object(anIOR->Value()));
				}
			}
		}
		// branch 2 : algorithms
		else if (gotBranch->Tag() >= 3)
		{
			SALOMEDS::ChildIterator_var it =
				aStudy->NewChildIterator(gotBranch);
			for (; it->More(); it->Next())
			{
				SALOMEDS::SObject_var mySObject = it->Value();
				SALOMEDS::GenericAttribute_var anAttr;
				SALOMEDS::AttributeIOR_var anIOR;
				if (mySObject->FindAttribute(anAttr, "AttributeIOR"))
				{
					anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
					SMESH::SMESH_Mesh_var myMesh =
						SMESH::SMESH_Mesh::_narrow(_orb->
						string_to_object(anIOR->Value()));
					if (!myMesh->_is_nil())
					{
						char objectId[10];
						sprintf(objectId, "%ld", myMesh->GetId());
//          cout<<"********** delete Mesh "<<objectId<<endl;
						_SMESHCorbaObj.erase(string("Mesh_") +
							string(objectId));
						CORBA::release(myMesh);
					}
					else
					{
						SMESH::SMESH_subMesh_var mySubMesh =
							SMESH::SMESH_subMesh::_narrow(_orb->
							string_to_object(anIOR->Value()));
						if (!mySubMesh->_is_nil())
						{
							char objectId[10];
							sprintf(objectId, "%ld", mySubMesh->GetId());
//            cout<<"********** delete SubMesh "<<objectId<<endl;
							_SMESHCorbaObj.erase(string("SubMesh_") +
								string(objectId));
							CORBA::release(mySubMesh);
						}
					}
				}
			}
		}
	}
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

char *SMESH_Gen_i::ComponentDataType()
{
	MESSAGE("SMESH_Gen_i::ComponentDataType");
	return strdup("SMESH");
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

char *SMESH_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
	const char *IORString, CORBA::Boolean isMultiFile, CORBA::Boolean isASCII)
{
	MESSAGE("SMESH_Gen_i::IORToLocalPersistentID");

	char objectId[10];

	SMESH::SMESH_Algo_var myAlgo =
		SMESH::SMESH_Algo::_narrow(_orb->string_to_object(IORString));
	if (!CORBA::is_nil(myAlgo))
	{
		string prefix = "Hypo_";
		sprintf(objectId, "%ld", myAlgo->GetId());
		string lpID = prefix + string(objectId);
		return CORBA::string_dup(lpID.c_str());
	}
	else
	{
		SMESH::SMESH_Hypothesis_var myHypo =
			SMESH::SMESH_Hypothesis::_narrow(_orb->string_to_object(IORString));
		if (!CORBA::is_nil(myHypo))
		{
			string prefix = "Hypo_";
			sprintf(objectId, "%ld", myHypo->GetId());
			string lpID = prefix + string(objectId);
			return CORBA::string_dup(lpID.c_str());
		}
		else
		{
			SMESH::SMESH_Mesh_var myMesh =
				SMESH::SMESH_Mesh::_narrow(_orb->string_to_object(IORString));
			if (!CORBA::is_nil(myMesh))
			{
				string prefix = "Mesh_";
				sprintf(objectId, "%ld", myMesh->GetId());
				string lpID = prefix + string(objectId);
				return CORBA::string_dup(lpID.c_str());
			}
			else
			{
				SMESH::SMESH_subMesh_var mySubMesh =
					SMESH::SMESH_subMesh::_narrow(_orb->
					string_to_object(IORString));
				if (!CORBA::is_nil(mySubMesh))
				{
					string prefix = "SubMesh_";
					sprintf(objectId, "%ld", mySubMesh->GetId());
					string lpID = prefix + string(objectId);
					return CORBA::string_dup(lpID.c_str());
				}
				else
					return (strdup("no object"));
			}
		}
	}
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

char *SMESH_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
	const char *aLocalPersistentID,
	CORBA::Boolean isMultiFile, CORBA::Boolean isASCII)
{
	MESSAGE("SMESH_Gen_i::LocalPersistentIDToIOR");
	SCRUTE(aLocalPersistentID);
	string clef = string(aLocalPersistentID);
	SCRUTE(_SMESHCorbaObj[clef].c_str());
	return CORBA::string_dup(_SMESHCorbaObj[clef].c_str());
}

//=============================================================================
/*!
 *  
 */
//=============================================================================

SMESH_topo *SMESH_Gen_i::ExploreMainShape(GEOM::GEOM_Gen_ptr geomEngine,
	CORBA::Long studyId, GEOM::GEOM_Shape_ptr aShape)
{
	MESSAGE("SMESH_Mesh_i::ExploreMainShape");
	// _narrow() duplicates the reference and check the type
	GEOM::GEOM_Gen_var geom = GEOM::GEOM_Gen::_narrow(geomEngine);
	GEOM::GEOM_Shape_var myShape = GEOM::GEOM_Shape::_narrow(aShape);

	if (CORBA::is_nil(geom))
		THROW_SALOME_CORBA_EXCEPTION("bad geom reference", SALOME::BAD_PARAM);
	if (CORBA::is_nil(myShape))
		THROW_SALOME_CORBA_EXCEPTION("bad shape reference", SALOME::BAD_PARAM);
	MESSAGE("---");
	SCRUTE(myShape->Name());
	geom->GetCurrentStudy(studyId);
	SCRUTE(studyId);
	TopoDS_Shape mainShape = _ShapeReader->GetShape(geom, myShape);
	MESSAGE("---");

	// create an SMESH_topo object for the mainShape

	SMESH_topo *myTopo = new SMESH_topo();
	MESSAGE("---");

	// explore local TopoDS_Shape, store reference of local TopoDS subShapes

	for (TopExp_Explorer exp(mainShape, TopAbs_COMPOUND); exp.More();
		exp.Next())
	{
		const TopoDS_Compound & E = TopoDS::Compound(exp.Current());
		int i = myTopo->_myShapes[TopAbs_COMPOUND].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_COMPSOLID); exp.More();
		exp.Next())
	{
		const TopoDS_CompSolid & E = TopoDS::CompSolid(exp.Current());
		int i = myTopo->_myShapes[TopAbs_COMPSOLID].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_SOLID); exp.More(); exp.Next())
	{
		const TopoDS_Solid & E = TopoDS::Solid(exp.Current());
		int i = myTopo->_myShapes[TopAbs_SOLID].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_SHELL); exp.More(); exp.Next())
	{
		const TopoDS_Shell & E = TopoDS::Shell(exp.Current());
		int i = myTopo->_myShapes[TopAbs_SHELL].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_FACE); exp.More(); exp.Next())
	{
		const TopoDS_Face & E = TopoDS::Face(exp.Current());
		int i = myTopo->_myShapes[TopAbs_FACE].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_WIRE); exp.More(); exp.Next())
	{
		const TopoDS_Wire & E = TopoDS::Wire(exp.Current());
		int i = myTopo->_myShapes[TopAbs_WIRE].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_EDGE); exp.More(); exp.Next())
	{
		const TopoDS_Edge & E = TopoDS::Edge(exp.Current());
		int i = myTopo->_myShapes[TopAbs_EDGE].Add(E);
		SCRUTE(i);
	}
	for (TopExp_Explorer exp(mainShape, TopAbs_VERTEX); exp.More(); exp.Next())
	{
		const TopoDS_Vertex & E = TopoDS::Vertex(exp.Current());
		int i = myTopo->_myShapes[TopAbs_VERTEX].Add(E);
		SCRUTE(i);
	}

	// explore subShapes of distant CORBA object,
	// associate distant CORBA subShape references
	// with local reference to local TopoDS subShape

	string filenode = "toposhape.txt";
	ofstream fic(filenode.c_str());

	for (int shapeType = TopAbs_COMPOUND; shapeType < TopAbs_SHAPE; shapeType++)
	{
		fic << "shape type : " << SMESH_shapeTypeNames[shapeType];

		GEOM::GEOM_Gen::ListOfGeomShapes_var subShapes
			= geom->SubShapeAll(myShape, shapeType);
		int nbSubShapes = subShapes->length();
		int nbLocal = myTopo->_myShapes[shapeType].Extent();
		fic << " - number of elements: " << nbSubShapes << endl;
		ASSERT(nbSubShapes == nbLocal);

		for (int i = 0; i < nbSubShapes; i++)
		{
			GEOM::GEOM_Shape_var aSubShape = subShapes[i];
			string idShape = SMESH_topo::GetShapeLocalId(aSubShape);
			fic << "  " << idShape;
			SCRUTE(idShape);
			TopoDS_Shape aLocShape = _ShapeReader->GetShape(geom, aSubShape);
			for (int j = 1; j <= nbLocal; j++)
				if (aLocShape.IsSame(myTopo->_myShapes[shapeType].FindKey(j)))
				{
					MESSAGE("  --- trouve = " << j);
					myTopo->_mapIndShapes[shapeType][idShape] = j;
					fic << "  --- trouve = " << j;
					break;
				}
			fic << endl;
		}
	}
	fic.close();

	return myTopo;
}

/**
 * Import a mesh from a file
 * @param fileName file name to be imported
 * @param fileType Currently it could be either "DAT", "UNV" or "MED".
 */
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::Import(CORBA::Long studyId,
	const char *fileName, const char *fileType)
{
	MESSAGE("SMESH_Gen_I::Import");
	SMESH_Mesh_i *meshServant;
	try
	{
		if (_mapStudyContext_i.find(studyId) == _mapStudyContext_i.end())
		{
			_mapStudyContext_i[studyId] = new StudyContext_iStruct;
		}
		StudyContext_iStruct *myStudyContext = _mapStudyContext_i[studyId];

		// create a new mesh object
		SMESH_Mesh * meshImpl=_impl.Import(studyId, fileName, fileType);
		
		// create a new mesh object servant, store it in a map in study context
		meshServant = new SMESH_Mesh_i(this, NULL, studyId, meshImpl);
		myStudyContext->mapMesh_i[meshImpl->GetId()] = meshServant;
	}
	catch(SALOME_Exception & S_ex)
	{
		THROW_SALOME_CORBA_EXCEPTION(S_ex.what(), SALOME::BAD_PARAM);
	}

	// activate the CORBA servant of Mesh

	SMESH::SMESH_Mesh_var mesh
		= SMESH::SMESH_Mesh::_narrow(meshServant->_this());

	meshServant->SetIor(mesh);
	return SMESH::SMESH_Mesh::_duplicate(mesh);
}

//=============================================================================
/*! 
 * C factory, accessible with dlsym, after dlopen  
 */
//=============================================================================

extern "C"
{
	PortableServer::ObjectId * SMESHEngine_factory(CORBA::ORB_ptr orb,
		PortableServer::POA_ptr poa,
		PortableServer::ObjectId * contId,
		const char *instanceName, const char *interfaceName)
	{
		MESSAGE("PortableServer::ObjectId * SMESHEngine_factory()");
		SCRUTE(interfaceName);
		SMESH_Gen_i *mySMESH_Gen
			= new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName);
		return mySMESH_Gen->getId();
	}
}