src/MEDCalc/cmp/MED.cxx

   1 // Copyright (C) 2015-2016  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "MED.hxx"
  21 #include "MEDFactoryClient.hxx"
  22 #include <MEDCalcConstants.hxx>
  23
  24 #include <SALOMEconfig.h>
  25 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
  26
  27 #include <SALOMEDS_SObject.hxx>
  28 #include <Utils_ExceptHandlers.hxx>
  29 #include <SALOME_LifeCycleCORBA.hxx>
  30 #include <SALOME_NamingService.hxx>
  31 #include <SALOME_KernelServices.hxx>
  32 #include <SALOMEDSImpl_AttributeParameter.hxx>
  33
  34 #include <string>
  35 #include <sstream>
  36
  37 /*!
  38   \brief Constructor
  39
  40   Creates an instance of the MED component engine
  41
  42   \param orb reference to the ORB
  43   \param poa reference to the POA
  44   \param contId CORBA object ID, pointing to the owner SALOME container
  45   \param instanceName SALOME component instance name
  46   \param interfaceName SALOME component interface name
  47 */
  48 MED::MED(CORBA::ORB_ptr orb,
  49          PortableServer::POA_ptr poa,
  50          PortableServer::ObjectId* contId,
  51          const char* instanceName,
  52          const char* interfaceName)
  53   : Engines_Component_i(orb, poa, contId, instanceName, interfaceName),
  54     _fieldSeriesEntries(),
  55     _meshEntries()
  56 {
  57   _thisObj = this;
  58   _id = _poa->activate_object(_thisObj); // register and activate this servant object
  59 }
  60
  61 MED::~MED()
  62 {
  63   // nothing to do
  64 }
  65
  66 MED_ORB::status
  67 MED::addDatasourceToStudy(const MEDCALC::DatasourceHandler& datasourceHandler)
  68 {
  69   // set exception handler to catch unexpected CORBA exceptions
  70   Unexpect aCatch(SALOME_SalomeException);
  71
  72   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
  73   // check if reference to study is valid
  74   if (!CORBA::is_nil(aStudy)) {
  75     // get full object path
  76     std::string fullName = CORBA::string_dup(datasourceHandler.name);
  77     // check if the object with the same name is already registered in the study
  78     SALOMEDS::SObject_var sobj = aStudy->FindObjectByPath(fullName.c_str());
  79     if (CORBA::is_nil(sobj)) {
  80       // object is not registered yet -> register
  81       SALOMEDS::GenericAttribute_var anAttr;
  82       SALOMEDS::AttributeParameter_var aParam;
  83       SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
  84       SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
  85
  86       // find MED component; create it if not found
  87       SALOMEDS::SComponent_var father = aStudy->FindComponent("MED");
  88       if (CORBA::is_nil(father)) {
  89         // create component
  90         father = studyBuilder->NewComponent("MED");
  91         // set name attribute
  92         father->SetAttrString("AttributeName", "MEDCalc");
  93         // set icon attribute
  94         father->SetAttrString("AttributePixMap", "ICO_MED");
  95         // register component in the study
  96         studyBuilder->DefineComponentInstance(father, MED_Gen::_this());
  97         // add component to the use case tree
  98         // (to support tree representation customization and drag-n-drop)
  99         useCaseBuilder->SetRootCurrent();
 100         useCaseBuilder->Append(father); // component object is added as the top level item
 101       }
 102
 103       // create new sub-object, as a child of the component object
 104       SALOMEDS::SObject_var soDatasource = studyBuilder->NewObject(father);
 105       soDatasource->SetAttrString("AttributeName", fullName.c_str());
 106       soDatasource->SetAttrString("AttributePixMap", "ICO_DATASOURCE");
 107       anAttr = studyBuilder->FindOrCreateAttribute(soDatasource, "AttributeParameter");
 108       aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 109       aParam->SetInt(SOURCE_ID, datasourceHandler.id);
 110       useCaseBuilder->AppendTo(soDatasource->GetFather(), soDatasource);
 111
 112       // We can add the meshes as children of the datasource
 113       MEDCALC::MeshHandlerList* meshHandlerList =
 114         MEDFactoryClient::getDataManager()->getMeshHandlerList(datasourceHandler.id);
 115
 116       for(CORBA::ULong iMesh=0; iMesh<meshHandlerList->length(); iMesh++) {
 117         MEDCALC::MeshHandler meshHandler = (*meshHandlerList)[iMesh];
 118         SALOMEDS::SObject_var soMesh = studyBuilder->NewObject(soDatasource);
 119         _meshEntries[meshHandler.id] = soMesh->GetID();
 120         soMesh->SetAttrString("AttributeName", meshHandler.name);
 121         soMesh->SetAttrString("AttributePixMap", "ICO_DATASOURCE_MESH");
 122         anAttr = studyBuilder->FindOrCreateAttribute(soMesh, "AttributeParameter");
 123         aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 124         aParam->SetInt(MESH_ID, meshHandler.id);
 125         aParam->SetBool(IS_IN_WORKSPACE, false);
 126         useCaseBuilder->AppendTo(soMesh->GetFather(), soMesh);
 127
 128         // We add the field timeseries defined on this mesh, as children of the mesh SObject
 129         MEDCALC::FieldseriesHandlerList * fieldseriesHandlerList =
 130           MEDFactoryClient::getDataManager()->getFieldseriesListOnMesh(meshHandler.id);
 131
 132         for(CORBA::ULong iFieldseries=0; iFieldseries<fieldseriesHandlerList->length(); iFieldseries++) {
 133           MEDCALC::FieldseriesHandler fieldseriesHandler = (*fieldseriesHandlerList)[iFieldseries];
 134           SALOMEDS::SObject_var soFieldseries = studyBuilder->NewObject(soMesh);
 135           _fieldSeriesEntries[fieldseriesHandler.id] = soFieldseries->GetID();
 136
 137           std::string label(fieldseriesHandler.name);
 138           label +=" ("+std::string(mapTypeOfFieldLabel[fieldseriesHandler.type])+")";
 139           soFieldseries->SetAttrString("AttributeName", label.c_str());
 140           soFieldseries->SetAttrString("AttributePixMap", "ICO_DATASOURCE_FIELD");
 141           anAttr = studyBuilder->FindOrCreateAttribute(soFieldseries, "AttributeParameter");
 142           aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 143           aParam->SetInt(FIELD_SERIES_ID, fieldseriesHandler.id);
 144           //aParam->SetInt(FIELD_ID, fieldseriesHandler.id);
 145           aParam->SetBool(IS_IN_WORKSPACE, false);
 146
 147           useCaseBuilder->AppendTo(soFieldseries->GetFather(), soFieldseries);
 148           soFieldseries->UnRegister();
 149         }
 150         soMesh->UnRegister();
 151       }
 152
 153       // cleanup
 154       father->UnRegister();
 155       soDatasource->UnRegister();
 156     }
 157   }
 158
 159   return MED_ORB::OP_OK;
 160 }
 161
 162 MED_ORB::status
 163 MED::registerPresentationField(CORBA::Long fieldId,
 164                                const char* name,
 165                                const char* type,
 166                                const char* ico,
 167                                CORBA::Long presentationId)
 168 {
 169   // set exception handler to catch unexpected CORBA exceptions
 170   Unexpect aCatch(SALOME_SalomeException);
 171
 172   MEDCALC::FieldHandler_var fldHandler = MEDFactoryClient::getDataManager()->getFieldHandler(fieldId);
 173   int fieldSeriesId = fldHandler->fieldseriesId;
 174   if (fieldSeriesId < 0){
 175       std::cerr << "MED::registerPresentationField(): Error getting field handler\n";
 176       return MED_ORB::OP_ERROR ;
 177     }
 178
 179   if (_fieldSeriesEntries.find(fieldSeriesId) == _fieldSeriesEntries.end()) {
 180     std::cerr << "MED::registerPresentationField(): Field series not found\n";
 181     return MED_ORB::OP_ERROR ;
 182   }
 183   std::string entry = _fieldSeriesEntries[fieldSeriesId];
 184   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 185   SALOMEDS::SObject_var sobject = aStudy->FindObjectID(entry.c_str());
 186   SALOMEDS::SObject_ptr soFieldseries = sobject._retn();
 187
 188   if (soFieldseries->IsNull()) {
 189     std::cerr << "MED::registerPresentationField(): Entry not found\n";
 190     return MED_ORB::OP_ERROR;
 191   }
 192
 193   SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
 194   SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
 195   SALOMEDS::SObject_var soPresentation = studyBuilder->NewObject(soFieldseries);
 196   useCaseBuilder->AppendTo(soPresentation->GetFather(), soPresentation);
 197
 198   soPresentation->SetAttrString("AttributeName", name);
 199   soPresentation->SetAttrString("AttributePixMap", ico);
 200
 201   SALOMEDS::GenericAttribute_var anAttr;
 202   SALOMEDS::AttributeParameter_var aParam;
 203   anAttr = studyBuilder->FindOrCreateAttribute(soPresentation, "AttributeParameter");
 204   aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 205   aParam->SetInt(FIELD_ID, fieldId);
 206   aParam->SetBool(IS_PRESENTATION, true);
 207   aParam->SetInt(PRESENTATION_ID, presentationId);
 208   aParam->SetString(PRESENTATION_TYPE, type);
 209
 210   return MED_ORB::OP_OK;
 211 }
 212
 213 MED_ORB::status
 214 MED::registerPresentationMesh(CORBA::Long meshId,
 215                               const char* name,
 216                               const char* type,
 217                               const char* ico,
 218                               CORBA::Long presentationId)
 219 {
 220   // set exception handler to catch unexpected CORBA exceptions
 221   Unexpect aCatch(SALOME_SalomeException);
 222
 223   MEDCALC::MeshHandler_var meshHandler = MEDFactoryClient::getDataManager()->getMeshHandler(meshId);
 224   if (meshHandler->id < 0){
 225       std::cerr << "MED::registerPresentationMesh(): Error getting mesh handler\n";
 226       return MED_ORB::OP_ERROR ;
 227     }
 228
 229   if (_meshEntries.find(meshHandler->id) == _meshEntries.end()) {
 230     std::cerr << "MED::registerPresentationMesh(): mesh not found\n";
 231     return MED_ORB::OP_ERROR ;
 232   }
 233   std::string entry = _meshEntries[meshHandler->id];
 234   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 235   SALOMEDS::SObject_var sobject = aStudy->FindObjectID(entry.c_str());
 236   SALOMEDS::SObject_ptr soMesh = sobject._retn();
 237
 238   if (soMesh->IsNull()) {
 239     std::cerr << "MED::registerPresentationMesh(): Entry not found\n";
 240     return MED_ORB::OP_ERROR;
 241   }
 242
 243   SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
 244   SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
 245   SALOMEDS::SObject_var soPresentation = studyBuilder->NewObject(soMesh);
 246   useCaseBuilder->AppendTo(soPresentation->GetFather(), soPresentation);
 247
 248   soPresentation->SetAttrString("AttributeName", name);
 249   soPresentation->SetAttrString("AttributePixMap", ico);
 250
 251   SALOMEDS::GenericAttribute_var anAttr;
 252   SALOMEDS::AttributeParameter_var aParam;
 253   anAttr = studyBuilder->FindOrCreateAttribute(soPresentation, "AttributeParameter");
 254   aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 255   aParam->SetInt(MESH_ID, meshId);
 256   aParam->SetBool(IS_PRESENTATION, true);
 257   aParam->SetInt(PRESENTATION_ID, presentationId);
 258   aParam->SetString(PRESENTATION_TYPE, type);
 259
 260   return MED_ORB::OP_OK;
 261 }
 262
 263
 264 MED_ORB::status
 265 MED::unregisterPresentation(CORBA::Long presentationId)
 266 {
 267   // set exception handler to catch unexpected CORBA exceptions
 268   Unexpect aCatch(SALOME_SalomeException);
 269
 270   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 271   SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
 272   SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
 273
 274   SALOMEDS::GenericAttribute_var anAttribute;
 275   SALOMEDS::SComponent_var father = aStudy->FindComponent("MED");
 276   SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(father);
 277   for (it->InitEx(true); it->More(); it->Next()) {
 278     SALOMEDS::SObject_var child(it->Value());
 279
 280     if (child->FindAttribute(anAttribute, "AttributeParameter")) {
 281       SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 282       if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 283         continue;
 284
 285       if (presentationId == attrParam->GetInt(PRESENTATION_ID)) {
 286         // remove object from study
 287         studyBuilder->RemoveObjectWithChildren(child);
 288         // remove object from use case tree
 289         useCaseBuilder->Remove(child);
 290       }
 291     }
 292   }
 293
 294   return MED_ORB::OP_OK;
 295 }
 296
 297 MED_ORB::PresentationsList*
 298 MED::getStudyPresentations()
 299 {
 300   // set exception handler to catch unexpected CORBA exceptions
 301   Unexpect aCatch(SALOME_SalomeException);
 302
 303   MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList;
 304
 305   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 306   SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
 307   SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
 308
 309   SALOMEDS::GenericAttribute_var anAttribute;
 310   SALOMEDS::SComponent_var father = aStudy->FindComponent("MED");
 311   SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(father);
 312   for (it->InitEx(true); it->More(); it->Next())
 313     {
 314       SALOMEDS::SObject_var child(it->Value());
 315       if (child->FindAttribute(anAttribute, "AttributeParameter"))
 316         {
 317           SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 318           if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 319             continue;
 320
 321           CORBA::ULong size = presList->length();
 322           presList->length(size+1);
 323           (*presList)[size] = attrParam->GetInt(PRESENTATION_ID);
 324         }
 325     }
 326   return presList;
 327 }
 328
 329 char*
 330 MED::getStudyPresentationEntry(CORBA::Long presentationId)
 331 {
 332   // set exception handler to catch unexpected CORBA exceptions
 333   Unexpect aCatch(SALOME_SalomeException);
 334
 335   MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList;
 336
 337   SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
 338   SALOMEDS::StudyBuilder_var studyBuilder = aStudy->NewBuilder();
 339   SALOMEDS::UseCaseBuilder_var useCaseBuilder = aStudy->GetUseCaseBuilder();
 340
 341   SALOMEDS::GenericAttribute_var anAttribute;
 342   SALOMEDS::SComponent_var father = aStudy->FindComponent("MED");
 343   SALOMEDS::ChildIterator_var it = aStudy->NewChildIterator(father);
 344   for (it->InitEx(true); it->More(); it->Next())
 345     {
 346       SALOMEDS::SObject_var child(it->Value());
 347       if (child->FindAttribute(anAttribute, "AttributeParameter"))
 348         {
 349           SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 350           if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 351             continue;
 352
 353           if (attrParam->GetInt(PRESENTATION_ID) == presentationId)
 354             return CORBA::string_dup(child->GetID());
 355         }
 356     }
 357   return CORBA::string_dup("");
 358 }
 359
 360
 361 Engines::TMPFile*
 362 MED::DumpPython(CORBA::Boolean isPublished,
 363                 CORBA::Boolean isMultiFile,
 364                 CORBA::Boolean& isValidScript)
 365 {
 366   SALOMEDS::SObject_var aSO = KERNEL::getStudyServant()->FindComponent("MED");
 367   if(CORBA::is_nil(aSO)) {
 368     std::cerr << "Error: Cannot find component MED\n";
 369     return new Engines::TMPFile(0);
 370   }
 371
 372   std::string aScript;
 373
 374   MEDCALC::CommandsList* history = MEDFactoryClient::getCommandsHistoryManager()->getCommandsHistory();
 375   for (CORBA::ULong i = 0; i < history->length(); ++i) {
 376     aScript += (*history)[i];
 377     aScript += "\n";
 378   }
 379
 380   int aLen = aScript.size();
 381   unsigned char* aBuffer = new unsigned char[aLen+1];
 382   strcpy((char*)aBuffer, aScript.c_str());
 383
 384   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)aBuffer;
 385   Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1);
 386
 387   isValidScript = true;
 388   return aStreamFile._retn();
 389 }
 390
 391 CORBA::Boolean
 392 MED::hasObjectInfo()
 393 {
 394   return true;
 395 }
 396
 397 char*
 398 MED::getObjectInfo(const char* entry)
 399 {
 400   SALOMEDS::SObject_var aSObj = KERNEL::getStudyServant()->FindObjectID( entry );
 401   SALOMEDS::SObject_var aResultSObj;
 402   if (aSObj->ReferencedObject(aResultSObj))
 403     aSObj = aResultSObj;
 404
 405   if (aSObj->_is_nil())
 406     return CORBA::string_dup("unknown");
 407
 408   SALOMEDS::GenericAttribute_var anAttribute;
 409
 410   std::string name("unknown");
 411   if (aSObj->FindAttribute(anAttribute, "AttributeName")) {
 412     SALOMEDS::AttributeName_var attrName = SALOMEDS::AttributeName::_narrow(anAttribute);
 413     name = std::string(attrName->Value());
 414   }
 415
 416   bool isInWorkspace = false;
 417   //bool isPresentation = false;
 418   int sourceId = -1;
 419   int meshId = -1;
 420   int fieldSeriesId = -1;
 421   int fieldId = -1;
 422   int presentationId = -1;
 423   if (aSObj->FindAttribute(anAttribute, "AttributeParameter")) {
 424     SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 425     if (attrParam->IsSet(IS_IN_WORKSPACE, PT_BOOLEAN))
 426       isInWorkspace = attrParam->GetBool(IS_IN_WORKSPACE);
 427     //if (attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN))
 428     //  isPresentation = attrParam->GetBool(IS_PRESENTATION);
 429     if (attrParam->IsSet(SOURCE_ID, PT_INTEGER))
 430       sourceId = attrParam->GetInt(SOURCE_ID);
 431     if (attrParam->IsSet(MESH_ID, PT_INTEGER))
 432       meshId = attrParam->GetInt(MESH_ID);
 433     if (attrParam->IsSet(FIELD_SERIES_ID, PT_INTEGER))
 434       fieldSeriesId = attrParam->GetInt(FIELD_SERIES_ID);
 435     if (attrParam->IsSet(FIELD_ID, PT_INTEGER))
 436       fieldId = attrParam->GetInt(FIELD_ID);
 437     if (attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 438       presentationId = attrParam->GetInt(PRESENTATION_ID);
 439   }
 440
 441   if (!aSObj->_is_nil() )
 442     aSObj->UnRegister();
 443
 444   std::ostringstream oss;
 445   if (sourceId > -1)
 446     oss << "Source id: " << sourceId << std::endl;
 447   if (meshId > -1)
 448     oss << "Mesh id: " << meshId << std::endl;
 449   if (fieldSeriesId > -1)
 450     oss << "Field series id: " << fieldSeriesId << std::endl;
 451   if (fieldId > -1)
 452     oss << "Field id: " << fieldId << std::endl;
 453   //oss << "Is presentation: " << isPresentation << std::endl;
 454   if (presentationId > -1)
 455     oss << "Presentation id: " << presentationId << std::endl;
 456   oss << "Is in workspace: " << isInWorkspace << std::endl;
 457
 458   return CORBA::string_dup(oss.str().c_str());
 459 }
 460
 461 void MED::cleanUp()
 462 {
 463   _fieldSeriesEntries.clear();
 464   _meshEntries.clear();
 465 }
 466
 467 extern "C"
 468 {
 469   /*!
 470     \brief Exportable factory function: create an instance of the MED component engine
 471     \param orb reference to the ORB
 472     \param poa reference to the POA
 473     \param contId CORBA object ID, pointing to the owner SALOME container
 474     \param instanceName SALOME component instance name
 475     \param interfaceName SALOME component interface name
 476     \return CORBA object identifier of the registered servant
 477   */
 478   PortableServer::ObjectId* MEDEngine_factory(CORBA::ORB_ptr orb,
 479                                               PortableServer::POA_ptr poa,
 480                                               PortableServer::ObjectId* contId,
 481                                               const char* instanceName,
 482                                               const char* interfaceName)
 483   {
 484     MED* component = new MED(orb, poa, contId, instanceName, interfaceName);
 485     return component->getId();
 486   }
 487 }