src/HOMARD_I/HOMARD_Boundary_i.cxx

   1 // Copyright (C) 2011-2013  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.
   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 // Remarques :
  20 // L'ordre de description des fonctions est le meme dans tous les fichiers
  21 // HOMARD_aaaa.idl, HOMARD_aaaa.hxx, HOMARD_aaaa.cxx, HOMARD_aaaa_i.hxx, HOMARD_aaaa_i.cxx :
  22 // 1. Les generalites : Name, Delete, DumpPython, Dump, Restore
  23 // 2. Les caracteristiques
  24 // 3. Le lien avec les autres structures
  25 //
  26 // Quand les 2 fonctions Setxxx et Getxxx sont presentes, Setxxx est decrit en premier
  27 //
  28 #include "HOMARD_Boundary_i.hxx"
  29 #include "HOMARD_Gen_i.hxx"
  30 #include "HOMARD_Boundary.hxx"
  31 #include "HOMARD_DriverTools.hxx"
  32
  33 #include "utilities.h"
  34
  35 //=============================================================================
  36 /*!
  37  *  standard constructor
  38  */
  39 //=============================================================================
  40 HOMARD_Boundary_i::HOMARD_Boundary_i()
  41 {
  42   MESSAGE( "Default constructor, not for use" );
  43   ASSERT( 0 );
  44 }
  45 //=============================================================================
  46 /*!
  47  *  standard constructor
  48  */
  49 //=============================================================================
  50 HOMARD_Boundary_i::HOMARD_Boundary_i( CORBA::ORB_ptr orb,
  51                               HOMARD::HOMARD_Gen_var engine )
  52 {
  53   MESSAGE( "HOMARD_Boundary_i" );
  54   _gen_i = engine;
  55   _orb = orb;
  56   myHomardBoundary = new ::HOMARD_Boundary();
  57   ASSERT( myHomardBoundary );
  58 }
  59 //=============================================================================
  60 /*!
  61  *  standard destructor
  62  */
  63 //=============================================================================
  64 HOMARD_Boundary_i::~HOMARD_Boundary_i()
  65 {
  66 }
  67 //=============================================================================
  68 //=============================================================================
  69 // Generalites
  70 //=============================================================================
  71 //=============================================================================
  72 void HOMARD_Boundary_i::SetName( const char* Name )
  73 {
  74   ASSERT( myHomardBoundary );
  75   myHomardBoundary->SetName( Name );
  76 }
  77 //=============================================================================
  78 char* HOMARD_Boundary_i::GetName()
  79 {
  80   ASSERT( myHomardBoundary );
  81   return CORBA::string_dup( myHomardBoundary->GetName().c_str() );
  82 }
  83 //=============================================================================
  84 CORBA::Long  HOMARD_Boundary_i::Delete()
  85 {
  86   ASSERT( myHomardBoundary );
  87   char* BoundaryName = GetName() ;
  88   MESSAGE ( "Delete : destruction de la frontiere " << BoundaryName );
  89   return _gen_i->DeleteBoundary(BoundaryName) ;
  90 }
  91 //=============================================================================
  92 char* HOMARD_Boundary_i::GetDumpPython()
  93 {
  94   ASSERT( myHomardBoundary );
  95   return CORBA::string_dup( myHomardBoundary->GetDumpPython().c_str() );
  96 }
  97 //=============================================================================
  98 std::string HOMARD_Boundary_i::Dump() const
  99 {
 100   return HOMARD::Dump( *myHomardBoundary );
 101 }
 102 //=============================================================================
 103 bool HOMARD_Boundary_i::Restore( const std::string& stream )
 104 {
 105   return HOMARD::Restore( *myHomardBoundary, stream );
 106 }
 107 //=============================================================================
 108 //=============================================================================
 109 // Caracteristiques
 110 //=============================================================================
 111 //=============================================================================
 112 void HOMARD_Boundary_i::SetType( CORBA::Long Type )
 113 {
 114   ASSERT( myHomardBoundary );
 115   myHomardBoundary->SetType( Type );
 116 }
 117 //=============================================================================
 118 CORBA::Long HOMARD_Boundary_i::GetType()
 119 {
 120   ASSERT( myHomardBoundary );
 121   return  CORBA::Long( myHomardBoundary->GetType() );
 122 }
 123 //=============================================================================
 124 void HOMARD_Boundary_i::SetMeshName( const char* MeshName )
 125 {
 126   ASSERT( myHomardBoundary );
 127   myHomardBoundary->SetMeshName( MeshName );
 128 }
 129 //=============================================================================
 130 char* HOMARD_Boundary_i::GetMeshName()
 131 {
 132   ASSERT( myHomardBoundary );
 133   return CORBA::string_dup( myHomardBoundary->GetMeshName().c_str() );
 134 }
 135 //=============================================================================
 136 void HOMARD_Boundary_i::SetMeshFile( const char* MeshFile )
 137 {
 138   ASSERT( myHomardBoundary );
 139   myHomardBoundary->SetMeshFile( MeshFile );
 140   int PublisMeshIN = _gen_i->GetPublisMeshIN () ;
 141   if ( PublisMeshIN != 0 ) { _gen_i->PublishResultInSmesh(MeshFile, 0); }
 142 }
 143 //=============================================================================
 144 char* HOMARD_Boundary_i::GetMeshFile()
 145 {
 146   ASSERT( myHomardBoundary );
 147   return CORBA::string_dup( myHomardBoundary->GetMeshFile().c_str() );
 148 }
 149 //=============================================================================
 150 void HOMARD_Boundary_i::SetCylinder( double X0, double X1, double X2, double X3, double X4, double X5, double X6 )
 151 {
 152   ASSERT( myHomardBoundary );
 153   myHomardBoundary->SetCylinder( X0, X1, X2, X3, X4, X5, X6 );
 154 }
 155 //=============================================================================
 156 void HOMARD_Boundary_i::SetSphere( double Xcentre, double Ycentre, double ZCentre, double rayon )
 157 {
 158   ASSERT( myHomardBoundary );
 159   myHomardBoundary->SetSphere( Xcentre, Ycentre, ZCentre, rayon );
 160 }
 161 //=============================================================================
 162 void HOMARD_Boundary_i::SetConeR( double Xcentre1, double Ycentre1, double Zcentre1, double Rayon1, double Xcentre2, double Ycentre2, double Zcentre2, double Rayon2)
 163 {
 164   ASSERT( myHomardBoundary );
 165   myHomardBoundary->SetConeR( Xcentre1, Ycentre1, Zcentre1, Rayon1, Xcentre2, Ycentre2, Zcentre2, Rayon2 );
 166 }
 167 //=============================================================================
 168 void HOMARD_Boundary_i::SetConeA( double Xaxe, double Yaxe, double Zaxe, double Angle, double Xcentre, double Ycentre, double Zcentre)
 169 {
 170   ASSERT( myHomardBoundary );
 171   myHomardBoundary->SetConeA( Xaxe, Yaxe, Zaxe, Angle, Xcentre, Ycentre, Zcentre );
 172 }
 173 //=============================================================================
 174 HOMARD::double_array* HOMARD_Boundary_i::GetCoords()
 175 {
 176   ASSERT( myHomardBoundary );
 177   HOMARD::double_array_var aResult = new HOMARD::double_array();
 178   std::vector<double> mesCoor = myHomardBoundary->GetCoords();
 179   aResult->length( mesCoor .size() );
 180   std::vector<double>::const_iterator it;
 181   int i = 0;
 182   for ( it = mesCoor.begin(); it != mesCoor.end(); it++ )
 183     aResult[i++] = (*it);
 184   return aResult._retn();
 185 }
 186 //=============================================================================
 187 void HOMARD_Boundary_i::SetLimit( double Xincr, double Yincr, double Zincr )
 188 {
 189   ASSERT( myHomardBoundary );
 190   myHomardBoundary->SetLimit( Xincr, Yincr, Zincr );
 191 }
 192 //=============================================================================
 193 HOMARD::double_array* HOMARD_Boundary_i::GetLimit()
 194 {
 195   ASSERT( myHomardBoundary );
 196   HOMARD::double_array_var aResult = new HOMARD::double_array();
 197   std::vector<double> mesCoor = myHomardBoundary->GetLimit();
 198   aResult->length( mesCoor .size() );
 199   std::vector<double>::const_iterator it;
 200   int i = 0;
 201   for ( it = mesCoor.begin(); it != mesCoor.end(); it++ )
 202     aResult[i++] = (*it);
 203   return aResult._retn();
 204 }
 205 //=============================================================================
 206 void HOMARD_Boundary_i::AddGroup( const char* Group)
 207 {
 208   ASSERT( myHomardBoundary );
 209   myHomardBoundary->AddGroup( Group );
 210 }
 211 //=============================================================================
 212 void HOMARD_Boundary_i::SetGroups(const HOMARD::ListGroupType& ListGroup)
 213 {
 214   ASSERT( myHomardBoundary );
 215   std::list<std::string> ListString;
 216   for ( int i = 0; i < ListGroup.length(); i++ )
 217   {
 218       ListString.push_back(std::string(ListGroup[i]));
 219   }
 220   myHomardBoundary->SetGroups( ListString );
 221 }
 222 //=============================================================================
 223 HOMARD::ListGroupType*  HOMARD_Boundary_i::GetGroups()
 224 {
 225   ASSERT( myHomardBoundary );
 226   const std::list<std::string>& ListString = myHomardBoundary->GetGroups();
 227   HOMARD::ListGroupType_var aResult = new HOMARD::ListGroupType;
 228   aResult->length( ListString.size() );
 229   std::list<std::string>::const_iterator it;
 230   int i = 0;
 231   for ( it = ListString.begin(); it != ListString.end(); it++ )
 232   {
 233     aResult[i++] = CORBA::string_dup( (*it).c_str() );
 234   }
 235   return aResult._retn();
 236 }
 237 //=============================================================================
 238 //=============================================================================
 239 // Liens avec les autres structures
 240 //=============================================================================
 241 //=============================================================================
 242 void HOMARD_Boundary_i::SetCaseCreation( const char* NomCaseCreation )
 243 {
 244   ASSERT( myHomardBoundary );
 245   myHomardBoundary->SetCaseCreation( NomCaseCreation );
 246 }
 247 //=============================================================================
 248 char* HOMARD_Boundary_i::GetCaseCreation()
 249 {
 250   ASSERT( myHomardBoundary );
 251   return CORBA::string_dup( myHomardBoundary->GetCaseCreation().c_str() );
 252 }
 253
 254
 255