src/ADAPT_I/ADAPT_Gen_i.hxx

   1 // Copyright (C) 2011-2020  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 #ifndef _ADAPT_GEN_I_HXX_
  21 #define _ADAPT_GEN_I_HXX_
  22
  23 #include <SALOMEconfig.h>
  24 #include CORBA_SERVER_HEADER(ADAPT_Gen)
  25 #include CORBA_SERVER_HEADER(HOMARD_Cas)
  26 #include CORBA_SERVER_HEADER(HOMARD_Hypothesis)
  27 #include CORBA_SERVER_HEADER(HOMARD_Iteration)
  28 #include CORBA_SERVER_HEADER(HOMARD_Zone)
  29 #include CORBA_SERVER_HEADER(HOMARD_Boundary)
  30 #include CORBA_SERVER_HEADER(HOMARD_YACS)
  31 #include CORBA_CLIENT_HEADER(SALOMEDS)
  32 #include CORBA_CLIENT_HEADER(SALOMEDS_Attributes)
  33
  34 #include "HOMARD_i.hxx"
  35 #include "ADAPT_Gen.hxx"
  36 #include "HomardDriver.hxx"
  37 #include "YACSDriver.hxx"
  38 #include "FrontTrack.hxx"
  39 #include "SALOME_Component_i.hxx"
  40 #include "SALOME_NamingService.hxx"
  41 #include "Utils_CorbaException.hxx"
  42
  43 #include <string>
  44 #include <map>
  45
  46 class HOMARDENGINE_EXPORT ADAPT_Gen_i:
  47   public virtual Engines_Component_i,
  48   public virtual POA_ADAPT::ADAPT_Gen
  49 {
  50 public:
  51   ADAPT_Gen_i( CORBA::ORB_ptr orb,
  52                 PortableServer::POA_ptr poa,
  53                 PortableServer::ObjectId* contId,
  54                 const char* instanceName,
  55                 const char* interfaceName );
  56   virtual ~ADAPT_Gen_i();
  57
  58
  59 // Generalites
  60
  61 // Les creations
  62   ADAPT::HOMARD_Boundary_ptr     CreateBoundary (const char* nomBoundary, CORBA::Long typeBoundary);
  63   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryCAO(const char* nomBoundary,
  64                                                     const char* DataFile);
  65   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryDi (const char* nomBoundary,
  66                                                     const char* MeshName, const char* DataFile);
  67   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryCylinder (const char* nomBoundary,
  68                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre,
  69                                       CORBA::Double Xaxis, CORBA::Double Yaxis, CORBA::Double Zaxis,
  70                                       CORBA::Double Rayon);
  71   ADAPT::HOMARD_Boundary_ptr     CreateBoundarySphere (const char* nomBoundary,
  72                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre,
  73                                       CORBA::Double Rayon);
  74   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryConeR (const char* nomBoundary,
  75                                       CORBA::Double Xcentre1, CORBA::Double Ycentre1, CORBA::Double Zcentre1, CORBA::Double Rayon1,
  76                                       CORBA::Double Xcentre2, CORBA::Double Ycentre2, CORBA::Double Zcentre2, CORBA::Double Rayon2);
  77   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryConeA (const char* nomBoundary,
  78                                       CORBA::Double Xaxis, CORBA::Double Yaxis, CORBA::Double Zaxis, CORBA::Double Angle,
  79                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre);
  80   ADAPT::HOMARD_Boundary_ptr     CreateBoundaryTorus (const char* nomBoundary,
  81                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre,
  82                                       CORBA::Double Xaxis, CORBA::Double Yaxis, CORBA::Double Zaxis,
  83                                       CORBA::Double RayonRev, CORBA::Double RayonPri);
  84
  85   ADAPT::HOMARD_Cas_ptr          CreateCase (const char* nomCas, const char* MeshName, const char* FileName);
  86   ADAPT::HOMARD_Cas_ptr          CreateCaseFromIteration (const char* nomCas, const char* DirNameStart);
  87   ADAPT::HOMARD_Cas_ptr          CreateCaseFromCaseLastIteration (const char* nomCas, const char* DirNameStart);
  88   ADAPT::HOMARD_Cas_ptr          CreateCaseFromCaseIteration (const char* nomCas, const char* DirNameStart, CORBA::Long Number);
  89   ADAPT::HOMARD_Cas_ptr          CreateCase0 (const char* nomCas, const char* MeshName, const char* FileName, CORBA::Long MeshOption, CORBA::Long NumeIter, CORBA::Long Option);
  90   std::string                     CreateCase1 (const char* DirNameStart, CORBA::Long Number);
  91
  92   ADAPT::HOMARD_Hypothesis_ptr   CreateHypothesis(const char* nomHypothesis);
  93
  94   ADAPT::HOMARD_Iteration_ptr    CreateIteration (const char* nomIter, const char* nomIterParent);
  95
  96   ADAPT::HOMARD_Zone_ptr         CreateZone (const char* nomZone, CORBA::Long typeZone);
  97   ADAPT::HOMARD_Zone_ptr         CreateZoneBox (const char* nomZone,
  98                                       CORBA::Double Xmini, CORBA::Double Xmaxi,
  99                                       CORBA::Double Ymini, CORBA::Double Ymaxi,
 100                                       CORBA::Double Zmini, CORBA::Double Zmaxi);
 101   ADAPT::HOMARD_Zone_ptr         CreateZoneBox2D (const char* nomZone,
 102                                       CORBA::Double Umini, CORBA::Double Umaxi,
 103                                       CORBA::Double Vmini, CORBA::Double Vmaxi,
 104                                       CORBA::Long Orient);
 105   ADAPT::HOMARD_Zone_ptr         CreateZoneCylinder (const char* nomZone,
 106                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre,
 107                                       CORBA::Double Xaxe, CORBA::Double Yaxe, CORBA::Double Zaxe,
 108                                       CORBA::Double Rayon, CORBA::Double Haut);
 109   ADAPT::HOMARD_Zone_ptr         CreateZoneDisk (const char* nomZone,
 110                                       CORBA::Double Ucentre, CORBA::Double Vcentre,
 111                                       CORBA::Double Rayon,
 112                                       CORBA::Long Orient);
 113   ADAPT::HOMARD_Zone_ptr         CreateZoneDiskWithHole (const char* nomZone,
 114                                       CORBA::Double Ucentre, CORBA::Double Vcentre,
 115                                       CORBA::Double Rayon, CORBA::Double Rayonint,
 116                                       CORBA::Long Orient);
 117   ADAPT::HOMARD_Zone_ptr         CreateZonePipe (const char* nomZone,
 118                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre,
 119                                       CORBA::Double Xaxe, CORBA::Double Yaxe, CORBA::Double Zaxe,
 120                                       CORBA::Double Rayon, CORBA::Double Haut, CORBA::Double Rayonint);
 121   ADAPT::HOMARD_Zone_ptr         CreateZoneSphere (const char* nomZone,
 122                                       CORBA::Double Xcentre, CORBA::Double Ycentre, CORBA::Double Zcentre, CORBA::Double Rayon);
 123
 124 // Les informations
 125   ADAPT::HOMARD_Boundary_ptr     GetBoundary   (const char* nomBoundary);
 126   ADAPT::HOMARD_Cas_ptr          GetCase       (const char* nomCas);
 127   ADAPT::HOMARD_Hypothesis_ptr   GetHypothesis (const char* nomHypothesis);
 128   ADAPT::HOMARD_Iteration_ptr    GetIteration  (const char* nomIteration);
 129   ADAPT::HOMARD_YACS_ptr         GetYACS       (const char* nomYACS);
 130   ADAPT::HOMARD_Zone_ptr         GetZone       (const char* nomZone);
 131
 132   ADAPT::listeBoundarys*         GetAllBoundarysName();
 133   ADAPT::listeCases*             GetAllCasesName();
 134   ADAPT::listeHypotheses*        GetAllHypothesesName();
 135   ADAPT::listeIterations*        GetAllIterationsName();
 136   ADAPT::listeYACSs*             GetAllYACSsName();
 137   ADAPT::listeZones*             GetAllZonesName();
 138
 139   void                            MeshInfo      (const char* nomCas,
 140                                                  const char* MeshName, const char* FileName, const char* DirName,
 141                                                  CORBA::Long Qual, CORBA::Long Diam, CORBA::Long Conn, CORBA::Long Tail, CORBA::Long Inte);
 142
 143   ADAPT::HOMARD_Iteration_ptr    LastIteration  (const char* nomCas);
 144
 145 // L'etude
 146   void                            UpdateStudy();
 147   void                            IsValidStudy();
 148
 149 // Liens entre structures
 150   void                            InvalideBoundary(const char* nomBoundary);
 151   void                            InvalideHypo(const char* nomHypo);
 152   void                            InvalideIter(const char* nomIter);
 153   void                            InvalideIterOption(const char* nomIter, CORBA::Long Option);
 154   void                            InvalideIterInfo(const char* nomIter);
 155   void                            InvalideYACS(const char* nomYACS);
 156   void                            InvalideZone(const char* nomZone);
 157
 158   CORBA::Long                     DeleteBoundary(const char* nomBoundary);
 159   CORBA::Long                     DeleteCase(const char* nomCas, CORBA::Long Option);
 160   CORBA::Long                     DeleteHypo(const char* nomHypothesis);
 161   CORBA::Long                     DeleteIteration(const char* nomIter, CORBA::Long Option);
 162   CORBA::Long                     DeleteIterationOption(const char* nomIter, CORBA::Long Option1, CORBA::Long Option2);
 163   CORBA::Long                     DeleteYACS(const char* nomYACS, CORBA::Long Option);
 164   CORBA::Long                     DeleteZone(const char* nomZone);
 165
 166   void                            AssociateIterHypo(const char* nomIter, const char* nomHypothesis);
 167
 168   void                            AssociateHypoZone(const char* nomHypothesis, const char* nomZone, CORBA::Long TypeUse);
 169   void                            DissociateHypoZone(const char* nomHypothesis, const char* nomZone);
 170
 171   void                            AssociateCaseIter(const char* nomCas, const char* nomIter,
 172                                                     const char* labelIter);
 173
 174 // Actions
 175   void                            SetEtatIter(const char* nomIter,const CORBA::Long Etat);
 176   char*                           CreateDirNameIter(const char* nomrep, CORBA::Long num );
 177
 178   CORBA::Long                     Compute(const char* nomIteration, CORBA::Long etatMenage, CORBA::Long modeHOMARD, CORBA::Long Option1, CORBA::Long Option2);
 179   CORBA::Long                     ComputeAdap(ADAPT::HOMARD_Cas_var myCase, ADAPT::HOMARD_Iteration_var myIteration, CORBA::Long etatMenage, HomardDriver* myDriver, CORBA::Long Option1, CORBA::Long Option2);
 180   CORBA::Long                     ComputeCAO(ADAPT::HOMARD_Cas_var myCase, ADAPT::HOMARD_Iteration_var myIteration, CORBA::Long Option1, CORBA::Long Option2);
 181   CORBA::Long                     ComputeCAObis(ADAPT::HOMARD_Iteration_var myIteration, CORBA::Long Option1, CORBA::Long Option2);
 182   char*                           ComputeDirManagement(ADAPT::HOMARD_Cas_var myCase, ADAPT::HOMARD_Iteration_var myIteration, CORBA::Long etatMenage);
 183   char*                           ComputeDirPaManagement(ADAPT::HOMARD_Cas_var myCase, ADAPT::HOMARD_Iteration_var myIteration);
 184   void                            DriverTexteZone(ADAPT::HOMARD_Hypothesis_var myHypo, HomardDriver* myDriver);
 185   void                            DriverTexteField(ADAPT::HOMARD_Iteration_var myIteration, ADAPT::HOMARD_Hypothesis_var myHypo, HomardDriver* myDriver);
 186   int                             DriverTexteBoundary(ADAPT::HOMARD_Cas_var myCase, HomardDriver* myDriver);
 187   void                            DriverTexteFieldInterp(ADAPT::HOMARD_Iteration_var myIteration, ADAPT::HOMARD_Hypothesis_var myHypo, HomardDriver* myDriver);
 188
 189   char*                           VerifieDir(const char* nomDir);
 190
 191   void                            PublishFileUnderIteration(const char* NomIter, const char* NomFich, const char* Commentaire);
 192   void                            PublishFileUnderYACS(const char* NomYACS, const char* NomFich, const char* Commentaire);
 193   void                            PublishBoundaryUnderCase(const char* CaseName, const char* BoundaryName);
 194   void                            PublishCaseUnderYACS(const char* YACSName, const char* CaseName);
 195   void                            PublishResultInSmesh(const char* NomFich, CORBA::Long Option);
 196   void                            DeleteResultInSmesh(std::string NomFich, std::string MeshName);
 197   void                            PublishMeshIterInSmesh(const char* NomIter);
 198
 199 // YACS
 200   ADAPT::HOMARD_YACS_ptr         CreateYACSSchema (const char* YACSName, const char* nomCas, const char* ScriptFile, const char* DirName, const char* MeshFile);
 201   CORBA::Long                     YACSWrite(const char* nomYACS);
 202   CORBA::Long                     YACSWriteOnFile(const char* nomYACS, const char* XMLFile);
 203   std::string                     YACSDriverTexteZone(ADAPT::HOMARD_Hypothesis_var myHypo, YACSDriver* myDriver);
 204   std::string                     YACSDriverTexteBoundary(ADAPT::HOMARD_Cas_var myCase, YACSDriver* myDriver);
 205
 206 // Preferences
 207   void                            SetPreferences() ;
 208   void                            SetLanguageShort(const char* LanguageShort);
 209   char*                           GetLanguageShort();
 210   void                            SetPublisMesh(CORBA::Long PublisMeshIN, CORBA::Long PublisMeshOUT);
 211   CORBA::Long                     GetPublisMeshIN();
 212   CORBA::Long                     GetPublisMeshOUT();
 213   void                            SetYACSMaximum(CORBA::Long YACSMaxIter, CORBA::Long YACSMaxNode, CORBA::Long YACSMaxElem);
 214   CORBA::Long                     GetYACSMaxIter();
 215   CORBA::Long                     GetYACSMaxNode();
 216   CORBA::Long                     GetYACSMaxElem();
 217   void                            SetYACSConvergenceType(CORBA::Long YACSTypeTest);
 218   CORBA::Long                     GetYACSConvergenceType();
 219
 220
 221   // ---------------------------------------------------------------
 222   // next functions are inherited from SALOMEDS::Driver interface
 223   // ---------------------------------------------------------------
 224
 225   // --> Persistence
 226   virtual SALOMEDS::TMPFile*      Save(SALOMEDS::SComponent_ptr theComponent,
 227                                         const char* theURL,
 228                                         CORBA::Boolean isMultiFile);
 229
 230   virtual SALOMEDS::TMPFile*      SaveASCII(SALOMEDS::SComponent_ptr theComponent,
 231                                              const char* theURL,
 232                                              CORBA::Boolean isMultiFile);
 233
 234   virtual CORBA::Boolean          Load(SALOMEDS::SComponent_ptr theComponent,
 235                                         const SALOMEDS::TMPFile& theStream,
 236                                         const char* theURL,
 237                                         CORBA::Boolean isMultiFile);
 238
 239   virtual CORBA::Boolean          LoadASCII(SALOMEDS::SComponent_ptr theComponent,
 240                                              const SALOMEDS::TMPFile& theStream,
 241                                              const char* theURL,
 242                                              CORBA::Boolean isMultiFile);
 243
 244   virtual void                    Close(SALOMEDS::SComponent_ptr IORSComponent);
 245
 246   virtual char*                   ComponentDataType();
 247
 248   virtual char*                   IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
 249                                                           const char* IORString,
 250                                                           CORBA::Boolean isMultiFile,
 251                                                           CORBA::Boolean isASCII);
 252
 253   virtual char*                   LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
 254                                                           const char* aLocalPersistentID,
 255                                                           CORBA::Boolean isMultiFile,
 256                                                           CORBA::Boolean isASCII);
 257
 258   // --> Data publishing
 259   virtual CORBA::Boolean          CanPublishInStudy(CORBA::Object_ptr theIOR);
 260
 261   virtual SALOMEDS::SObject_ptr   PublishInStudy(SALOMEDS::SObject_ptr theSObject,
 262                                                  CORBA::Object_ptr theObject,
 263                                                  const char* theName);
 264
 265   // --> Copy/Paste
 266   virtual CORBA::Boolean          CanCopy(SALOMEDS::SObject_ptr theObject);
 267
 268   virtual SALOMEDS::TMPFile*      CopyFrom(SALOMEDS::SObject_ptr theObject,
 269                                             CORBA::Long& theObjectID);
 270
 271   virtual CORBA::Boolean          CanPaste(const char* theComponentName, CORBA::Long theObjectID);
 272
 273   virtual SALOMEDS::SObject_ptr   PasteInto(const SALOMEDS::TMPFile& theStream,
 274                                              CORBA::Long theObjectID,
 275                                              SALOMEDS::SObject_ptr theObject);
 276
 277 //   virtual void SALOMEException( std::string message );
 278
 279 private:
 280   SALOMEDS::SObject_ptr           PublishBoundaryInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
 281                                                      ADAPT::HOMARD_Boundary_ptr theObject, const char* theName);
 282   SALOMEDS::SObject_ptr           PublishCaseInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
 283                                                      ADAPT::HOMARD_Cas_ptr theObject, const char* theName);
 284   SALOMEDS::SObject_ptr           PublishHypotheseInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
 285                                                      ADAPT::HOMARD_Hypothesis_ptr theObject, const char* theName);
 286   SALOMEDS::SObject_ptr           PublishYACSInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
 287                                                      ADAPT::HOMARD_YACS_ptr theObject, const char* theName);
 288   SALOMEDS::SObject_ptr           PublishZoneInStudy(SALOMEDS::StudyBuilder_var aStudyBuilder,
 289                                                      ADAPT::HOMARD_Zone_ptr theObject, const char* theName);
 290   virtual void                    PublishInStudyAttr(SALOMEDS::StudyBuilder_var aStudyBuilder,
 291                                                      SALOMEDS::SObject_var aResultSO,
 292                                                      const char* theName, const char* comment, const char* icone, const char* ior);
 293
 294   PortableServer::ServantBase_var GetServant(CORBA::Object_ptr theObject);
 295
 296   ADAPT::HOMARD_Boundary_ptr     newBoundary();
 297   ADAPT::HOMARD_Cas_ptr          newCase();
 298   ADAPT::HOMARD_Hypothesis_ptr   newHypothesis();
 299   ADAPT::HOMARD_Iteration_ptr    newIteration();
 300   ADAPT::HOMARD_YACS_ptr         newYACS();
 301   ADAPT::HOMARD_Zone_ptr         newZone();
 302
 303
 304   virtual Engines::TMPFile*       DumpPython(CORBA::Boolean isPublished,
 305                                                                  CORBA::Boolean isMultiFile,
 306                                                                  CORBA::Boolean& isValidScript);
 307
 308   virtual char*                   getVersion();
 309   std::string GetStringInTexte( const std::string Texte, const std::string String, int option ) ;
 310
 311 private:
 312   struct StudyContext
 313   {
 314     std::map<std::string, ADAPT::HOMARD_Boundary_var>   _mesBoundarys;
 315     std::map<std::string, ADAPT::HOMARD_Cas_var>        _mesCas;
 316     std::map<std::string, ADAPT::HOMARD_Hypothesis_var> _mesHypotheses;
 317     std::map<std::string, ADAPT::HOMARD_Iteration_var>  _mesIterations;
 318     std::map<std::string, ADAPT::HOMARD_YACS_var>       _mesYACSs;
 319     std::map<std::string, ADAPT::HOMARD_Zone_var>       _mesZones;
 320     std::map<int, PortableServer::ServantBase*>          _idmap;
 321   };
 322
 323   ::ADAPT_Gen*                 myHomard;
 324   SALOMEDS::Study_var           myStudy;
 325   StudyContext                  myStudyContext;
 326   SALOME_NamingService*         _NS;
 327
 328   int _tag_gene ;
 329   int _tag_boun ;
 330   int _tag_hypo ;
 331   int _tag_yacs ;
 332   int _tag_zone ;
 333
 334 // Preferences
 335   std::string _Langue ;
 336   std::string _LangueShort ;
 337   int _PublisMeshIN ;
 338   int _PublisMeshOUT ;
 339   int _YACSMaxIter ;
 340   int _YACSMaxNode ;
 341   int _YACSMaxElem ;
 342   int _YACSTypeTest ;
 343  ;
 344
 345 };
 346
 347 #endif