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
  33 #include <string>
  34 #include <sstream>
  35
  36 /*!
  37   \brief Constructor
  38
  39   Creates an instance of the MED component engine
  40
  41   \param orb reference to the ORB
  42   \param poa reference to the POA
  43   \param contId CORBA object ID, pointing to the owner SALOME container
  44   \param instanceName SALOME component instance name
  45   \param interfaceName SALOME component interface name
  46 */
  47 MED::MED(CORBA::ORB_ptr orb,
  48          PortableServer::POA_ptr poa,
  49          PortableServer::ObjectId* contId,
  50          const char* instanceName,
  51          const char* interfaceName)
  52   : Engines_Component_i(orb, poa, contId, instanceName, interfaceName),
  53     _fieldSeriesEntries()
  54 {
  55   _thisObj = this;
  56   _id = _poa->activate_object(_thisObj); // register and activate this servant object
  57 }
  58
  59 MED::~MED()
  60 {
  61   // nothing to do
  62 }
  63
  64 MED_ORB::status
  65 MED::addDatasourceToStudy(SALOMEDS::Study_ptr study,
  66                           const MEDCALC::DatasourceHandler& datasourceHandler)
  67 {
  68   // set exception handler to catch unexpected CORBA exceptions
  69   Unexpect aCatch(SALOME_SalomeException);
  70
  71   // check if reference to study is valid
  72   if (!CORBA::is_nil(study)) {
  73     // get full object path
  74     std::string fullName = CORBA::string_dup(datasourceHandler.name);
  75     // check if the object with the same name is already registered in the study
  76     SALOMEDS::SObject_var sobj = study->FindObjectByPath(fullName.c_str());
  77     if (CORBA::is_nil(sobj)) {
  78       // object is not registered yet -> register
  79       SALOMEDS::GenericAttribute_var anAttr;
  80       SALOMEDS::AttributeParameter_var aParam;
  81       SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
  82       SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
  83
  84       // find MED component; create it if not found
  85       SALOMEDS::SComponent_var father = study->FindComponent("MED");
  86       if (CORBA::is_nil(father)) {
  87         // create component
  88         father = studyBuilder->NewComponent("MED");
  89         // set name attribute
  90         father->SetAttrString("AttributeName", "MEDCalc");
  91         // set icon attribute
  92         father->SetAttrString("AttributePixMap", "ICO_MED");
  93         // register component in the study
  94         studyBuilder->DefineComponentInstance(father, MED_Gen::_this());
  95         // add component to the use case tree
  96         // (to support tree representation customization and drag-n-drop)
  97         useCaseBuilder->SetRootCurrent();
  98         useCaseBuilder->Append(father); // component object is added as the top level item
  99       }
 100
 101       // create new sub-object, as a child of the component object
 102       SALOMEDS::SObject_var soDatasource = studyBuilder->NewObject(father);
 103       soDatasource->SetAttrString("AttributeName", fullName.c_str());
 104       soDatasource->SetAttrString("AttributePixMap", "ICO_DATASOURCE");
 105       anAttr = studyBuilder->FindOrCreateAttribute(soDatasource, "AttributeParameter");
 106       aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 107       aParam->SetInt(SOURCE_ID, datasourceHandler.id);
 108       useCaseBuilder->AppendTo(soDatasource->GetFather(), soDatasource);
 109
 110       // We can add the meshes as children of the datasource
 111       MEDCALC::MeshHandlerList* meshHandlerList =
 112         MEDFactoryClient::getDataManager()->getMeshList(datasourceHandler.id);
 113
 114       for(CORBA::ULong iMesh=0; iMesh<meshHandlerList->length(); iMesh++) {
 115         MEDCALC::MeshHandler meshHandler = (*meshHandlerList)[iMesh];
 116         SALOMEDS::SObject_var soMesh = studyBuilder->NewObject(soDatasource);
 117         soMesh->SetAttrString("AttributeName", meshHandler.name);
 118         soMesh->SetAttrString("AttributePixMap", "ICO_DATASOURCE_MESH");
 119         anAttr = studyBuilder->FindOrCreateAttribute(soMesh, "AttributeParameter");
 120         aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 121         aParam->SetInt(MESH_ID, meshHandler.id);
 122         aParam->SetBool(IS_IN_WORKSPACE, false);
 123         useCaseBuilder->AppendTo(soMesh->GetFather(), soMesh);
 124
 125         // We add the field timeseries defined on this mesh, as children of the mesh SObject
 126         MEDCALC::FieldseriesHandlerList * fieldseriesHandlerList =
 127           MEDFactoryClient::getDataManager()->getFieldseriesListOnMesh(meshHandler.id);
 128
 129         for(CORBA::ULong iFieldseries=0; iFieldseries<fieldseriesHandlerList->length(); iFieldseries++) {
 130           MEDCALC::FieldseriesHandler fieldseriesHandler = (*fieldseriesHandlerList)[iFieldseries];
 131           SALOMEDS::SObject_var soFieldseries = studyBuilder->NewObject(soMesh);
 132           _fieldSeriesEntries[fieldseriesHandler.id] = soFieldseries->GetID();
 133
 134           std::string label(fieldseriesHandler.name);
 135           label +=" ("+std::string(mapTypeOfFieldLabel[fieldseriesHandler.type])+")";
 136           soFieldseries->SetAttrString("AttributeName", label.c_str());
 137           soFieldseries->SetAttrString("AttributePixMap", "ICO_DATASOURCE_FIELD");
 138           anAttr = studyBuilder->FindOrCreateAttribute(soFieldseries, "AttributeParameter");
 139           aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 140           aParam->SetInt(FIELD_SERIES_ID, fieldseriesHandler.id);
 141           //aParam->SetInt(FIELD_ID, fieldseriesHandler.id);
 142           aParam->SetBool(IS_IN_WORKSPACE, false);
 143
 144           useCaseBuilder->AppendTo(soFieldseries->GetFather(), soFieldseries);
 145           soFieldseries->UnRegister();
 146         }
 147         soMesh->UnRegister();
 148       }
 149
 150       // cleanup
 151       father->UnRegister();
 152       soDatasource->UnRegister();
 153     }
 154   }
 155
 156   return MED_ORB::OP_OK;
 157 }
 158
 159 MED_ORB::status
 160 MED::registerPresentation(SALOMEDS::Study_ptr study,
 161                           CORBA::Long fieldId,
 162                           const char* name,
 163                           const char* type,
 164                           const char* ico,
 165                           CORBA::Long presentationId)
 166 {
 167   // set exception handler to catch unexpected CORBA exceptions
 168   Unexpect aCatch(SALOME_SalomeException);
 169
 170   MEDCALC::FieldHandler_var fldHandler = MEDFactoryClient::getDataManager()->getFieldHandler(fieldId);
 171   int fieldSeriesId = fldHandler->fieldseriesId;
 172   if (fieldSeriesId < 0){
 173       std::cerr << "MED::registerPresentation(): Error getting field handler\n";
 174       return MED_ORB::OP_ERROR ;
 175     }
 176
 177   if (_fieldSeriesEntries.find(fieldSeriesId) == _fieldSeriesEntries.end()) {
 178     std::cerr << "MED::registerPresentation(): Field series not found\n";
 179     return MED_ORB::OP_ERROR ;
 180   }
 181   std::string entry = _fieldSeriesEntries[fieldSeriesId];
 182   SALOMEDS::SObject_var sobject = study->FindObjectID(entry.c_str());
 183   SALOMEDS::SObject_ptr soFieldseries = sobject._retn();
 184
 185   if (soFieldseries->IsNull()) {
 186     std::cerr << "MED::registerPresentation(): Entry not found\n";
 187     return MED_ORB::OP_ERROR;
 188   }
 189
 190   SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
 191   SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
 192   SALOMEDS::SObject_var soPresentation = studyBuilder->NewObject(soFieldseries);
 193   useCaseBuilder->AppendTo(soPresentation->GetFather(), soPresentation);
 194
 195   soPresentation->SetAttrString("AttributeName", name);
 196   soPresentation->SetAttrString("AttributePixMap", ico);
 197
 198   SALOMEDS::GenericAttribute_var anAttr;
 199   SALOMEDS::AttributeParameter_var aParam;
 200   anAttr = studyBuilder->FindOrCreateAttribute(soPresentation, "AttributeParameter");
 201   aParam = SALOMEDS::AttributeParameter::_narrow(anAttr);
 202   aParam->SetInt(FIELD_ID, fieldId);
 203   aParam->SetBool(IS_PRESENTATION, true);
 204   aParam->SetInt(PRESENTATION_ID, presentationId);
 205   aParam->SetString(PRESENTATION_TYPE, type);
 206
 207   return MED_ORB::OP_OK;
 208 }
 209
 210 MED_ORB::status
 211 MED::unregisterPresentation(SALOMEDS::Study_ptr study,
 212                             CORBA::Long presentationId)
 213 {
 214   // set exception handler to catch unexpected CORBA exceptions
 215   Unexpect aCatch(SALOME_SalomeException);
 216
 217   SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
 218   SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
 219
 220   SALOMEDS::GenericAttribute_var anAttribute;
 221   SALOMEDS::SComponent_var father = study->FindComponent("MED");
 222   SALOMEDS::ChildIterator_var it = study->NewChildIterator(father);
 223   for (it->InitEx(true); it->More(); it->Next()) {
 224     SALOMEDS::SObject_var child(it->Value());
 225
 226     if (child->FindAttribute(anAttribute, "AttributeParameter")) {
 227       SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 228       if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 229         continue;
 230
 231       if (presentationId == attrParam->GetInt(PRESENTATION_ID)) {
 232         // remove object from study
 233         studyBuilder->RemoveObjectWithChildren(child);
 234         // remove object from use case tree
 235         useCaseBuilder->Remove(child);
 236       }
 237     }
 238   }
 239
 240   return MED_ORB::OP_OK;
 241 }
 242
 243 MED_ORB::PresentationsList*
 244 MED::getStudyPresentations(SALOMEDS::Study_ptr study)
 245 {
 246   // set exception handler to catch unexpected CORBA exceptions
 247   Unexpect aCatch(SALOME_SalomeException);
 248
 249   MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList;
 250
 251   SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
 252   SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
 253
 254   SALOMEDS::GenericAttribute_var anAttribute;
 255   SALOMEDS::SComponent_var father = study->FindComponent("MED");
 256   SALOMEDS::ChildIterator_var it = study->NewChildIterator(father);
 257   for (it->InitEx(true); it->More(); it->Next())
 258     {
 259       SALOMEDS::SObject_var child(it->Value());
 260       if (child->FindAttribute(anAttribute, "AttributeParameter"))
 261         {
 262           SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 263           if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 264             continue;
 265
 266           CORBA::ULong size = presList->length();
 267           presList->length(size+1);
 268           (*presList)[size] = attrParam->GetInt(PRESENTATION_ID);
 269         }
 270     }
 271   return presList;
 272 }
 273
 274
 275 MED_ORB::PresentationsList*
 276 MED::getSiblingPresentations(SALOMEDS::Study_ptr study, CORBA::Long presentationId)
 277 {
 278   // set exception handler to catch unexpected CORBA exceptions
 279   Unexpect aCatch(SALOME_SalomeException);
 280
 281   MED_ORB::PresentationsList* presList = new MED_ORB::PresentationsList;
 282
 283   SALOMEDS::StudyBuilder_var studyBuilder = study->NewBuilder();
 284   SALOMEDS::UseCaseBuilder_var useCaseBuilder = study->GetUseCaseBuilder();
 285
 286   SALOMEDS::GenericAttribute_var anAttribute;
 287   SALOMEDS::SComponent_var father = study->FindComponent("MED");
 288   SALOMEDS::ChildIterator_var it = study->NewChildIterator(father);
 289   for (it->InitEx(true); it->More(); it->Next()) {
 290     SALOMEDS::SObject_var child(it->Value());
 291
 292     if (child->FindAttribute(anAttribute, "AttributeParameter")) {
 293       SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 294       if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 295         continue;
 296
 297       if (presentationId == attrParam->GetInt(PRESENTATION_ID)) {
 298         // get siblings
 299         SALOMEDS::ChildIterator_var siblItr = study->NewChildIterator(child->GetFather());
 300         for (siblItr->InitEx(true); siblItr->More(); siblItr->Next()) {
 301           SALOMEDS::SObject_var sibl(siblItr->Value());
 302
 303           if (sibl->FindAttribute(anAttribute, "AttributeParameter")) {
 304             SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 305             if (!attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN) || !attrParam->GetBool(IS_PRESENTATION) || !attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 306               continue;
 307
 308             if (attrParam->GetInt(PRESENTATION_ID) != presentationId) {
 309               CORBA::ULong size = presList->length();
 310               presList->length(size+1);
 311               (*presList)[size] = attrParam->GetInt(PRESENTATION_ID);
 312             }
 313           }
 314         }
 315         return presList;
 316       }
 317     }
 318   }
 319
 320   return presList;
 321 }
 322
 323 Engines::TMPFile*
 324 MED::DumpPython(CORBA::Object_ptr theStudy,
 325                 CORBA::Boolean isPublished,
 326                 CORBA::Boolean isMultiFile,
 327                 CORBA::Boolean& isValidScript)
 328 {
 329   std::cout << "In MED::DumpPython\n";
 330
 331   SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow(theStudy);
 332   if(CORBA::is_nil(aStudy)) {
 333     std::cerr << "Error: Cannot find the study\n";
 334     return new Engines::TMPFile(0);
 335   }
 336
 337   SALOMEDS::SObject_var aSO = aStudy->FindComponent("MED");
 338   if(CORBA::is_nil(aSO)) {
 339     std::cerr << "Error: Cannot find component MED\n";
 340     return new Engines::TMPFile(0);
 341   }
 342
 343   std::string aScript;
 344
 345   MEDCALC::CommandsList* history = MEDFactoryClient::getCommandsHistoryManager()->getCommandsHistory();
 346   for (CORBA::ULong i = 0; i < history->length(); ++i) {
 347     aScript += (*history)[i];
 348     aScript += "\n";
 349   }
 350
 351   int aLen = aScript.size();
 352   unsigned char* aBuffer = new unsigned char[aLen+1];
 353   strcpy((char*)aBuffer, aScript.c_str());
 354
 355   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)aBuffer;
 356   Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1);
 357
 358   isValidScript = true;
 359   return aStreamFile._retn();
 360 }
 361
 362 CORBA::Boolean
 363 MED::hasObjectInfo()
 364 {
 365   return true;
 366 }
 367
 368 char*
 369 MED::getObjectInfo(CORBA::Long studyId, const char* entry)
 370 {
 371   SALOME_LifeCycleCORBA lcc;
 372   CORBA::Object_var aSMObject = lcc.namingService()->Resolve( "/myStudyManager" );
 373   SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow( aSMObject );
 374   SALOMEDS::Study_var aStudy = aStudyManager->GetStudyByID( studyId );
 375   SALOMEDS::SObject_var aSObj = aStudy->FindObjectID( entry );
 376   SALOMEDS::SObject_var aResultSObj;
 377   if (aSObj->ReferencedObject(aResultSObj))
 378     aSObj = aResultSObj;
 379
 380   if (aSObj->_is_nil())
 381     return CORBA::string_dup("unknown");
 382
 383   SALOMEDS::GenericAttribute_var anAttribute;
 384
 385   std::string name("unknown");
 386   if (aSObj->FindAttribute(anAttribute, "AttributeName")) {
 387     SALOMEDS::AttributeName_var attrName = SALOMEDS::AttributeName::_narrow(anAttribute);
 388     name = std::string(attrName->Value());
 389   }
 390
 391   bool isInWorkspace = false;
 392   //bool isPresentation = false;
 393   int sourceId = -1;
 394   int meshId = -1;
 395   int fieldSeriesId = -1;
 396   int fieldId = -1;
 397   int presentationId = -1;
 398   if (aSObj->FindAttribute(anAttribute, "AttributeParameter")) {
 399     SALOMEDS::AttributeParameter_var attrParam = SALOMEDS::AttributeParameter::_narrow(anAttribute);
 400     if (attrParam->IsSet(IS_IN_WORKSPACE, PT_BOOLEAN))
 401       isInWorkspace = attrParam->GetBool(IS_IN_WORKSPACE);
 402     //if (attrParam->IsSet(IS_PRESENTATION, PT_BOOLEAN))
 403     //  isPresentation = attrParam->GetBool(IS_PRESENTATION);
 404     if (attrParam->IsSet(SOURCE_ID, PT_INTEGER))
 405       sourceId = attrParam->GetInt(SOURCE_ID);
 406     if (attrParam->IsSet(MESH_ID, PT_INTEGER))
 407       meshId = attrParam->GetInt(MESH_ID);
 408     if (attrParam->IsSet(FIELD_SERIES_ID, PT_INTEGER))
 409       fieldSeriesId = attrParam->GetInt(FIELD_SERIES_ID);
 410     if (attrParam->IsSet(FIELD_ID, PT_INTEGER))
 411       fieldId = attrParam->GetInt(FIELD_ID);
 412     if (attrParam->IsSet(PRESENTATION_ID, PT_INTEGER))
 413       presentationId = attrParam->GetInt(PRESENTATION_ID);
 414   }
 415
 416   if (!aSObj->_is_nil() )
 417     aSObj->UnRegister();
 418
 419   std::ostringstream oss;
 420   if (sourceId > -1)
 421     oss << "Source id: " << sourceId << std::endl;
 422   if (meshId > -1)
 423     oss << "Mesh id: " << meshId << std::endl;
 424   if (fieldSeriesId > -1)
 425     oss << "Field series id: " << fieldSeriesId << std::endl;
 426   if (fieldId > -1)
 427     oss << "Field id: " << fieldId << std::endl;
 428   //oss << "Is presentation: " << isPresentation << std::endl;
 429   if (presentationId > -1)
 430     oss << "Presentation id: " << presentationId << std::endl;
 431   oss << "Is in workspace: " << isInWorkspace << std::endl;
 432
 433   return CORBA::string_dup(oss.str().c_str());
 434 }
 435
 436 extern "C"
 437 {
 438   /*!
 439     \brief Exportable factory function: create an instance of the MED component engine
 440     \param orb reference to the ORB
 441     \param poa reference to the POA
 442     \param contId CORBA object ID, pointing to the owner SALOME container
 443     \param instanceName SALOME component instance name
 444     \param interfaceName SALOME component interface name
 445     \return CORBA object identifier of the registered servant
 446   */
 447   PortableServer::ObjectId* MEDEngine_factory(CORBA::ORB_ptr orb,
 448                                               PortableServer::POA_ptr poa,
 449                                               PortableServer::ObjectId* contId,
 450                                               const char* instanceName,
 451                                               const char* interfaceName)
 452   {
 453     MED* component = new MED(orb, poa, contId, instanceName, interfaceName);
 454     return component->getId();
 455   }
 456 }