src/MEDMEM_I/MEDMEM_Med_i.cxx

   1 using namespace std;
   2 //=============================================================================
   3 // File      : MEDMEM_Med_i.cxx
   4 // Project   : SALOME
   5 // Author    : EDF
   6 // Copyright : EDF 2002
   7 // $Header: /export/home/PAL/MED_SRC/src/MEDMEM_I/MEDMEM_i.cxx
   8 //=============================================================================
   9
  10 #include <deque>
  11
  12 //#include "MEDMEM_Field.hxx"
  13
  14 #include "MEDMEM_Med_i.hxx"
  15 #include "MEDMEM_Mesh_i.hxx"
  16 #include "MEDMEM_FieldDouble_i.hxx"
  17 #include "MEDMEM_FieldInt_i.hxx"
  18 #include "MEDMEM_Support_i.hxx"
  19 #include "MEDMEM_Family_i.hxx"
  20 #include "MEDMEM_Group_i.hxx"
  21 #include "MEDMEM_convert.hxx"
  22
  23 #include "MEDMEM_DriversDef.hxx"
  24 #include "utilities.h"
  25 #include "Utils_CorbaException.hxx"
  26 using namespace MEDMEM;
  27
  28 //=============================================================================
  29 /*!
  30  * Default constructor
  31  */
  32 //=================================POA_SALOME_MED::FAMILY::_============================================
  33 MED_i::MED_i():_med((::MED*)NULL)
  34 {
  35         BEGIN_OF("Default Constructor MED_i");
  36         END_OF("Default Constructor MED_i");
  37 }
  38 //=============================================================================
  39 /*!
  40  * methods
  41  */
  42 //=============================================================================
  43 void MED_i::init(SALOMEDS::Study_ptr myStudy,driverTypes driverType, const string & fileName)
  44 {
  45         const char * LOC = "MED_i::init(driverTypes, const string &)";
  46         BEGIN_OF(LOC);
  47
  48   // we create all IOR from _med
  49         _med = new ::MED(driverType,fileName);
  50
  51   // MESHES :
  52         deque<string> meshesNames = _med->getMeshNames();
  53         int numberOfMeshes = meshesNames.size();
  54         for (int i=0; i<numberOfMeshes; i++)
  55         {
  56                 ::MESH * myMesh = _med->getMesh(meshesNames[i]);
  57                 myMesh->read();
  58                 MESH_i * myMeshI = new MESH_i(myMesh);
  59                 SALOME_MED::MESH_ptr myMeshIOR = myMeshI->_this();
  60                 _meshes[meshesNames[i]] = myMeshIOR;
  61                 myMeshI->addInStudy(myStudy,myMeshIOR,fileName);
  62         }
  63
  64   // SUPPORTS :
  65         _med->updateSupport();
  66
  67   // FAMILIES :
  68   // we add all families
  69         vector<FAMILY*> familyVector;
  70         vector<FAMILY*>::iterator familyVectorIt;
  71   // GROUPS :
  72   // we add all groups
  73         vector<GROUP*> groupVector;
  74         vector<GROUP*>::iterator groupVectorIt;
  75
  76         MED_FR::MESH_ENTITIES::const_iterator currentEntity;
  77         for (int i=0; i<numberOfMeshes; i++)
  78         {
  79                 ::MESH * ptrMesh = _med->getMesh(meshesNames[i]);
  80                 for (currentEntity = MED_FR::meshEntities.begin();
  81                      currentEntity != MED_FR::meshEntities.end();
  82                      currentEntity++)
  83                 {
  84                 // family :
  85                      familyVector = ptrMesh->getFamilies((MED_EN::medEntityMesh)(*currentEntity).first);
  86                      for (familyVectorIt = familyVector.begin();
  87                           familyVectorIt != familyVector.end();
  88                           familyVectorIt++)
  89                      {
  90                           FAMILY_i * myFamilyI = new FAMILY_i(*familyVectorIt);
  91                           SALOME_MED::FAMILY_ptr myFamilyIOR = myFamilyI->POA_SALOME_MED::FAMILY::_this();
  92                            myFamilyI->addInStudy(myStudy,myFamilyIOR);
  93                      }
  94
  95                // group :
  96                     groupVector = ptrMesh->getGroups((MED_EN::medEntityMesh)(*currentEntity).first);
  97                     for (groupVectorIt = groupVector.begin();
  98                          groupVectorIt != groupVector.end();
  99                          groupVectorIt++)
 100                     {
 101                          GROUP_i * myGroupI = new GROUP_i(*groupVectorIt);
 102                          SALOME_MED::GROUP_ptr myGroupIOR = myGroupI->POA_SALOME_MED::GROUP::_this();
 103                          myGroupI->addInStudy(myStudy,myGroupIOR);
 104                     }
 105                 }
 106         }
 107
 108         for (int i=0; i<numberOfMeshes; i++)
 109         {
 110               map<MED_FR::med_entite_maillage,::SUPPORT*> mySupports = _med->getSupports(meshesNames[i]);
 111               map<MED_FR::med_entite_maillage,::SUPPORT*>::const_iterator itSupport;
 112               map<MED_FR::med_entite_maillage, SALOME_MED::SUPPORT_ptr> & mySupportsIOR
 113                                 = _supports[meshesNames[i]];
 114               for ( itSupport = mySupports.begin(); itSupport != mySupports.end(); itSupport++ )
 115               {
 116                     SUPPORT_i * mySupportI = new SUPPORT_i((*itSupport).second);
 117                     SALOME_MED::SUPPORT_ptr mySupportIOR = mySupportI->_this();
 118                     mySupportsIOR[(*itSupport).first] = mySupportIOR;
 119                     mySupportI->addInStudy(myStudy,mySupportIOR);
 120               }
 121         }
 122
 123   // FIELDS :
 124         deque<string> fieldsNames = _med->getFieldNames();
 125         int numberOfFields = fieldsNames.size();
 126         for (int i=0; i<numberOfFields; i++)
 127         {
 128              deque<DT_IT_> myIteration = _med->getFieldIteration (fieldsNames[i]);
 129              int numberOfIteration = myIteration.size();
 130              for (int j=0; j<numberOfIteration; j++)
 131              {
 132                  ::FIELD_ * myField = _med->getField(fieldsNames[i], myIteration[j].dt, myIteration[j].it);
 133                  string meshName = myField->getSupport()->getMesh()->getName();
 134                  medEntityMesh myEntity = myField->getSupport()->getEntity();
 135                  map<string, map<MED_FR::med_entite_maillage, SALOME_MED::SUPPORT_ptr> >::const_iterator
 136                                                              itSupportOnMesh = _supports.find(meshName);
 137                  if ( itSupportOnMesh == _supports.end() )
 138                       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 139                                          << "There is no support on mesh named |"
 140                                          << meshName << "|" ));
 141                  const map<MED_FR::med_entite_maillage, SALOME_MED::SUPPORT_ptr> & SupportOnMesh
 142                                         = (*itSupportOnMesh).second;
 143                  map<MED_FR::med_entite_maillage,SALOME_MED::SUPPORT_ptr>::const_iterator itSupport
 144                                         = SupportOnMesh.find((MED_FR::med_entite_maillage)myEntity);
 145                  if (itSupport == SupportOnMesh.end())
 146                       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 147                                          << "There is no support on entity "
 148                                          << entity << " in mesh named |"
 149                                          << meshName << "|"));
 150                  SALOME_MED::SUPPORT_ptr mySupportIOR = (*itSupport).second;
 151                  med_type_champ type = myField->getValueType();
 152                  SALOME_MED::FIELD_ptr myFieldIOR;
 153                  switch (type)
 154                  {
 155                          case MED_FR::MED_INT32 :
 156                          {
 157                              ((FIELD<int>*)myField)->read();
 158                              FIELDINT_i * myFieldIntI = new FIELDINT_i(mySupportIOR,(FIELD<int>*)myField);
 159                              POA_SALOME_MED::FIELD_tie<FIELD_i> * myFieldTie
 160                                         = new POA_SALOME_MED::FIELD_tie<FIELD_i>(myFieldIntI);
 161                              myFieldIOR = myFieldTie->_this();
 162                              myFieldIntI->addInStudy(myStudy,myFieldIOR);
 163                              break;
 164                          }
 165
 166                         case MED_FR::MED_REEL64:
 167                         {
 168                              ((FIELD<double>*)myField)->read();
 169                              FIELDDOUBLE_i * myFieldDoubleI
 170                                         = new FIELDDOUBLE_i(mySupportIOR,(FIELD<double>*)myField);
 171                              POA_SALOME_MED::FIELD_tie<FIELD_i> * myFieldTie
 172                                         = new POA_SALOME_MED::FIELD_tie<FIELD_i>(myFieldDoubleI);
 173                              myFieldIOR = myFieldTie->_this();
 174                              myFieldDoubleI->addInStudy(myStudy,myFieldIOR);
 175                              break;
 176                         }
 177                         default:
 178                         {
 179                              throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 180                                          <<"   * Iteration "<<FieldIteration[j].dt
 181                                          <<", order number "<<FieldIteration[j].it
 182                                          <<" has wrong type : "<<type));
 183                              break;
 184                         }
 185                 }
 186
 187                 DT_IT_ dtIt;
 188                 dtIt.dt  = myIteration[j].dt;
 189                 dtIt.it  = myIteration[j].it;
 190                 _fields[fieldsNames[i]][dtIt] = myFieldIOR;
 191              }
 192   }
 193
 194   END_OF(LOC);
 195 }
 196
 197 //=============================================================================
 198 /*!
 199  * methods
 200  */
 201 //=============================================================================
 202 void MED_i::initWithFieldType(SALOMEDS::Study_ptr myStudy,driverTypes driverType, const string & fileName)
 203 {
 204         const char * LOC = "MED_i::initWithFieldType(driverTypes, const string &)";
 205         BEGIN_OF(LOC);
 206
 207   // we create all IOR from _med
 208         _med = new ::MED(driverType,fileName);
 209
 210   // MESHES :
 211         deque<string> meshesNames = _med->getMeshNames();
 212         int numberOfMeshes = meshesNames.size();
 213         for (int i=0; i<numberOfMeshes; i++)
 214         {
 215             ::MESH * myMesh = _med->getMesh(meshesNames[i]);
 216             myMesh->read();
 217             MESH_i * myMeshI = new MESH_i(myMesh);
 218             SALOME_MED::MESH_ptr myMeshIOR = myMeshI->_this();
 219             _meshes[meshesNames[i]]=myMeshIOR;
 220             myMeshI->addInStudy(myStudy,myMeshIOR);
 221         }
 222
 223   // SUPPORTS :
 224         _med->updateSupport();
 225         for (int i=0; i<numberOfMeshes; i++)
 226         {
 227             map<MED_FR::med_entite_maillage,::SUPPORT*> mySupports = _med->getSupports(meshesNames[i]);
 228             map<MED_FR::med_entite_maillage,::SUPPORT*>::const_iterator itSupport;
 229             map<MED_FR::med_entite_maillage,SALOME_MED::SUPPORT_ptr> &
 230                         mySupportsIOR = _supports[meshesNames[i]];
 231             for (itSupport=mySupports.begin(); itSupport!=mySupports.end(); itSupport++ )
 232             {
 233                  SUPPORT_i * mySupportI = new SUPPORT_i((*itSupport).second);
 234                  SALOME_MED::SUPPORT_ptr mySupportIOR = mySupportI->_this();
 235                  mySupportsIOR[(*itSupport).first]= mySupportIOR;
 236                  mySupportI->addInStudy(myStudy,mySupportIOR);
 237             }
 238         }
 239
 240   // FIELDS :
 241         deque<string> fieldsNames = _med->getFieldNames();
 242         int numberOfFields = fieldsNames.size();
 243         for (int i=0; i<numberOfFields; i++)
 244         {
 245              deque<DT_IT_> myIteration = _med->getFieldIteration (fieldsNames[i]);
 246              int numberOfIteration = myIteration.size();
 247              for (int j=0; j<numberOfIteration; j++)
 248              {
 249                   ::FIELD_ * myField = _med->getField(fieldsNames[i],myIteration[j].dt,myIteration[j].it);
 250                   string meshName = myField->getSupport()->getMesh()->getName();
 251                   medEntityMesh myEntity = myField->getSupport()->getEntity();
 252                   map<string, map<MED_FR::med_entite_maillage,SALOME_MED::SUPPORT_ptr> >::const_iterator
 253                         itSupportOnMesh = _supports.find(meshName);
 254                   if (itSupportOnMesh == _supports.end() )
 255                         throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 256                                          << "There is no support on mesh named |"
 257                                          << meshName << "|"));
 258                   const map<MED_FR::med_entite_maillage,SALOME_MED::SUPPORT_ptr> & SupportOnMesh
 259                                 = (*itSupportOnMesh).second;
 260                   map<MED_FR::med_entite_maillage,SALOME_MED::SUPPORT_ptr>::const_iterator itSupport
 261                                 = SupportOnMesh.find((MED_FR::med_entite_maillage)myEntity);
 262                   if (itSupport == SupportOnMesh.end() )
 263                         throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 264                                          << "There is no support on entity "
 265                                          << entity << " in mesh named |"
 266                                          << meshName << "|"));
 267                   SALOME_MED::SUPPORT_ptr mySupportIOR = (*itSupport).second;
 268                   med_type_champ type = myField->getValueType();
 269
 270                   DT_IT_ dtIt;
 271                   dtIt.dt  = myIteration[j].dt;
 272                   dtIt.it  = myIteration[j].it;
 273
 274                   switch (type)
 275                   {
 276                      case MED_FR::MED_INT32:
 277                      {
 278                         ((FIELD<int>*)myField)->read();
 279                         FIELDINT_i * myFieldIntI
 280                                    = new FIELDINT_i(mySupportIOR,(FIELD<int>*)myField);
 281                         SALOME_MED::FIELDINT_ptr myFieldIntIOR;
 282                         POA_SALOME_MED::FIELDINT_tie<FIELDINT_i> * myFieldIntTie
 283                                 = new POA_SALOME_MED::FIELDINT_tie<FIELDINT_i>(myFieldIntI);
 284                         myFieldIntIOR = myFieldIntTie->_this();
 285                         myFieldIntI->addInStudy(myStudy,myFieldIntIOR);
 286                         _fields[fieldsNames[i]][dtIt] = myFieldIntIOR;
 287                         break;
 288                      }
 289
 290                      case MED_FR::MED_REEL64:
 291                      {
 292                         ((FIELD<double>*)myField)->read();
 293                         FIELDDOUBLE_i * myFieldDoubleI
 294                                 = new FIELDDOUBLE_i(mySupportIOR,(FIELD<double>*)myField);
 295                         SALOME_MED::FIELDDOUBLE_ptr myFieldDoubleIOR;
 296                         POA_SALOME_MED::FIELDDOUBLE_tie<FIELDDOUBLE_i> * myFieldDoubleTie
 297                                 = new POA_SALOME_MED::FIELDDOUBLE_tie<FIELDDOUBLE_i>(myFieldDoubleI);
 298                         myFieldDoubleIOR = myFieldDoubleTie->_this();
 299                         myFieldDoubleI->addInStudy(myStudy,myFieldDoubleIOR);
 300                         _fields[fieldsNames[i]][dtIt] = myFieldDoubleIOR;
 301                         break;
 302                      }
 303
 304                     default:
 305                     {
 306                         throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 307                                          <<"   * Iteration "<<FieldIteration[j].dt
 308                                          <<", order number "<<FieldIteration[j].it
 309                                          <<" has wrong type : "<<type));
 310                         break;
 311                      }
 312                   }
 313              }
 314         }
 315
 316         END_OF(LOC);
 317 }
 318
 319 //=============================================================================
 320 /*!
 321  * Destructor
 322  */
 323 //=============================================================================
 324 MED_i::~MED_i()
 325 {
 326 }
 327 //=============================================================================
 328 /*!
 329  * CORBA: Accessor for Number of meshes
 330  */
 331 //=============================================================================
 332 CORBA::Long MED_i::getNumberOfMeshes()
 333 throw (SALOME::SALOME_Exception)
 334 {
 335         if (_med==NULL)
 336                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 337                                              SALOME::INTERNAL_ERROR);
 338         try
 339         {
 340                 return _med->getNumberOfMeshes();
 341         }
 342         catch (MEDEXCEPTION &ex)
 343         {
 344                 MESSAGE("Unable to get the number of meshes in Med Object");
 345                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 346         }
 347 }
 348 //=============================================================================
 349 /*!
 350  * CORBA: Accessor for Number of fields
 351  */
 352 //=============================================================================
 353 CORBA::Long MED_i::getNumberOfFields()
 354 throw (SALOME::SALOME_Exception)
 355 {
 356         if (_med==NULL)
 357                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 358                                              SALOME::INTERNAL_ERROR);
 359         try
 360         {
 361                 return _med->getNumberOfFields();
 362         }
 363         catch (MEDEXCEPTION &ex)
 364         {
 365                 MESSAGE("Unable to get the number of fields in Med Object");
 366                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 367         }
 368 }
 369 //=============================================================================
 370 /*!
 371  * CORBA: Accessor for meshes names
 372  */
 373 //=============================================================================
 374 SALOME_MED::string_array * MED_i::getMeshNames()
 375 throw (SALOME::SALOME_Exception)
 376 {
 377         if (_med==NULL)
 378                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 379                                              SALOME::INTERNAL_ERROR);
 380         SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
 381         try
 382         {
 383                 int nbMeshes=_med->getNumberOfMeshes();
 384                 myseq->length(nbMeshes);
 385                 string * nameMeshes = new string[nbMeshes];
 386                 _med->getMeshNames(nameMeshes);
 387                 for (int i=0;i<nbMeshes;i++)
 388                 {
 389                         myseq[i]=CORBA::string_dup(nameMeshes[i].c_str());
 390                 }
 391                 delete [] nameMeshes;
 392                 nameMeshes=NULL;
 393         }
 394         catch (MEDEXCEPTION &ex)
 395         {
 396                 MESSAGE("Unable to get the names of the meshes in Med Object");
 397                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 398         }
 399         return myseq._retn();
 400 }
 401 //=============================================================================
 402 /*!
 403  * CORBA: Accessor for fields names
 404  */
 405 //=============================================================================
 406 SALOME_MED::string_array * MED_i::getFieldNames()
 407 throw (SALOME::SALOME_Exception)
 408 {
 409         if (_med==NULL)
 410                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 411                                              SALOME::INTERNAL_ERROR);
 412         SALOME_MED::string_array_var myseq = new SALOME_MED::string_array;
 413         try
 414         {
 415                 int nbFields=_med->getNumberOfFields();
 416                 myseq->length(nbFields);
 417                 string * nameFields = new string[nbFields];
 418                 _med->getFieldNames(nameFields);
 419                 for (int i=0;i<nbFields;i++)
 420                 {
 421                         myseq[i]=CORBA::string_dup(nameFields[i].c_str());
 422                 }
 423                 delete nameFields;
 424                 nameFields=NULL;
 425         }
 426         catch (MEDEXCEPTION &ex)
 427         {
 428                 MESSAGE("Unable to get the names of the fields in Med Object");
 429                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 430         }
 431         return myseq._retn();
 432 }
 433 //=============================================================================
 434 /*!
 435  * CORBA: Accessor for a specific mesh
 436  */
 437 //=============================================================================
 438 SALOME_MED::MESH_ptr MED_i::getMeshByName(const char* meshName)
 439 throw (SALOME::SALOME_Exception)
 440 {
 441         if (_med==NULL)
 442                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 443                                              SALOME::INTERNAL_ERROR);
 444         try
 445         {
 446                 MESH * mesh=_med->getMesh(meshName);
 447                 MESH_i * m1 = new MESH_i(mesh);
 448                 SALOME_MED::MESH_ptr m2 = m1->POA_SALOME_MED::MESH::_this();
 449                 m1->_remove_ref();
 450                 return (SALOME_MED::MESH::_duplicate(m2));
 451         }
 452         catch (MEDEXCEPTION &ex)
 453         {
 454                 MESSAGE("Unable to get the specified mesh");
 455                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 456         }
 457
 458 }
 459 //=============================================================================
 460 /*!
 461  * CORBA: Accessor for a specific mesh
 462  */
 463 //=============================================================================
 464 SALOME_MED::MESH_ptr MED_i::getMesh(SALOME_MED::FIELD_ptr fieldPtr)
 465 throw (SALOME::SALOME_Exception)
 466 {
 467         if (_med==NULL)
 468                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 469                                              SALOME::INTERNAL_ERROR);
 470         int ind=fieldPtr->getCorbaIndex();
 471         SCRUTE(ind);
 472
 473         MESH * mesh;
 474         SALOME_MED::FIELDINT_var fieldint =SALOME_MED::FIELDINT::_narrow(fieldPtr);
 475         if (CORBA::is_nil(fieldint))
 476         {
 477                 MESSAGE("Double");
 478                 SALOME_MED::FIELDDOUBLE_var fielddouble =
 479                             SALOME_MED::FIELDDOUBLE::_narrow(fieldPtr);
 480                 ASSERT(!CORBA::is_nil(fielddouble));
 481                 ASSERT(FIELDOF_i<double>::fieldMap.find(ind)
 482                                 !=FIELDOF_i<double>::fieldMap.end());
 483                 ::FIELD<double> * fdouble = FIELDOF_i<double>::fieldMap[ind];
 484                 MESH * mesh=_med->getMesh(fdouble);
 485         }
 486         else
 487         {
 488                 MESSAGE("Integer");
 489                 ASSERT(FIELDOF_i<int>::fieldMap.find(ind)!=FIELDOF_i<int>::fieldMap.end());
 490                 ::FIELD<int> * fint = FIELDOF_i<int>::fieldMap[ind];
 491                 MESH * mesh=_med->getMesh(fint);
 492         }
 493         MESH_i * meshi = new MESH_i(mesh);
 494         SALOME_MED::MESH_ptr meshptr = meshi->POA_SALOME_MED::MESH::_this();
 495         meshi->_remove_ref();
 496         return (SALOME_MED::MESH::_duplicate(meshptr));
 497
 498 }
 499 //=============================================================================
 500 /*!
 501  * CORBA: Accessor for a specific field
 502  */
 503 //=============================================================================
 504 SALOME_MED::FIELD_ptr MED_i::getField(const char* fieldName,
 505                                       CORBA::Long pasTemps,
 506                                       CORBA::Long numOrdre )
 507 throw (SALOME::SALOME_Exception)
 508 {
 509         const char * LOC="MED_i::getField(const char*,CORBA::Long,CORBA::Long) ";
 510         BEGIN_OF(LOC);
 511
 512         DT_IT_ dtIt;
 513
 514         dtIt.dt= (int)pasTemps;
 515         dtIt.it= (int)numOrdre;
 516
 517         map<string,MAP_IOR_DT_IT_>::const_iterator itFields = _fields.find(fieldName);
 518
 519         if ( itFields == _fields.end() )
 520                 THROW_SALOME_CORBA_EXCEPTION("Field not found !", SALOME::INTERNAL_ERROR);
 521
 522         const MAP_IOR_DT_IT_ & map_dtIt = (*itFields).second;
 523         MAP_IOR_DT_IT_::const_iterator itMap_dtIt =  map_dtIt.find(dtIt);
 524
 525         if ( itMap_dtIt == map_dtIt.end() )
 526                 THROW_SALOME_CORBA_EXCEPTION("Iteration not found !", SALOME::INTERNAL_ERROR);
 527
 528         END_OF(LOC);
 529         return (*itMap_dtIt).second;
 530
 531 }
 532 //=============================================================================
 533 /*!
 534  * CORBA: Accessor for a specific field
 535  */
 536 //=============================================================================
 537 CORBA::Long MED_i::addDriver(SALOME_MED::medDriverTypes driverType, const char* fileName)
 538 throw (SALOME::SALOME_Exception)
 539 {
 540         if (_med==NULL)
 541                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 542                                              SALOME::INTERNAL_ERROR);
 543         try
 544         {
 545                 int driv=_med->addDriver(convertIdlDriverToMedDriver(driverType),
 546                                         fileName);
 547                 return driv;
 548         }
 549         catch (MEDEXCEPTION &ex)
 550         {
 551                 MESSAGE("Unable to add a driver to the med object");
 552                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 553         }
 554
 555 }
 556 //=============================================================================
 557 /*!
 558  * CORBA: relase the driver (mandatory)
 559  */
 560 //=============================================================================
 561 void MED_i::rmDriver(CORBA::Long i)
 562 throw (SALOME::SALOME_Exception)
 563 {
 564         if (_med==NULL)
 565                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 566                                              SALOME::INTERNAL_ERROR);
 567         try
 568         {
 569                 _med->rmDriver(i);
 570         }
 571         catch (MEDEXCEPTION &ex)
 572         {
 573                 MESSAGE("Unable to unlink the driver from the med object");
 574                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 575         }
 576 }
 577 //=============================================================================
 578 /*!
 579  * CORBA: read med objects relations
 580  */
 581 //=============================================================================
 582 void MED_i::readFileStruct(CORBA::Long i)
 583 throw (SALOME::SALOME_Exception)
 584 {
 585         if (_med==NULL)
 586                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 587                                              SALOME::INTERNAL_ERROR);
 588         try
 589         {
 590                 _med->readFileStruct(i);
 591         }
 592         catch (MEDEXCEPTION &ex)
 593         {
 594                 MESSAGE("Unable to read the structure of this file ");
 595                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 596         }
 597 }
 598 //=============================================================================
 599 /*!
 600  * CORBA: write specifics objects f
 601  */
 602 //=============================================================================
 603 void MED_i::writeFrom(CORBA::Long i)
 604 throw (SALOME::SALOME_Exception)
 605 {
 606         if (_med==NULL)
 607                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 608                                              SALOME::INTERNAL_ERROR);
 609         try
 610         {
 611                 _med->writeFrom(i);
 612         }
 613         catch (MEDEXCEPTION &ex)
 614         {
 615                 MESSAGE("Unable to write this driver ");
 616                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 617         }
 618 }
 619 //=============================================================================
 620 /*!
 621  * CORBA: write objects
 622  */
 623 //=============================================================================
 624 void MED_i::write(CORBA::Long i)
 625 throw (SALOME::SALOME_Exception)
 626 {
 627         if (_med==NULL)
 628                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 629                                              SALOME::INTERNAL_ERROR);
 630         try
 631         {
 632                 _med->write(i);
 633         }
 634         catch (MEDEXCEPTION &ex)
 635         {
 636                 MESSAGE("Unable to write this file ");
 637                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 638         }
 639 }
 640 //=============================================================================
 641 /*!
 642  * CORBA: Add Mesh in Med objects
 643  */
 644 //=============================================================================
 645 void MED_i::addMesh(SALOME_MED::MESH_ptr ptrMesh)
 646 throw (SALOME::SALOME_Exception)
 647 {
 648         if (_med==NULL)
 649                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 650                                              SALOME::INTERNAL_ERROR);
 651         try
 652         {
 653                 int ind=ptrMesh->getCorbaIndex();
 654                 SCRUTE(ind);
 655                 ASSERT(MESH_i::meshMap.find(ind) !=MESH_i::meshMap.end());
 656                 MESH * mesh= MESH_i::meshMap[ind];
 657                 _med->addMesh(mesh);
 658         }
 659         catch (MEDEXCEPTION &ex)
 660         {
 661                 MESSAGE("Unable to link this mesh to this med object");
 662                 THROW_SALOME_CORBA_EXCEPTION(ex.what(), SALOME::INTERNAL_ERROR);
 663         }
 664 }
 665 //=============================================================================
 666 /*!
 667  * CORBA: Add field in Med objects
 668  */
 669 //=============================================================================
 670 void MED_i::addField(SALOME_MED::FIELD_ptr ptrField)
 671 throw (SALOME::SALOME_Exception)
 672 {
 673         if (_med==NULL)
 674                 THROW_SALOME_CORBA_EXCEPTION("No associated Med object",\
 675                                              SALOME::INTERNAL_ERROR);
 676         int ind=ptrField->getCorbaIndex();
 677         SCRUTE(ind);
 678
 679         SALOME_MED::FIELDINT_var fieldint =SALOME_MED::FIELDINT::_narrow(ptrField);
 680         if (CORBA::is_nil(fieldint))
 681         {
 682                 MESSAGE("Double");
 683                 SALOME_MED::FIELDDOUBLE_var fielddouble =
 684                             SALOME_MED::FIELDDOUBLE::_narrow(ptrField);
 685                 ASSERT(!CORBA::is_nil(fielddouble));
 686                 ASSERT(FIELDOF_i<double>::fieldMap.find(ind)
 687                                 !=FIELDOF_i<double>::fieldMap.end());
 688                 ::FIELD<double> * fdouble = FIELDOF_i<double>::fieldMap[ind];
 689                 // A modifier
 690                 //_med->addField(fdouble);
 691         }
 692         else
 693         {
 694                 MESSAGE("Integer");
 695                 ASSERT(FIELDOF_i<int>::fieldMap.find(ind)!=FIELDOF_i<int>::fieldMap.end());
 696                 ::FIELD<int> * fint = FIELDOF_i<int>::fieldMap[ind];
 697                 //_med->addField(fint);
 698         }
 699 }
 700 //=============================================================================
 701 /*!
 702  * CORBA: Add Med in Study
 703  */
 704 //=============================================================================
 705 void MED_i::addInStudy(SALOMEDS::Study_ptr myStudy, SALOME_MED::MED_ptr myIor)
 706 throw (SALOME::SALOME_Exception,SALOMEDS::StudyBuilder::LockProtection)
 707 {
 708         BEGIN_OF("MED_Mesh_i::addInStudy");
 709         if ( _medId != "" )
 710         {
 711                 MESSAGE("Med already in Study");
 712                     THROW_SALOME_CORBA_EXCEPTION("Med already in Study", \
 713                                  SALOME::BAD_PARAM);
 714         };
 715
 716         SALOMEDS::StudyBuilder_var     myBuilder = myStudy->NewBuilder();
 717         myBuilder->NewCommand();
 718         SALOMEDS::GenericAttribute_var anAttr;
 719         SALOMEDS::AttributeName_var    aName;
 720         SALOMEDS::AttributeIOR_var     aIOR;
 721
 722         // Create SComponent labelled 'MED' if it doesn't already exit
 723         SALOMEDS::SComponent_var medfather = myStudy->FindComponent("MED");
 724         if ( CORBA::is_nil(medfather) )
 725         {
 726           THROW_SALOME_CORBA_EXCEPTION("Component Med not found",
 727                                        SALOME::BAD_PARAM);
 728         };
 729
 730         MESSAGE("Add a MED Object under Med");
 731         SALOMEDS::SObject_var newObj = myBuilder->NewObject(medfather);
 732
 733         ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
 734         ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 735         CORBA::ORB_var &orb = init(0,0);
 736         string iorStr = orb->object_to_string(myIor);
 737         anAttr = myBuilder->FindOrCreateAttribute(newObj, "AttributeIOR");
 738         aIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 739         aIOR->SetValue(iorStr.c_str());
 740         anAttr = myBuilder->FindOrCreateAttribute(newObj, "AttributeName");
 741         aName = SALOMEDS::AttributeName::_narrow(anAttr);
 742         aName->SetValue("Objet MED");
 743         _medId = newObj->GetID();
 744         myBuilder->CommitCommand();
 745
 746         END_OF("Med_i::addInStudy(SALOMEDS::Study_ptr myStudy)");
 747 }
 748